摘要:
本文系统梳理了Python核心知识点，包括函数参数、yield生成器、作用域、类与装饰器等。函数参数部分详解了位置参数、关键字参数、默认参数及可变参数的用法与注意事项；yield生成器解析了惰性求值特性及其在协程和异步编程中的应用；作用域规则阐述了LEGB查找顺序及global/nonlocal关键字的使用；类与对象章节剖析了点语法原理、魔术方法和继承机制；装饰器部分展示了高阶函数与闭包实现的功能扩展技巧。全文通过代码示例和考点分析，帮助开发者掌握Python核心语法与高级特性。
一.函数形参全部考法
位置参数（必选形参）
调用时按顺序依次传值，个数必须严格匹配，不能多也不能少。
python
def func(a, b):
print(a, b)
func(10, 20)
# func(10)
# func(10,20,30) 考点：位置参数个数、顺序必须一一对应。
关键字参数
调用时 形参名=值，不用按顺序；位置参数必须放在关键字参数前面。
python
def func(a, b):
print(a, b)
func(b=20, a=10)
func(10, b=20)
# func(a=10, 20)考点：位置参数和关键字参数混用顺序限制。
默认参数
形参设置默认值，调用可省略不传。
python
def func(a, b=100):
print(a, b)
func(10)
func(10, 200) 可变类型当默认参数会导致逻辑陷阱。
python
def func(lst=[]):
lst.append(1)
print(lst)
func()
func()
func() 考点：禁止用 list/dict/set 做默认参数。
可变位置参数 *args
*作用：接收多余的位置参数 ，自动打包成元组args只是普通变量名（argument 缩写）- 你写成
*c、*nums、*abc都可以，功能无任何区别
python
# 写法1：约定写法 *args
def fun(*args):
print(args)
# 写法2：换成 *c 一模一样
def fun(*c):
print(c)
fun(1,2,3,4)考点 ：*args 只能接收位置参数，装成元组。
可变关键字参数 **kwargs
接收多余关键字参数，打包成字典。
python
def func(a, **kwargs):
print(a)
print(kwargs)
func(1, name="张三", age=18)考点 ：**kwargs 只收关键字参数，装成字典。
*args 和 **kwargs 混合用法
严格遵守顺序：*args 在前，**kwargs 在后。
python
def func(*args, **kwargs):
print(args)
print(kwargs)
func(1,2,3, name="李四", sex="男")仅限关键字参数
用单独一个 * 隔开，后面参数必须用关键字传参，不能用位置传。
python
def func(a, *, b, c):
print(a, b, c)
func(10, b=20, c=30)
# func(10,20,30) 全套参数标准写法
python
def func(a, b=10, *args, x, y=20, **kwargs):
pass完全符合顺序：位置 → 默认 → *args → 仅限关键字 → **kwargs。
高频报错汇总
- 位置参数个数不匹配 → 报错
- 关键字参数放位置参数前面 → 报错
*args放在默认参数后面乱序 → 语法报错- 同一个形参重复传值（既位置又关键字）→ 报错
- 可变类型list/dict做默认参数 → 逻辑陷阱bug
二.yield
理解 yield 的基本概念
yield 是 Python 中的一个关键字，用于定义生成器函数。生成器函数返回一个生成器对象，可以逐个生成值，而不是一次性返回所有值。这种惰性求值的特性使得生成器在处理大数据集或无限序列时非常高效。
yield 的工作原理是通过暂停函数的执行状态，并在下次调用时从暂停的位置继续执行。这种机制称为"协程"，允许函数在生成值的同时保持其局部状态。
yield 与 return 的区别
return 用于普通函数，一旦执行 return，函数立即终止并返回结果。yield 则用于生成器函数，每次调用生成器的 next() 方法时，函数会执行到 yield 语句处暂停，并返回 yield 后面的值。下次调用时，函数从上次暂停的位置继续执行。
生成器函数可以包含多个 yield 语句，每次执行到 yield 时都会暂停并返回值。而 return 在生成器函数中用于终止生成器，并抛出 StopIteration 异常。
生成器函数的定义与使用
定义一个生成器函数时，只需在函数体中使用 yield 关键字。调用生成器函数时，不会立即执行函数体，而是返回一个生成器对象。通过调用 next() 方法或使用 for 循环遍历生成器对象时，函数体才会逐步执行。
python
def simple_generator():
yield 1
yield 2
yield 3
gen = simple_generator()
print(next(gen)) # 输出 1
print(next(gen)) # 输出 2
print(next(gen)) # 输出 3yield 的高级用法
yield 不仅可以用于生成值，还可以用于接收值。通过生成器的 send() 方法，可以向生成器发送数据，生成器内部通过 yield 表达式接收数据。这种双向通信的机制使得生成器可以用于更复杂的任务，如协程和异步编程。
python
def coroutine():
while True:
received = yield
print(f"Received: {received}")
co = coroutine()
next(co) # 启动生成器
co.send("Hello") # 输出 "Received: Hello"
co.send("World") # 输出 "Received: World"yield from 语法
yield from 是 Python 3.3 引入的语法，用于简化生成器的嵌套。它可以将子生成器的值直接传递给外层生成器的调用者，避免了手动迭代子生成器的繁琐操作。yield from 还可以用于委托生成器的控制流。
python
def sub_generator():
yield 1
yield 2
def main_generator():
yield from sub_generator()
yield 3
for value in main_generator():
print(value) # 输出 1, 2, 3yield 在实际项目中的应用
生成器在处理大数据集时非常有用，可以逐个生成数据而不占用大量内存。例如，读取大型文件时，可以使用生成器逐行读取文件内容，而不是一次性加载整个文件到内存中。
生成器还可以用于实现无限序列，如斐波那契数列。由于生成器是惰性求值的，可以无限生成数列中的值，而不会导致内存溢出。
python
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
fib = fibonacci()
for _ in range(10):
print(next(fib)) # 输出前10个斐波那契数yield 与异步编程
yield 在异步编程中扮演了重要角色，尤其是在 Python 的 asyncio 库出现之前。通过结合 yield 和事件循环，可以实现协程式的异步编程。虽然现代 Python 更推荐使用 async/await 语法，但理解 yield 在异步编程中的历史作用仍有意义。
常见问题与调试技巧
使用 yield 时可能会遇到一些常见问题，如生成器耗尽后再次调用 next() 会抛出 StopIteration 异常。可以通过捕获异常或使用 for 循环避免这一问题。
调试生成器时，可以使用 inspect 模块检查生成器的状态，或通过打印 yield 的值跟踪生成器的执行流程。生成器的惰性特性可能导致调试时难以追踪问题，因此需要特别注意。
性能优化与最佳实践
生成器的性能优势在于其惰性求值和内存效率，但在某些场景下可能会带来额外的开销。例如，频繁创建和销毁生成器对象可能导致性能下降。在性能敏感的场景中，需要权衡生成器的使用。
最佳实践包括避免在生成器函数中执行耗时操作，合理使用 yield from 简化代码，以及确保生成器的生命周期管理得当。生成器适用于流式数据处理和大型数据集遍历，但不适合所有场景。
三.Python 作用域与函数调用
Python 作用域与函数调用核心规则
LEGB 作用域查找顺序(从高到低)
局部作用域（Local） → 嵌套外层作用域（Enclosing） → 全局作用域（Global） → 内置作用域（Built-in）
核心场景解析
全局函数与全局变量
全局函数可直接读取全局变量，无需声明：
python
name = "全局" # 全局变量
def func(): # 全局函数
print(name)
func() # 全局：全局调用全局函数 ✅ 正常局部读取全局变量
函数内部仅读取时直接使用：
python
num = 100
def func():
print(num) # 正常读取
func()局部修改全局变量
必须使用 global 显式声明：
python
num = 100
def func():
global num # 不写 global 直接赋值，会生成新的局部变量，遮蔽全局变量
num = 200 # 修改生效
func()
print(num) # 输出200未声明时赋值会创建局部变量，遮蔽全局变量。
嵌套函数作用域
内层读取外层变量
闭包中内层函数可直接读取外层变量：
python
def outer():
x = 10
def inner():
print(x) # 正常读取
inner()
outer()内层修改外层变量
需使用 nonlocal 声明：
python
def outer():
x = 10
def inner():
nonlocal x
x = 20 # 修改生效
inner()
print(x) # 输出20
outer()函数作用域限制
全局调用局部函数
需通过返回函数对象实现：
python
# 错误：全局直接调用局部函数 ❌ 报错
def outer():
def inner():
print("内层函数")
outer()
# inner() # NameError: 作用域不允许
# 正确：返回引用，全局调用 ✅
def outer():
def inner():
print("内层函数")
return inner # 返回函数对象
f = outer()
f() # 全局调用成功直接调用 inner() 会引发 NameError。
关键字对比表
| 关键字 | 功能 | 适用层级 |
|---|---|---|
global |
声明并修改全局变量 | 全局作用域 |
nonlocal |
声明并修改外层嵌套变量 | 闭包嵌套作用域 |
| 无 | 默认创建或读取局部变量 | 局部/嵌套作用域 |
关键结论
- 作用域由定义位置决定 ，与调用位置无关。
- 修改外部变量必须显式声明：
global（全局）或nonlocal（嵌套）。 - 局部/嵌套函数需通过返回值暴露给外部作用域。
- 未声明时的赋值操作会创建新局部变量。
四.类
Python 中 类、函数、变量、实例、字符串、数字 全都是对象 。对象的本质：一堆属性 + 一堆方法 + 命名空间（存储属性的字典）
Python 类、变量、函数核心知识点
点语法原理
点语法 . 是访问对象命名空间的固定语法，用于操作对象的属性和方法。每个对象或类都有一个隐藏的 __dict__ 字典，存储所有变量和方法。点语法本质上是操作这个字典：
python
对象.属性 === 对象.__dict__['属性']
类.方法 === 类.__dict__['方法']实例对象属性的查找顺序为：实例自身的 __dict__ → 类的 __dict__ → 父类的 __dict__ → 报错 AttributeError。类名直接访问属性时，查找顺序为类自身 → 父类。
魔术方法
魔术方法是系统自动调用的特殊方法，以双下划线开头和结尾。常见魔术方法包括：
__init__: 构造方法，创建对象时调用(作用就是负责初始化对象,给空对象绑定属性,赋值)__new__: 创建对象时调用(作用：向内存申请空间，返回一个空白的实例对象 。)，比__init__更早执行__del__: 析构方法，对象销毁时调用__str__: 控制print(对象)的输出__repr__: 控制开发者调试时的输出__call__: 使对象可像函数一样使用（）进行调用- 例如：output = model(x) # 底层自动调用 model.forward(x)
__len__: 定义len(对象)的行为__getitem__和__setitem__: 定义索引操作行为__eq__: 定义==操作符行为__add__: 定义加法操作行为
继承本质
继承通过 class 子类(父类) 实现，子类拥有父类的非私有属性和方法。底层机制是子类的 __bases__ 元组记录父类，方法查找按 MRO（方法解析顺序）进行。继承的核心作用是代码复用、方法重写和功能扩展。
私有属性和方法（双下划线开头）通过 Python 的改名机制实现，子类无法直接访问。super() 用于调用父类方法，解决重写后的父类方法调用问题。多继承按从左到右顺序查找方法。
变量类型
类中包含三种变量：
- 实例变量：通过
self.变量名定义，每个实例独有 - 类变量：定义在类内方法外，整个类共享
- 局部变量：定义在方法内部，方法执行完销毁
实例变量必须用 self 绑定，修改类变量推荐使用类名直接访问，通过实例修改会创建同名实例变量遮蔽类变量。
方法类型
类中包含四种方法：
- 实例方法：第一个参数为
self，用于操作实例变量和类变量 - 类方法：
@classmethod装饰，第一个参数为cls，专门操作类变量 - 静态方法：
@staticmethod装饰，无默认参数，作为工具函数使用 - 魔术方法：系统自动调用，实现特殊行为
三者关系
类是封装变量和函数的容器，函数在类中成为方法，变量分为实例变量和类变量。点语法统一访问属性和方法，底层操作 __dict__。继承通过层级查找实现代码复用和扩展。
面试三问答案
- 类使用点语法是因为类是命名空间对象，属性和方法存储在
__dict__中，点语法是访问命名空间的专用语法。 - 常用魔术方法包括
__init__、__str__、__call__、__new__、__len__和__getitem__。 - 类可以继承是因为 Python 设计了类的层级查找机制（MRO），子类关联父类命名空间，自动获得父类属性和方法。
类继承案例
python
# 1. 导入必备库
import torch
import torch.nn as nn
# 2. 定义神经网络类：继承 父类 nn.Module
class MyNet(nn.Module):
# 构造方法：初始化网络层
def __init__(self):
# 3. 调用父类 nn.Module 的构造方法（继承核心！）
super().__init__()
# 等价完整版带参数写法
# super(MyNet, self).__init__()
# 4. 定义网络层（全连接层/线性层）
# 输入10维，输出20维
self.fc1 = nn.Linear(10, 20)
# 输入20维，输出2维（分类结果）
self.fc2 = nn.Linear(20, 2)
# 5. 必须实现的前向传播方法（父类要求）
def forward(self, x):
# 数据流经第一层
x = self.fc1(x)
# 激活函数
x = torch.relu(x)
# 数据流经第二层
x = self.fc2(x)
# 返回输出结果
return x
# ------------------- 测试代码 -------------------
# 创建模型对象（实例化子类）
model = MyNet()
# 构造输入数据：batch_size=1, 特征=10
input_data = torch.randn(1, 10)
# 前向传播（不用手动调用forward，自动执行）
'''
# 1. 触发 __call__
model.__call__(input_data)
# 2. __call__ 内部自动帮你填 self，并调用 forward
model.forward(self=model, x=input_data)
'''
output = model(input_data) # 因为__call__使得对象可以项函数那样使用（）来调用。实际隐藏做的是：output = model(x) # 底层自动调用 model.forward(x)
# 打印结果
print("模型结构：\n", model)
print("\n输出结果形状：", output.shape)
python
class Person:
def __init__(self, name):
self.name = name
# 子类
class Student(Person):
def __init__(self, name, age):
# Python3 简写（自动推断）
super().__init__(name)
# 等价完整版带参数写法
# super(Student, self).__init__(name)
self.age = age
class A:
def info(self):
print("A")
class B(A):
def info(self):
print("B")
class C(B):
def info(self):
# 从 B 开始找下一个父类 → 调到 A，跳过 B
super(B, self).info()
c = C()
c.info() # 输出 A，直接跳过了 B五.装饰器
装饰器基本概念
装饰器是Python独有的语法糖，基于高阶函数和闭包实现，在不修改原函数代码和调用方式的前提下，为函数或方法动态添加额外功能。
核心作用
不修改原函数代码，通过包装函数扩展功能。
- 代码解耦：将通用功能（如日志、计时）与业务逻辑分离
- 代码复用：一个装饰器可应用于多个函数
- 无侵入性：符合开闭原则，不修改原函数
语法结构
python
# 最简装饰器示例
def decorator(func):
def wrapper():
print("前置功能")
func() # 调用原函数
print("后置功能")
return wrapper
# @语法：装饰原函数
@decorator
def hello():
print("原函数：Hello")
# 调用方式不变
hello()实现原理
装饰器依赖高阶函数和闭包：
- 高阶函数：函数可作为参数传递或返回值返回
- 闭包：内层函数引用外层函数的变量
底层等价形式
@decorator 等价于 hello = decorator(hello)，实际调用的是包装函数 wrapper。
常见应用场景
日志记录
python
import functools
def log(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f"调用函数：{func.__name__}")
res = func(*args, **kwargs)
print("函数执行完毕")
return res
return wrapper性能测试
python
import time
def timer(func):
def wrapper(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
print(f"耗时：{time.time()-start:.4f}s")
return res
return wrapper权限校验
python
def check_login(func):
def wrapper(user):
if not user.get("login"):
print("无权限，请登录")
return
return func(user)
return wrapper带参数的装饰器
通过三层嵌套函数实现：
python
def log(level):
def decorator(func):
def wrapper(*args, **kwargs):
print(f"[{level}] 执行函数：{func.__name__}")
return func(*args, **kwargs)
return wrapper
return decorator
@log("INFO")
def test():
print("测试")类装饰器
利用 __call__ 方法实现：
python
class Decorator:
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print("类装饰器前置")
res = self.func(*args, **kwargs)
print("类装饰器后置")
return res
@Decorator
def hello():
print("Hello")链式调用
执行顺序为从内到外：
python
@A
@B
def test():
print("原函数")
# 输出顺序：A1 → B1 → 原函数 → B2 → A2调试与性能
关键工具
使用 functools.wraps 保留原函数元数据：
python
import functools
def decorator(func):
@functools.wraps(func)
def wrapper():
func()
return wrapper性能注意
- 装饰器会增加调用栈开销，高频循环中避免滥用
- 常见陷阱：忘记返回原函数返回值、嵌套层级错误
实际项目实践
最佳实践
- 通用功能（日志、权限）优先用装饰器
- 简单逻辑用函数装饰器，复杂状态用类装饰器
- 必须使用
functools.wraps
企业级场景
- Web框架路由（如
@app.route） - 测试工具（如
@pytest.fixture） - 异步框架的限流、重试装饰器
进阶扩展
异步装饰器
python
async def async_decorator(func):
async def wrapper(*args, **kwargs):
print("异步前置")
res = await func(*args, **kwargs)
print("异步后置")
return res
return wrapper高阶结合
- 描述符 + 装饰器：实现方法级权限控制
- 元类 + 装饰器：批量装饰类方法
代码解析
(一)不带参数的装饰器
python
def my_decorator(func):
def wrapper():
print("包装函数：执行原函数前的逻辑")
func()
print("包装函数：执行原函数后的逻辑")
return wrapper
@my_decorator
def say_hello():
print("原函数：Hello World")
say_hello()执行流程
1.1装饰绑定阶段
- 创建装饰器函数
my_decorator - 创建原函数
say_hello @my_decorator等价于say_hello = my_decorator(say_hello)- 原函数作为参数传给
my_decorator - 定义
wrapper函数 my_decorator返回wrappersay_hello被重新赋值为wrapper
1.2函数调用阶段
- 调用
say_hello()实际调用wrapper() - 执行前置打印
- 调用原函数
say_hello - 执行后置打印
(二)带参数的装饰器
python
def log_decorator(level):
def decorator(func):
def wrapper():
print(f"【日志级别】：{level}")
print("执行原函数前")
func()
print("执行原函数后")
return wrapper
return decorator
@log_decorator(level="INFO")
def say_hi():
print("原函数：Hi Python")
say_hi()执行流程
2.1装饰器传参阶段
- 创建最外层函数
log_decorator - 执行
log_decorator("INFO") - 传入参数
level="INFO" - 返回第二层函数
decorator
2.2装饰绑定阶段
- 创建原函数
say_hi - 执行
say_hi = decorator(say_hi) - 原函数作为参数传给
decorator - 定义
wrapper函数 decorator返回wrappersay_hi被赋值为wrapper
2.3函数调用阶段
- 调用
say_hi()实际调用wrapper() - 打印日志级别
- 执行前置打印
- 调用原函数
say_hi - 执行后置打印
(三)核心区别
- 不带参装饰器：2层函数，1步装饰绑定
- 带参装饰器：3层函数，先传参再做无参装饰器的绑定
- 两者最终调用原函数的逻辑完全一致
总结
装饰器基于高阶函数和闭包，通过 @ 语法无侵入扩展功能，适用于日志、权限、性能监控等场景，核心价值是 不改原代码，增强原功能。
六.import（模块 / 包 / 文件夹 / 路径 所有导入写法全覆盖）
os模块核心功能
路径处理
- 使用
os.path.join()进行路径拼接，自动适配不同操作系统的分隔符 os.path.abspath()将相对路径转为绝对路径os.path.dirname()获取路径中的目录部分os.path.basename()获取路径中的文件名部分os.path.exists()检查路径是否存在os.path.isfile()和os.path.isdir()判断路径类型
文件/目录操作
os.mkdir()创建单层目录os.makedirs()递归创建多层目录os.rmdir()删除空目录os.remove()删除文件os.rename()重命名或移动文件os.listdir()列出目录内容os.chdir()改变当前工作目录
Python导入系统
核心概念
单个 .py 是模块 ，带 __init__.py 的文件夹是包；
- 没有
__init__.py的话只是普通文件夹，不能直接导入 __init__.py的作用：标记当前文件夹是一个包、控制导出接口- 跨文件夹导入靠 sys.path 加项目根目录 或 设置 Sources Root；
- os 模块只管路径拼接、文件文件夹增删遍历 ，永远用
os.path.join拼路径。
导入语法
- 绝对导入：从项目根目录开始的完整路径
- 相对导入：使用
.表示当前目录，..表示父目录;相对路径 ：./当前目录、../上一级目录 - 别名导入：使用
as关键字 - 通配符导入：
from module import *（不推荐）项目规范：配置、读取文件一律用绝对路径，避免换环境报错。
项目结构最佳实践
- 使用清晰的包结构
- 在项目根目录添加
__init__.py - 主要使用绝对导入
- 需要时手动添加项目根目录到
sys.path
常见问题解决
ModuleNotFoundError：检查sys.path是否包含模块路径- 相对导入错误：确保不在包外使用相对导入
- 循环导入：重构代码结构，提取公共部分
实用技巧
路径处理规范
- 项目中始终使用绝对路径
- 使用
os.path函数而非手动拼接路径 - 跨平台兼容性考虑
导入优化
- 在
__init__.py中预先导入常用模块 - 使用
__all__控制导出内容 - 避免循环导入
- 大型项目考虑使用显式相对导入
调试技巧
- 打印
sys.path检查模块搜索路径 - 使用
try-except捕获导入错误 - 在PyCharm中标记Sources Root
python
# 遍历文件夹所有文件（项目实战常用）
root = "./data"
for file in os.listdir(root):
file_path = os.path.join(root, file)
if os.path.isfile(file_path):
print("文件：", file_path)
# 导入模块并起别名
import numpy as np
import torch as nn
# 从模块导入指定 函数 / 类 / 变量
from utils import add, Person
add()
from utils import add as my_add
# 通配符导入（不推荐，污染命名空间）
from utils import *
# 导入包下的子模块
from mypackage import utils
# 或
import mypackage.utils
# 直接导入包内成员
from mypackage.utils import add
python
'''绝对导入
project/
main.py
package/
__init__.py
utils.py
a.py
'''
from package.utils import add
'''相对导入
. 当前同级目录
.. 上一级目录
... 上两级目录
规则：
只能在包内 .py 文件使用
不能把带相对导入的文件当入口脚本运行（会报错）
'''
# 在 package/a.py 导入同级 utils.py
from .utils import add
# 在 package/a.py 导入上一级模块
from ..main import hello