Python 核心编程（进阶必修）

一、函数

定义与调用

python
def greet(name, greeting="Hello"):    """文档字符串 — 描述函数功能"""    return f"{greeting}, {name}!" greet("Alice")              # "Hello, Alice!"  使用默认值greet("Bob", "Hi")          # "Hi, Bob!"       覆盖默认值greet(greeting="Hey", name="Eve")  # 关键字参数（顺序无关） 

参数类型

参数类型	语法	说明
位置参数	def f(a, b)	按顺序传入
默认参数	def f(a, b=10)	调用时可省略
可变位置参数	def f(*args)	接收任意多个位置参数，打包为元组
可变关键字参数	def f(**kwargs)	接收任意多个关键字参数，打包为字典
仅限关键字参数	def f(a, *, b)	* 之后的参数只能用关键字传入

python
def example(a, b=10, *args, c=20, **kwargs):    print(a, b, args, c, kwargs) example(1, 2, 3, 4, c=30, x=100, y=200)# 1 2 (3, 4) 30 {'x': 100, 'y': 200} def star_range(*, start, end, step=1):  # 仅限关键字参数    passstar_range(start=0, end=10)  # 必须用关键字传入 

作用域

python
x = 100          # 全局变量 def outer():    y = 200      # 嵌套作用域        def inner():        z = 300  # 局部变量        nonlocal y  # 声明要修改外层变量        global x    # 声明要修改全局变量        y += 1        x += 1 

Python 查找变量的顺序（LEGB）：Local → Enclosing → Global → Builtin

二、模块与包

import 机制

python
import math              # 导入整个模块from math import sqrt, pi  # 导入特定成员from math import *       # 导入全部（不推荐）import numpy as np       # 别名 # 模块搜索路径import sysprint(sys.path)          # 打印搜索路径列表 

if name == “main”

python
# mymodule.pydef main():    print("Running as script") if __name__ == "__main__":    main()   # 只有直接运行此文件时才执行 

当通过 python mymodule.py 运行时，__name__ 为 "__main__"；当 import mymodule 时，__name__ 为 "mymodule"。

包结构

mypackage/├── __init__.py       # 标记为包（可为空）├── module_a.py└── subpackage/    ├── __init__.py    └── module_b.py 

python
from mypackage.module_a import funcfrom mypackage.subpackage import module_b 

三、异常处理

基本语法

python
try:    result = 10 / 0except ZeroDivisionError as e:    print(f"除零错误: {e}")except (ValueError, TypeError) as e:    print(f"值或类型错误: {e}")except Exception as e:    # 兜底（不推荐裸 except:）    print(f"其他错误: {e}")else:    print("没有异常时执行")finally:    print("无论是否有异常都会执行（清理资源）") 

抛出异常

python
def validate_age(age):    if age < 0:        raise ValueError("年龄不能为负数")    if age > 150:        raise ValueError(f"年龄 {age} 超出合理范围") # 异常链try:    process_data()except ValueError as e:    raise RuntimeError("数据处理失败") from e  # 保留原始异常链 

自定义异常

python
class ValidationError(Exception):    def __init__(self, message, field=None):        super().__init__(message)        self.field = field raise ValidationError("邮箱格式错误", field="email") 

四、迭代器与生成器

迭代器

python
lst = [1, 2, 3]it = iter(lst)          # 获取迭代器next(it)                # 1next(it)                # 2next(it)                # 3next(it)                # StopIteration 异常 

生成器

python
def countdown(n):    """每次 yield 返回一个值，函数状态被冻结"""    while n > 0:        yield n        n -= 1 for num in countdown(5):     # 5, 4, 3, 2, 1    print(num) # 生成器表达式（惰性求值，省内存）gen = (x**2 for x in range(10**6))  # 不会立即计算next(gen)  # 0next(gen)  # 1 

生成器 vs 列表：

• 生成器：惰性，逐个产生值，省内存但不支持索引
• 列表：一次性全部计算，支持随机访问但占内存

yield from（委托子生成器）

python
def flatten(nested):    for sublist in nested:        yield from sublist     # 等价于 for item in sublist: yield item list(flatten([[1, 2], [3, 4]]))  # [1, 2, 3, 4] 

五、装饰器

闭包基础

python
def outer(x):    def inner(y):        return x + y     # inner 记住了 outer 的 x    return inner add5 = outer(5)    # add5 是一个闭包add5(3)            # 8 

@语法糖

python
def timer(func):    import time    def wrapper(*args, **kwargs):        start = time.time()        result = func(*args, **kwargs)        print(f"{func.__name__} 耗时: {time.time() - start:.4f}s")        return result    return wrapper @timer              # 等价于 slow_func = timer(slow_func)def slow_func():    time.sleep(0.5) 

