一、通用装饰器：从带参数函数开始
通用装饰器，就是可以装饰任意函数的装饰器。在装饰函数时，需要注意：被装饰的函数可能有参数，也可能没有参数，或者有返回值，或者是不定长参数。
1.1 初探：装饰器如何装饰带参数的函数？
先看下面这段代码，你能发现其中的问题吗？
# 定义装饰器def decPar(): def inner(): # 在内部函数中对已有函数进行装饰 print("对有参数的函数进行了装饰") # 执行需要装饰的函数 existParameter() return inner@decPar # 语法糖，用装饰器语法糖装饰带有参数的函数def existParameter(par1, par2): res = par1 + par2 print(f"这是有参数的函数，显示的结果是{res}")
运行这段代码，会报如下错误：
TypeError: decPar() takes 0 positional arguments but 1 was given
原因分析：使用 @decPar 语法糖时，Python 会把被装饰函数 existParameter 作为参数传递给装饰器 decPar，但我们的 decPar() 没有定义参数来接收这个函数。
修正方案：给装饰器加上参数 func：
def decPar(func): # 接收被装饰的函数 def inner(): print("对有参数的函数进行了装饰") existParameter() return inner@decPardef existParameter(par1, par2): res = par1 + par2 print(f"这是有参数的函数，显示的结果是{res}")
现在没有参数错误了，但执行 existParameter(6, 6) 时，又会出现新问题：
TypeError: decPar.<locals>.inner() takes 0 positional arguments but 2 were given
原因分析：装饰器的原理是让 inner 函数取代原来的函数。但我们的 inner() 没有参数，而原函数需要两个参数，所以报错。
再次修正：让 inner 接受不定长参数：
def decPar(func): def inner(*args, **kwargs): # 接受任意参数 print("对有参数的函数进行了装饰") existParameter() return inner
1.2 *args 和 **kwargs 详解
def f(*args): print(args)f(1, 2, 3, 6, 5, 4, 8)# 输出：(1, 2, 3, 6, 5, 4, 8)
def fk(**kwargs): print(kwargs)fk(a=1, b=5)# 输出：{'a': 1, 'b': 5}
注意：**kwargs 只能接收关键字参数，不能接收位置参数：
def fk(**kwargs): print(kwargs)fk(a=1, b=5) # 正确fk(1, 2) # 报错：TypeError
另外，*args 中的 args 只是一个约定名称，可以换成任意名字：
def f(*aaa): print(aaa)f(1, 2, 3, 6, 5, 4, 8)# 输出：(1, 2, 3, 6, 5, 4, 8)
1.3 递归调用陷阱（高频踩坑）
即使 inner 加上了 *args, **kwargs，如果内部仍然调用的是原函数名（而不是 func 参数），就会导致无限递归：
def decPar(func): def inner(*args, **kwargs): print("对有参数的函数进行了装饰") existParameter() # ❌ 这里调用了全局函数名，不是 func 参数 return inner
执行 existParameter(6, 6) 时，会报 RecursionError: maximum recursion depth exceeded。
原因：装饰后 existParameter 变成了 inner，而 inner 内部又调用了 existParameter（实际是 inner 自己），形成了死循环。
正确写法：调用 func 参数，并传递参数：
def decPar(func): def inner(*args, **kwargs): print("对有参数的函数进行了装饰") func(*args, **kwargs) # ✅ 调用 func，并传递参数 return inner@decPardef existParameter(par1, par2): res = par1 + par2 print(f"这是有参数的函数，显示的结果是{res}")existParameter(6, 6)# 输出：# 对有参数的函数进行了装饰# 这是有参数的函数，显示的结果是12
1.4 通用装饰器：装饰无参数函数
上面的装饰器同样可以装饰无参数函数：
@decPardef nonPar(): print("这是一个没有参数的函数")nonPar()# 输出：# 对有参数的函数进行了装饰# 这是一个没有参数的函数
至此，这个装饰器已经可以装饰任意函数，成为了一个通用装饰器。
1.5 处理有返回值的函数
如果被装饰的函数有返回值，inner 也需要返回该值：
@decPardef reAddPar(*par, **keyPar): res = 0 for index in par: res += index for indexValue in keyPar.values(): # 注意：values() 是方法，要加括号 res += indexValue return resprint(reAddPar(1, 2, 3, 4, 5, 6)) # 21print(reAddPar(a=5, b=0, c=6)) # 11
常见错误：keyPar.values 不加括号，会返回 builtin_function_or_method 对象，导致 TypeError: 'builtin_function_or_method' object is not iterable。
二、Python 元组（Tuple）核心知识点复习
元组（tuple）是 Python 中不可变的有序序列，和列表用法高度相似，但核心区别是元组一旦创建就无法修改，是 Python 最基础、最常用的数据类型之一。
2.1 元组的核心特性
- 不可变性
- 有序性
- 异构性：可存储任意类型数据（数字、字符串、列表、字典等）
- 可重复
2.2 元组的创建（4种常用方式）
元组用小括号 () 定义，元素之间用逗号 , 分隔。
1. 标准创建
# 存储不同类型数据t1 = (1, "hello", 3.14, True)# 存储同类型数据t2 = (2, 4, 6, 8)
2. 空元组
empty_t = () # 方式1empty_t2 = tuple() # 方式2
3. 单元素元组（❗️必记易错点）
单元素元组必须加逗号，否则 Python 会把它当成普通数据：
# 正确：单元素元组t3 = (5,)print(type(t3)) # <class 'tuple'># 错误：不是元组，是整数t4 = (5)print(type(t4)) # <class 'int'>
4. 省略括号创建
Python 允许直接用逗号分隔元素创建元组（语法糖）：
t5 = 1, 2, 3 # 等价于 (1,2,3)print(type(t5)) # <class 'tuple'>
5. 可迭代对象转元组
用 tuple() 把列表、字符串等转为元组：
# 列表转元组t6 = tuple([1, 2, 3])# 字符串转元组t7 = tuple("abc") # ('a', 'b', 'c')
2.3 访问元组元素
元组支持索引和切片，语法和列表完全一致：
t = (10, 20, 30, 40, 50)# 1. 正索引（从0开始）print(t[0]) # 10print(t[2]) # 30# 2. 负索引（从末尾-1开始）print(t[-1]) # 50print(t[-3]) # 30# 3. 切片 [起始:结束:步长]print(t[1:4]) # (20, 30, 40)print(t[::2]) # (10, 30, 50)
2.4 核心：元组的不可变性
1. 常规不可变
直接修改/删除元组元素会直接报错：
t = (1, 2, 3)# t[0] = 100 # 报错！TypeError# del t[1] # 报错！不支持删除元素
2. 特殊情况（易踩坑）
如果元组中包含可变元素（列表、字典），可变元素的内容可以修改（元组只限制自身元素的引用，不限制元素内部）：
t = (1, [2, 3], 4)t[1].append(5) # 修改元组里的列表，不报错print(t) # (1, [2, 3, 5], 4)
2.5 元组的常用操作
t1 = (1, 2)t2 = (3, 4)# 1. 元组拼接 +print(t1 + t2) # (1,2,3,4)# 2. 元组重复 *print(t1 * 3) # (1,2,1,2,1,2)# 3. 成员运算 in / not inprint(2 in t1) # True# 4. 长度 len()print(len(t1)) # 2# 5. 最值 max()/min()（元素需为同类型可比较数据）print(max((5, 1, 9))) # 9# 6. 遍历元组for i in t1: print(i)
2.6 元组的内置方法（仅2个）
t = (1, 2, 2, 3, 3, 3)# 1. count(x)：统计元素x出现的次数print(t.count(2)) # 2# 2. index(x)：查找元素x第一次出现的索引print(t.index(3)) # 3
2.7 元组解包（高频实用语法）
快速把元组的元素赋值给多个变量：
# 1. 基础解包（变量数=元素数）a, b, c = (1, 2, 3)print(a, b, c) # 1 2 3# 2. * 通配符解包（接收剩余元素）x, *y, z = (1, 2, 3, 4, 5)print(x) # 1print(y) # [2,3,4]print(z) # 5# 3. 交换变量（元组解包经典用法）m, n = 10, 20m, n = n, mprint(m, n) # 20 10
2.8 元组 vs 列表（核心区别）
2.9 元组的使用场景
- 保护数据不被修改
- 函数多返回值
- 作为字典的键
- 多变量同时赋值
三、Python 字典（dict）超全复习笔记
字典是 Python 中**可变、有序（Python3.7+ 保留插入顺序）、以「键值对」**为核心的数据结构，底层基于哈希表实现，查询速度极快，是日常开发使用频率最高的类型之一。
3.1 字典核心特性（必背）
字典格式：{键: 值, 键: 值, ...}
- 键值对结构：数据成对存储，通过键(key) 找值(value)
- 键(key) 严格规则
- 值(value) 无限制
- 可变性
- 顺序：Python 3.7 及以上，字典默认保留元素插入顺序
- 查询高效
3.2 字典的 5 种创建方式
1. 直接使用大括号 {}（最常用）
dic1 = {"name": "小明", "age": 20, "gender": "男"}dic2 = {"水果": ["苹果", "香蕉"], "价格": 10}
2. 创建空字典
empty_dic = {} # 方式1（推荐）empty_dic2 = dict() # 方式2
3. dict() 关键字形式创建
# 注意：键不能加引号，只能是合法标识符dic3 = dict(name="小红", age=18)print(dic3) # {'name': '小红', 'age': 18}
4. 可迭代对象转字典
接收包含二元序列的可迭代对象（(键,值) / [键,值]）：
lst = [("a", 1), ("b", 2)]dic4 = dict(lst)print(dic4) # {'a': 1, 'b': 2}
5. 批量创建同值字典 dict.fromkeys()
keys = ["k1", "k2", "k3"]dic5 = dict.fromkeys(keys, 0)print(dic5) # {'k1': 0, 'k2': 0, 'k3': 0}
⚠️ 易错提醒：如果值是列表/字典等可变对象，所有键会共享同一个内存地址，修改一个全部变化。
3.3 访问字典元素（2 种主流方式）
只能通过键取值，字典不支持数字索引、切片！
1. 中括号取值 字典[键]
- 缺点：键不存在时，直接抛出
KeyError 错误
dic = {"name": "小李", "age": 22}print(dic["name"]) # 小李# print(dic["score"]) # 报错：KeyError
2. get() 方法取值（项目开发首选）
dic = {"name": "小李", "age": 22}print(dic.get("name")) # 小李print(dic.get("score")) # Noneprint(dic.get("score", 0)) # 0
3.4 增、改、删（字典可变核心操作）
1. 新增 / 修改 键值对
规则：键已存在→覆盖；键不存在→新增
dic = {"a": 1, "b": 2}dic["a"] = 100 # 修改print(dic) # {'a': 100, 'b': 2}dic["c"] = 3 # 新增print(dic) # {'a': 100, 'b': 2, 'c': 3}
2. 删除键值对（4 种方式）
dic = {"a": 1, "b": 2, "c": 3}# ① del 字典[键]：删除指定键值对del dic["b"]print(dic) # {'a': 1, 'c': 3}# ② pop(键)：删除并返回被删除的值res = dic.pop("a")print(res) # 1print(dic) # {'c': 3}# ③ popitem()：
10个月宝宝每天需要喝多少奶粉？