Python 基础

导语

Python 作为一门简洁高效的编程语言，在数据分析、AI 开发、后端服务等领域广泛应用。掌握其核心基础知识点，是应对面试、提升代码质量和解决实际问题的关键。本文将系统梳理 Python 开发中高频出现的 8 大核心模块，包括数据类型、装饰器、迭代器/生成器、GIL、反射/GC/上下文管理器、对象比较、正则模块及内置函数，帮助你快速回顾并深化理解这些基础但至关重要的概念。

1. 数据类型：不可变 vs 可变

Python 数据类型分为不可变类型和可变类型，这一分类直接影响变量赋值、内存管理和使用场景。

1.1 不可变类型（3 类）

• Number（数字）：包括 int、float、complex，不可变。修改数值会创建新对象，例如 a = 1; a += 1 实际是 a 指向新的整数对象。
• String（字符串）：不可变序列，支持索引和切片（如 s = "hello"; s[0] = 'H' 会报错）。常用于存储文本信息，如用户输入、配置文件内容。
• Tuple（元组）：有序不可变序列，元素可不同类型（如 (1, "a", True)）。因不可变特性，适合存储固定数据（如坐标 (x, y)）或作为字典的键（若元素可哈希）。

1.2 可变类型（3 类）

• List（列表）：有序可变序列，支持动态增删（如 lst = [1,2]; lst.append(3)）。适合存储动态变化的数据，如待处理任务列表。
• Dictionary（字典）：键值对集合，键唯一且可哈希（如 d = {"name": "Alice", "age": 25}）。用于快速映射查询，如配置项、用户信息。
• Set（集合）：无序不重复元素，支持交/并/差运算（如 s1 = {1,2}; s2 = {2,3}; s1 & s2 = {2}）。常用于去重或集合运算，如标签去重、权限校验。

2. 装饰器：动态增强函数行为

装饰器是 Python 中函数/类行为动态修改的核心工具，本质是一个接收函数并返回新包装函数的函数。它允许你在不修改原函数代码的前提下，为函数添加额外逻辑（如日志、计时、权限检查）。

2.1 基础原理

# 简单装饰器示例
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("执行前逻辑")
        result = func(*args, **kwargs)
        print("执行后逻辑")
        return result
    return wrapper

@my_decorator  # 语法糖：等价于 func = my_decorator(func)
def say_hello():
    print("Hello!")

2.2 常见类型

• 函数装饰器：最基础形式，如上述 @my_decorator。
• 带参装饰器：通过「工厂函数」实现参数化，例如 @repeat(3) 表示重复执行 3 次：
  python def repeat(times): def decorator(func): def wrapper(*args, **kwargs): for _ in range(times): func(*args, **kwargs) return wrapper return decorator
• 类装饰器：通过 __call__ 方法实现，适合复杂逻辑封装（如状态管理）。
• 内置装饰器：Python 内置 @staticmethod（静态方法）、@classmethod（类方法）、@property（属性访问器）等，用于优化类的设计。

2.3 实战应用：速率限制器

import time
from functools import wraps

def rate_limiter(seconds=10):
    def decorator(func):
        last_called = None  # 记录上次调用时间
        @wraps(func)
        def wrapper(*args, **kwargs):
            nonlocal last_called  # 修改外层变量
            now = time.time()
            if last_called and now - last_called < seconds:
                return "Too frequent! Please try again later."
            last_called = now
            return func(*args, **kwargs)
        return wrapper
    return decorator

@rate_limiter(seconds=10)
def api_call():
    return "API response"

用途：防止 API 频繁调用（如防刷、防重复提交），通过 nonlocal 记录调用时间，控制请求间隔。

3. 迭代器 vs 生成器：高效处理数据序列

3.1 迭代器（Iterator）

• 定义：记住遍历位置的对象，只能向前遍历，通过 __iter__() 和 __next__() 协议实现。
• 核心方法：
• iter(iterable)：将可迭代对象转为迭代器。
• next(iterator)：返回迭代器的下一个元素，无元素时抛出 StopIteration。
• 示例：
  python class Counter: def __init__(self, start, end): self.start = start self.end = end def __iter__(self): return self def __next__(self): if self.start >= self.end: raise StopIteration current = self.start self.start += 1 return current # 使用迭代器 it = Counter(1, 4) print(next(it)) # 1 print(next(it)) # 2

3.2 生成器（Generator）

• 定义：用 yield 关键字的特殊函数，迭代中逐步产生值（而非一次性返回），内存效率极高。
• 核心优势：避免一次性加载大量数据到内存，适合处理大数据流（如日志分析、无限序列）。
• 示例：
  ```python
  def fibonacci():
  a, b = 0, 1
  while True:
  yield a
  a, b = b, a + b

# 使用生成器
fib = fibonacci()
print(next(fib)) # 0
print(next(fib)) # 1
print(next(fib)) # 1
```