functools.wraps（保留原函数元信息）

python
from functools import wraps def logger(func):    @wraps(func)       # 保留 __name__、__doc__ 等    def wrapper(*args, **kwargs):        print(f"调用 {func.__name__}")        return func(*args, **kwargs)    return wrapper 

带参数装饰器

python
def repeat(n):    def decorator(func):        @wraps(func)        def wrapper(*args, **kwargs):            for _ in range(n):                result = func(*args, **kwargs)            return result        return wrapper    return decorator @repeat(3)       # hello 会执行 3 次def hello():    print("Hello!") 

常用装饰器

python
@staticmethod     # 静态方法（不需要 self/cls）@classmethod      # 类方法（第一个参数是 cls）@property         # 将方法变为属性访问@lru_cache        # 缓存函数结果（functools） 

六、面向对象（OOP）

类与实例

python
class Person:    species = "Homo sapiens"     # 类属性（所有实例共享）     def __init__(self, name, age):        self.name = name          # 实例属性        self._age = age           # 约定"受保护"（单下划线）        self.__secret = "hidden"  # 名称改写为 _Person__secret     def greet(self):        return f"Hi, I'm {self.name}"     @classmethod    def create_anonymous(cls):        return cls("Anonymous", 0)     @staticmethod    def is_adult(age):        return age >= 18 # 调用p = Person("Alice", 25)Person.create_anonymous()   # 类方法Person.is_adult(20)          # 静态方法 

继承与多态

python
class Student(Person):    def __init__(self, name, age, school):        super().__init__(name, age)  # 调用父类 __init__        self.school = school     def greet(self):                  # 重写（多态）        return f"{super().greet()} from {self.school}" # 多继承（MRO: 方法解析顺序）class A: passclass B(A): passclass C(A): passclass D(B, C): pass   # MRO: D → B → C → Aprint(D.__mro__) 

slots — 节省内存

python
class Point:    __slots__ = ('x', 'y')    # 只允许这两个属性，不能动态添加    def __init__(self, x, y):        self.x, self.y = x, y 

七、魔术方法

python
class Vector:    def __init__(self, x, y):        self.x, self.y = x, y     def __repr__(self):         # 开发者友好的字符串表示        return f"Vector({self.x}, {self.y})"     def __str__(self):          # 用户友好的字符串表示        return f"({self.x}, {self.y})"     def __add__(self, other):   # v1 + v2        return Vector(self.x + other.x, self.y + other.y)     def __eq__(self, other):    # v1 == v2        return self.x == other.x and self.y == other.y     def __hash__(self):         # 用于 set/dict 的哈希值        return hash((self.x, self.y))  # 必须和 __eq__ 一致     def __call__(self):         # 让实例像函数一样被调用        return f"called {self}"     def __getitem__(self, i):   # v[0]        return [self.x, self.y][i]     def __len__(self):          # len(v)        return 2 

上下文管理器

python
class DatabaseConnection:    def __enter__(self):        print("连接数据库")        return self     def __exit__(self, exc_type, exc_val, exc_tb):        print("关闭连接")        return False   # False = 异常继续传播 with DatabaseConnection() as conn:    # 使用连接...    pass # 也可以用 contextlibfrom contextlib import contextmanager @contextmanagerdef db_connection():    print("连接")    yield "conn"       # 资源在这里返回    print("关闭")      # 退出时执行（即使有异常也执行） 

八、赋值与引用

python
# 可变对象的赋值是引用a = [1, 2, 3]b = a               # b 和 a 指向同一个列表b.append(4)          # a 也变成 [1, 2, 3, 4] # 浅拷贝import copyb = copy.copy(a)     # 或 a[:], a.copy()b = a.copy() # 深拷贝b = copy.deepcopy(a)  # 递归拷贝所有嵌套对象 # 不可变对象的行为x = 42y = x               # 值拷贝，y 和 x 互相独立y += 1               # x 不变 

九、常用内置函数

python
# 高阶函数map(str, [1, 2, 3])              # ["1", "2", "3"]filter(lambda x: x > 0, [-1, 2, 3])  # [2, 3]from functools import reducereduce(lambda a, b: a+b, [1, 2, 3])  # 6 # 排序sorted([3, 1, 2])                     # [1, 2, 3]sorted(["aa", "b"], key=len)          # 按长度排序: ["b", "aa"] # 聚合any([False, True, False])  # True（任一为真）all([True, True, False])   # False（全部为真） # 组合list(zip([1, 2], ['a', 'b']))    # [(1, 'a'), (2, 'b')]list(enumerate(['a', 'b', 'c']))  # [(0, 'a'), (1, 'b'), (2, 'c')] # 类型isinstance(42, int)     # Truecallable(print)         # Truehasattr(obj, 'method')  # True 如果有该方法