企业官网建设流程全解析

1、提示注释,只提示，不强制结果

def fun1(a:int,b:str="default1")->str:
return a*b
print(fun1(2,"ab")) #abab #字符串重复
print(fun1(3)) #default1default1default1 #字符串重复
print(fun1(3,2)) #6 注意：结果不为str格式，两数字相乘结果还为数字

2、min(…,key…)

H1, H2, H3, H4 = map(int, input().split()) #输入 150 165 135 133
# 取出key中最小值x，其中x为H2, H3, H4中的一个
# 分析：比较(15,165)、(15,135)、(17,133)
# 元组比较规则：先比第一个元素，相同再比第二个
print(min([H2, H3, H4], key=lambda x: (abs(x - H1), x))) # 135

补充：key 常见于 sorted、list.sort、min、max

3、时间复杂度和空间复杂度的判断

时间复杂度：数循环执行次数，用 n 表示，去掉的是"常数系数"和"低阶项"。
例如：
循环 n-1 ——时间复杂度为O(n)
3n + 5 → O(n)（3 和 5 都去掉）
n² + 3n + 10 → O(n²)（只留最高阶）

空间复杂度:存储空间
例如：
用了长度为 n+1 的数组/列表——空间复杂度为O(n)
只用了几个变量（a, b, i 之类）→ O(1)（常数级）

4、拷贝

(1)b=a.copy()浅拷贝，修改共享列表时，b和a共用一个数据;但要是赋新列表，不共用

示例1：
a = {1: [2], 3: [4]}
b = a.copy() # b复制a
b[1].append(3) # b[1]=[2,3] ∵浅拷贝，∴a[1]=b[1]
print(a[1]) # a[1]=[2,3]

示例2：
a = {1: [2]}
b = a.copy()
b[1] = [99] # 注意：∵b[1] 赋新列表，而不是b[1].append，∴b[1]不影响a[1]
print(a[1]) # a[1]不受影响！

b[1].append(3) # b[1]修改共享的列表,b[1]会影响a[1],b[1]=[2,3]
print(a[1]) # b[1]=a[1]=[2, 3]

(2)b=copy.deepcopy(a)深拷贝，b和a数据独立，互不影响

示例3：
import copy
a = {1: [2], 3: [4]}
b = copy.deepcopy(a) # 深拷贝
b[1].append(3) # b[1]=[2,3]
print(a[1]) # a[1]=[2] ← b不影响a

(3)切片，浅拷贝

a = [1, 2, [3, 4]]
b = a[:] # 切片，浅拷贝
b[0] = 10 # 修改外层元素，不影响a
b[2][0] = 30 # 修改内层列表，影响a
print(a) # [1, 2, [30, 4]]

(4)例题

执行以下Python代码后，输出结果是 ([1, 2], 3) 。（ ❌️ ）

a = [1, 2]
b = (a, 3)
a.append(4)
print(b) #([1, 2, 4], 3)

分析：

b = (a, 3) # 第 1 个元素是a（列表的引用）

b里存的不是列表的拷贝，而是a这个列表本身。
b ──→ ( ●, 3 )
│
└──→ a 指向的同一个列表 [1, 2]

5、嵌套列表推导式的理解

列表推导式的多个 for 是从左到右嵌套：先写的外层，后写的内层。
result=[item for row in matrix for item in row] # 外层 内层
等价于
for row in matrix: # 外层：遍历每一行
for item in row: # 内层：遍历这一行里的每个元素
result.append(item)

6、默认参数的可变对象陷阱

def func(x, lst=[]): # 陷阱1：默认参数，列表只创建一次，之后一直复用
lst.append(x)
return lst
print(func(1), func(2), func(3)) # 陷阱2：[1, 2, 3] [1, 2, 3] [1, 2, 3]
# 分析陷阱2：
func(1):返回[1]
func(2):返回[1,2]
func(3):返回[1,2,3]
但是print返回当前状态，当前lst已为[1,2,3],∴最终结果为[1, 2, 3] [1, 2, 3] [1, 2, 3]

7、finally与return运行的顺序

try和finally都有return 时，finally赢。
finally永远执行，且优先于return生效。
finally里若有return，会覆盖前面try的返回值。
try无return，正常执行finally，函数返回None【注意】。

示例1：
def f():
try:
return "From try"
finally:
print("From finally", end="#")
print(f(), end="#") # From finally#From try#

示例2：
def f():
try:
return "From try"
finally:
return "From finally" # 会覆盖 try 的 return！
print(f()) # From finally

示例3：
def f():
try:
print("try", end="#")
finally:
print("finally", end="#")
print(f(), end="#") # try#finally#None#

8、修改全局变量和外层函数变量的关键字

在嵌套函数中，需要修改外层函数（非全局作用域）的变量，用nonlocal关键字。
修改全局变量，用global关键字。

9、lambda 匿名函数可以接受多个参数，但只能有一个表达式。

10、元组解包赋值：先算右边所有值，再同时赋给左边。

11、readline和readline

在Python中，readline()方法每次读取文件的下一行内容，包括行尾的换行符。如果已到文件末尾，则返回一个空字符串。readlines()返回列表。