4. GIL：全局解释器锁的影响

4.1 什么是 GIL？

GIL（Global Interpreter Lock）是 CPython 解释器的全局锁，确保同一时间只有一个线程执行 Python 字节码。

4.2 对多线程的影响

• CPU 密集型任务：多线程效率低于单线程（锁竞争导致线程切换开销）。例如：计算圆周率的循环任务，多线程反而更慢。
• I/O 密集型任务：多线程有效（线程大部分时间在等待 I/O，锁竞争少）。例如：并发调用 LLM API、读写文件。

4.3 优化策略

• CPU 密集型：改用多进程（multiprocessing 模块），绕过 GIL，利用多核 CPU。
• I/O 密集型：多线程 + 异步（asyncio）或 gevent 协程，进一步提升并发效率。

5. 反射 / GC / 上下文管理器

5.1 反射（Reflection）

• 定义：通过字符串动态调用对象属性/方法（如 getattr/setattr）。
• 核心函数：
• getattr(obj, name)：获取对象属性。
• setattr(obj, name, value)：设置对象属性。
• hasattr(obj, name)：检查属性是否存在。
• 应用场景：Agent 插件路由（根据配置动态加载不同模块的函数）。

5.2 垃圾回收（GC）

• 机制：Python 以引用计数为主，标记清除和分代回收为辅。
• 引用计数：对象被引用次数减为 0 时自动回收。
• 标记清除：解决循环引用问题（如两个对象互相引用）。
• 分代回收：优先回收长期未使用的对象，提升效率。

5.3 上下文管理器（Context Manager）

• 定义：通过 __enter__/__exit__ 协议，确保资源自动释放（如文件、数据库连接）。
• 语法：with 语句自动调用 __enter__（返回资源）和 __exit__（释放资源）。
• 示例：
  python class DBConnection: def __enter__(self): self.conn = connect_to_db() # 建立连接 return self.conn def __exit__(self, exc_type, exc_val, exc_tb): self.conn.close() # 关闭连接 # 使用 with DBConnection() as conn: conn.query("SELECT * FROM users")

6. == vs eq：对象比较的本质

• == 操作符：默认比较对象的内存地址（即引用是否相同），不可重写。
• __eq__ 方法：可在类中重写，自定义相等逻辑。
• 示例：
  ```python
  class User:
  def init(self, id):
  self.id = id
  def eq(self, other):
  if not isinstance(other, User):
  return False
  return self.id == other.id

u1 = User(1)
u2 = User(1)
print(u1 == u2) # True（因重写了 eq）
```

7. re 正则模块：字符串匹配利器

re 模块提供高效字符串处理工具，核心函数与用法：

7.1 基础匹配

• re.match(pattern, string)：从字符串开头匹配。
• re.search(pattern, string)：全文匹配第一个结果。
• re.findall(pattern, string)：返回所有匹配结果列表。

7.2 替换与分割

• re.sub(pattern, repl, string)：替换匹配项。
• re.split(pattern, string)：按匹配项分割字符串。

7.3 高级特性

• 预编译：re.compile(pattern) 复用正则对象，提升多次匹配效率。
• 标志：re.IGNORECASE（忽略大小写）、re.DOTALL（. 匹配换行符）。
• 分组：(group) 捕获子串，(?P<name>) 命名分组。
• 断言：(?=...) 先行断言（匹配后接内容）、(?<=...) 后行断言。

8. 常用内置函数：提升编码效率

8.1 数值与转换

• 数值：abs(-10)（绝对值）、round(3.1415, 2)（四舍五入）、sum([1,2,3])（求和）。
• 转换：int("123")（转整数）、float("3.14")（转浮点数）、str(123)（转字符串）。

8.2 迭代与映射

• map(func, iterable)：对每个元素执行函数。
• filter(func, iterable)：过滤满足条件的元素。
• zip(*iterables)：并行迭代多个序列（行转列）。
• 真题代码：行转列 arr = list(map(list, zip(*arr)))。

8.3 迭代器与反射工具

• iter(iterable)：转为迭代器。
• next(iterator)：获取下一个元素。
• type(obj)/isinstance(obj, Type)：类型检查。

小结

本文系统梳理了 Python 核心基础知识点：
- 数据类型：理解可变/不可变特性，选择合适容器。
- 装饰器：动态增强函数行为，掌握带参/类装饰器及内置用法。
- 迭代器/生成器：高效处理序列，生成器内存优势显著。
- GIL：根据任务类型选择多线程/多进程，优化性能。
- 反射/GC/上下文管理器：动态调用、内存管理、资源自动释放。
- 对象比较：区分 == 和 __eq__ 的行为。
- 正则模块：灵活处理字符串匹配与替换。
- 内置函数：提升代码简洁性与效率。

这些知识点是 Python 开发的基石，建议结合实战场景（如写一个简单爬虫、实现异步 API 调用）加深理解。