企业官网建设流程全解析

1.replace（）函数：

str.replace(oldvalue, newvalue[, count])

1. oldvalue：将被替换的子字符串(必需)
2. newvalue：用于替换oldvalue的子字符串(必需)
3. count：数值次数，指定要替换多少个oldvalue(可选)

例：.replace("\n", "")：去掉所有换行符，确保数据是连续的

data = sys.stdin.read().replace("\n", "")

2.append()函数

例：向列表末尾添加元素

results = []

results.append(f"{A}:{B}")

f"{A}:{B}"格式化为"A:B"形式，比如"11:8"，然后存入results列表。

3.for _ in range(N):

循环执行N次。

• range(N)生成一个从0到N-1的序列。

• _表示我们不关心循环变量的值,即不需要使用循环变量

for _ in range(N):
m, v = map(int, input().split())
coins.append((m, v))

循环N次，每次读取一行输入，将其解析为两个整数m和v，然后将(m, v)添加到列表coins中。

4.sys.stdin.read

data = sys.stdin.read().split()

sys.stdin.read：读取所有输入数据，返回一个字符串。输入数据可能包含多行，使用sys.stdin.read可以一次性读取所有输入。

split()：将字符串按空格分割成列表。

5.列表推导式和enumerate（）

链接：洛谷 排队接水1223

times = list(map(int, data[1:n+1])) indexed_times = [(time, i + 1) for i, time in enumerate(times)]

列表切片：data[1:n+1]获取从第 2 个元素到第n+1个元素。

将接水时间和原始编号绑定，生成一个元组列表indexed_times。enumerate(times)：遍历times列表，返回索引和值。最终生成一个列表，如[(56, 1), (12, 2), (1, 3), ...]

列表推导式（List Comprehension）

是 Python 中一种简洁的创建列表的方式。它可以用一行代码生成一个新的列表，通常比传统的for循环更简洁和高效。

[表达式 for 变量 in 可迭代对象 if 条件]

可迭代对象：如列表、元组、字符串、range等

例：

# 定义二维数组 mp = [[0] * 5 for i in range(5)]

[0] * 5：创建一个包含 5 个0的列表：[0, 0, 0, 0, 0]。

for i in range(5)：这个列表推导式会执行 5 次。

enumerate函数：

是 Python 的内置函数，用于在遍历可迭代对象时同时获取元素的索引和值

enumerate(可迭代对象, start=0)

• 可迭代对象：如列表、元组、字符串等。

• enumerate返回一个枚举对象，每次迭代返回一个元组(index, value)，其中：

  • index：元素的索引。

  • value：元素的值

例：

s = "abc"

那么：

enumerate(s)

相当于得到：

i = 0, ch = 'a' i = 1, ch = 'b' i = 2, ch = 'c'

其实等价于：

for i in range(len(s)): ch = s[i]

又例：

for index,app in enumerate(apple): if app[0] > a + b: continue s -= app[1] if s < 0: break ans += 1

applevsapp的区别

• apple是整个列表，存储所有苹果的信息，例如：

  apple = [(3, 2), (5, 1), (2, 4), ...]

• app是apple中的单个苹果，例如：

  app = (3, 2) # 第一个苹果，x=3（高度），y=2（体力消耗）

• 因此，app[0]是当前苹果的高度x，app[1]是当前苹果的体力消耗y。

6.元组（Tuple）

元组是 Python 中的一种内置数据结构，用于存储一组有序的元素。元组是不可变的（Immutable），即创建后不能修改，即不能添加、删除或修改元素。

元组用圆括号()表示，元素之间用逗号,分隔

my_tuple = (1, 2, 3)

元组中的元素是有序的，可以通过索引访问。

my_tuple = (1, 2, 3) print(my_tuple[0]) # 输出：1

支持切片：

• 可以通过切片操作获取子元组。

• 例如：

  my_tuple = (1, 2, 3, 4, 5) print(my_tuple[1:4]) # 输出：(2, 3, 4)

7.列表

列表是 Python 中最常用的数据结构之一，用于存储一组有序的元素。列表是可变的（Mutable），即创建后可以修改其内容。

列表用方括号[]表示，元素之间用逗号,分隔

my_list = [1, 2, 3]

修改

my_list = [1, 2, 3]

my_list[0] = 10 # 修改第一个元素

print(my_list) # 输出：[10, 2, 3]

8.切片

1.概述

切片是 Python 中用于从序列（如列表、字符串、元组等）中提取子序列的操作。切片通过指定起始索引、结束索引和步长来提取元素。

序列[起始索引:结束索引:步长]

• 起始索引：切片的起始位置（包含）。

• 结束索引：切片的结束位置（不包含）。

• 步长：每隔多少个元素取一个（默认为 1）。

左闭右开：

my_list = [1, 2, 3, 4, 5] print(my_list[1:4]) # 输出：[2, 3, 4]

2. [::-1]

切片操作，用于反转列表。

c = {'a': 3, 'b': 1, 'c': 2}

d = sorted(list(c.values()))[::-1]

print(d) # 输出：[3, 2, 1]

将字典c的值按降序排列，并赋值给变量d。

9.解包讲解

解包是 Python 中一种将序列（如列表、元组）或字典中的元素拆分并赋值给多个变量的操作。解包可以让我们更方便地处理多个值。

遍历序列

for time, idx in indexed_times:

遍历indexed_times列表中的每个元素。indexed_times是一个元组列表，每个元组包含接水时间time和对应的编号idx。使用解包语法，将元组中的time和idx分别赋值给变量。

列表/元组的解包

a, b, c = [1, 2, 3] #将列表 [1, 2, 3]中的元素分别赋值给变量 a、b、c

10.lambda()函数

lambda是 Python 中的匿名函数，用于定义简单的函数。

lambda 参数: 返回值

competitions.sort(key=lambda x: x[1])

#lambda x: x[1]是一个匿名函数，接受一个参数x，并返回x[1]。

competitions是一个列表，其中每个元素是一个元组，表示一个比赛的开始时间和结束时间。例如competitions = [(0, 2), (2, 4), (1, 3)]

x是lambda函数的参数，表示competitions列表中的每个元素（即每个比赛的元组），x[1]是元组的第二个元素，即比赛的结束时间。

11.输出+join()语句

join()是 Python 字符串的一个方法，用于将一个可迭代对象（通常是列表或元组）中的多个字符串元素合并成一个字符串，并用指定的分隔符连接。

'分隔符'.join(可迭代对象)

分隔符可以是任意字符串：包括空字符串''；

必须作用于字符串元素：可迭代对象中的所有元素必须是字符串类型。如果有数字，需要先转换为字符串。

使用' '.join(map(str, numbers))将排序后的数字列表转换为空格分隔的字符串。

int(''.join(li)[:-1])

• ''.join(li)：用空字符串连接列表li的所有元素（直接拼接）。

• [:-1]：去掉最后一个字符（哨兵'0'）。

12.字典

1.字典：

da = {
1: 2,
2: 3,
4: 1
}#这意味着：

• 键（Key）：是 1、2、4

• 值（Value）：分别是 2、3、1

你可以用da[1]获取键为1的值，也可以用da[2]设置键为2的值。

2. get(key, default)

• 如果key存在于字典中，返回对应的值

• 如果key不存在，返回default值（这里是0）

count = {} for num in votes: count[num] = count.get(num, 0) + 1

3. dict.items()

items()是 Python 字典（dict）的一个非常重要的方法，它的作用是返回字典中所有的键值对，并且以元组形式返回。每个元组的第一个元素是键（key），第二个元素是值（value）

da = {1: 'a', 2: 'b', 3: 'c'}
for i, j in da.items():
print(i, j)

#输出
1 a

2 b
3 c

13.set()

n_l = list(set(map(int,input().split(" "))))

• 将map对象转换为集合，自动去重

• [1, 2, 2, 3]→{1, 2, 3}

14. defaultdict

from collections import defaultdict

d = defaultdict(default_factory)

1. defaultdict是内置 dict 类的子类。在字典中获取一个 key 有两种方法, 第一种 get , 第二种 通过 [] 获取，使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict。

2. 其中default_factory是一个可调用对象（通常是类型如int,list,set等），用于在 key 不存在时提供默认值。

P1102 A-B 数对 - 洛谷

例：

time = defaultdict(int)

for i in num:
time[i] += 1

time：一个字典，用来统计每个数字出现的次数，默认值为 0。

这一步是遍历整个数列，对每个数字i计数。
举个例子：输入[1, 3, 5, 7, 9, 3]
计数结果是：time = {1:1, 3:2, 5:1, 7:1, 9:1}

15.round()

round()是 Python 的一个内置函数，用来四舍五入。

round(number, ndigits) #number：你要四舍五入的那个数；ndigits：保留到小数点后几位。

round(3.14159, 2) → 3.14
round(2.71828, 3) → 2.718
round(5.5555, 0) → 6.0

16. abs()和all（）

均为Python 里的内置函数。

abs（）：返回一个数的绝对值（absolute value）

all()：判断所有条件是否都为 True，接收一个可迭代对象（比如列表、生成器表达式），如果里面所有元素都为True，返回True；否则返回False

P1024 [NOIP 2001 提高组] 一元三次方程求解 - 洛谷

all(abs(root - r) >= 0.99 for r in roots)

对每一个r（在已找到的根中），只要abs(root - r) >= 0.99都成立，就返回True。

17.strip()方法

strip()是字符串方法，用于移除字符串首尾的空白字符（包括空格、制表符\t、换行符\n等）。

18.global关键字

global关键字用于在函数内部声明一个变量是来自于全局作用域的，而不是当前函数作用域（局部作用域）的。

主要用途是：允许你在函数内部修改全局变量的值。

19. py和c++对应关系

C++ Python int int double float string str bool bool vector<int> list[int] vector<string> list[str]

20.nums.sort(key=abs, reverse=True)

sort()是列表 list 自带的方法，会直接修改原列表。默认是升序排序。

nums.sort(key=abs, reverse=True)

常见格式：

列表.sort(key=排序依据, reverse=是否降序)

key = abs 表示：按绝对值排序。

然后：reverse=True 表示：从大到小。

比如：

nums = [-4, -2, 3, 1]

排序以后：

[-4, 3, -2, 1]