如何从其他编程语言顺利过渡到掌握Pythonic编程思维？

想学学python搞ai应用开发，但是好多教程都是从“hello world" 开始，太痛苦了。因此，整理了这份文档。面向有编程基础的开发者，快速掌握 Python 开发全貌 一、环境管理 Python 版本管理 macOS / Linux（pyenv） # 安装 pyenv curl https://pyenv.run | bash # 常用命令 pyenv install 3.12.0 # 安装指定版本 pyenv global 3.12.0 # 设置全局版本 pyenv local 3.11.0 # 设置当前目录版本（生成 .python-version） pyenv versions # 列出所有已安装版本 pyenv which python # 查看当前 python 路径 Windows（PowerShell） # 方式一：winget 直接安装（最简单） # 设置国内源加速：winget source add winget https://mirrors.cernet.edu.cn/winget-source --trust-level trusted winget search Python.Python # 搜索可用版本 winget install Python.Python.3.12 # 安装 winget upgrade Python.Python.3.12 # 升级 # 验证（Windows 用 python，不是 python3） python --version pip --version ⚠️ 使用官网 .exe​ 安装包时，务必勾选 ​Add Python to PATH​，否则终端找不到 python 命令。 # 方式二：pyenv-win（推荐，支持多版本切换） Invoke-WebRequest -UseBasicParsing ` -Uri "https://raw.githubusercontent.com/pyenv-win/pyenv-win/master/pyenv-win/install-pyenv-win.ps1" ` -OutFile "$HOME\install-pyenv-win.ps1" & "$HOME\install-pyenv-win.ps1" # 重启 PowerShell 后，命令与 Unix pyenv 完全相同 # 配置环境变量，使用加速源。环境变量名：PYTHON_BUILD_MIRROR_URL，值：https://registry.npmmirror.com/-/binary/python pyenv install 3.12.0 pyenv global 3.12.0 pyenv local 3.11.0 pyenv versions pyenv rehash # 安装新版本后刷新 shims # 如果 python 命令找不到，检查 PATH where.exe python $env:PATH -split ";" 虚拟环境 macOS / Linux python -m venv .venv # 创建 source .venv/bin/activate # 激活 deactivate # 退出 Windows（PowerShell） # 创建（与 Unix 相同） python -m venv .venv # 激活 —— PowerShell 专用，注意与 bash 不同！ .\.venv\Scripts\Activate.ps1 # 激活后提示符出现 (.venv) 前缀 # (.venv) PS C:\myproject> # 退出 deactivate # 删除虚拟环境 Remove-Item -Recurse -Force .venv ⚠️ 首次激活若报"无法加载文件"执行策略错误，运行一次即可解决： Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser :: CMD（命令提示符）激活方式 .venv\Scripts\activate.bat # Git Bash 激活方式 source .venv/Scripts/activate conda（科学计算场景，跨平台） conda create -n myenv python=3.12 conda activate myenv conda deactivate 现代工具链（推荐 uv） # uv：极速包管理器，兼容 pip 语法，Rust 编写 pip install uv uv venv # 创建虚拟环境 uv pip install requests # 安装包 uv pip sync requirements.txt # 同步依赖 二、包管理 pip 基础命令 pip install requests # 安装 pip install requests==2.31.0 # 安装指定版本 pip install "requests>=2.28,<3" # 版本范围 pip uninstall requests # 卸载 pip list # 列出已安装包 pip show requests # 查看包信息 pip freeze > requirements.txt # 导出依赖 pip install -r requirements.txt # 从文件安装 pip install -e . # 以开发模式安装当前包 pip install --upgrade requests # 升级 requirements.txt requests==2.31.0 numpy>=1.24.0 pandas fastapi[all]>=0.100.0 pyproject.toml（现代项目标准） [build-system] requires = ["hatchling"] build-backend = "hatchling.build" [project] name = "my-project" version = "0.1.0" description = "My awesome project" readme = "README.md" requires-python = ">=3.10" dependencies = [ "requests>=2.28", "fastapi>=0.100", ] [project.optional-dependencies] dev = [ "pytest>=7.0", "black", "mypy", ] [project.scripts] my-cli = "my_project.cli:main" # 命令行入口 三、项目结构 标准项目结构 my_project/ ├── .venv/ # 虚拟环境（不提交 git） ├── .github/ │ └── workflows/ # CI/CD 配置 ├── src/ │ └── my_project/ # 源代码（src layout，推荐） │ ├── __init__.py │ ├── main.py # 主程序 │ ├── config.py # 配置 │ ├── models/ │ │ ├── __init__.py │ │ └── user.py │ ├── services/ │ │ ├── __init__.py │ │ └── user_service.py │ └── utils/ │ ├── __init__.py │ └── helpers.py ├── tests/ │ ├── __init__.py │ ├── conftest.py # pytest 配置/fixtures │ ├── test_main.py │ └── services/ │ └── test_user_service.py ├── docs/ ├── scripts/ # 工具脚本 ├── .env # 环境变量（不提交 git） ├── .env.example # 环境变量示例（提交 git） ├── .gitignore ├── pyproject.toml # 项目配置（现代标准） ├── requirements.txt # 依赖（可选） └── README.md 简单脚本结构 simple_app/ ├── app.py ├── requirements.txt └── .env 四、程序入口 # main.py def main(): print("Hello, Python!") # 关键：判断是否作为主程序运行（而非被导入） if __name__ == "__main__": main() # 运行方式 python main.py python -m my_project.main # 以模块方式运行 命令行参数 import argparse def main(): parser = argparse.ArgumentParser(description="My tool") parser.add_argument("name", help="Your name") parser.add_argument("-v", "--verbose", action="store_true") parser.add_argument("--count", type=int, default=1) args = parser.parse_args() for _ in range(args.count): print(f"Hello, {args.name}!") if __name__ == "__main__": main() 五、基础语法 变量与赋值 # 变量赋值示例 x = 10 # 动态类型，可以随时改变类型 print(x) # 输出 10 x = "Hello, World!" # 现在 x 是一个字符串 print(x) # 输出 "Hello, World!" x, y, z = 20, 30, 40 # 多变量赋值 print(x, y, z) # 输出 20 30 40 a = b = c = 50 # 链式赋值 print(a, b, c) # 输出 50 50 50 x, *rest = [1, 2, 3, 4, 5] # 解包赋值，rest 将包含剩余的值 print(x) # 输出 1 print(rest) # 输出 [2, 3, 4, 5] _, second, *_ = [10, 20, 30, 40] # 使用 _ 忽略不需要的值 print(second) # 输出 20 # 命名规范 my_variable = 100 # 变量名应该使用小写字母和下划线分隔（snake_case） MY_CONSTANT = 3.14 # 常量名应该使用大写字母和下划线分隔（UPPER_SNAKE_CASE） MyClass = "This is a class name" # 类名应该使用大写字母开头的驼峰命名法（PascalCase） _private_variable = "This is a private variable" # 私有变量通常以单下划线开头 __dunder_variable__ = "This is a dunder variable" # 双下划线变量通常用于特殊用途,如 __init__ 或 __str__ 注释 # 单行注释 """ 多行注释示例 这是一个多行注释的示例，可以用于函数说明文档或者代码块的解释。 """ def example_function(param1, param2) -> str: """ 函数说明文档 Args: param1 (int): 这是第一个参数的说明 param2 (str): 这是第二个参数的说明 Returns: str: 这是函数返回值的说明 """ pass # 这里是函数体的占位符，实际代码应该在这里编写 基本运算 # 算术 10 + 3 # 13 10 - 3 # 7 10 * 3 # 30 10 / 3 # 3.3333...（真除法，始终返回 float） 10 // 3 # 3（整除） 10 % 3 # 1（取余） 10 ** 3 # 1000（幂运算） # 比较（返回 bool） x == y # 等于 x != y # 不等于 x > y # 大于 x >= y # 大于等于 # 逻辑 True and False # False True or False # True not True # False # 成员 & 身份 x in [1, 2, 3] # True/False x not in [1, 2, 3] x is None # 身份比较（比较对象地址） x is not None 六、数据类型 数字 i = 42 # int（任意精度） f = 3.14 # float c = 1 + 2j # complex b = True # bool（int 的子类，True==1, False==0） # 转换 int("42") # 42 float("3.14") # 3.14 str(42) # "42" bool(0) # False（0, "", [], None 均为 falsy） # 数字字面量 1_000_000 # 下划线分隔（可读性） 0xFF # 十六进制 0b1010 # 二进制 0o17 # 八进制 字符串 s = "hello" s = 'hello' s = """多行 字符串""" # f-string（推荐，Python 3.6+） name = "Alice" print(f"Hello, {name}!") print(f"2 + 3 = {2 + 3}") print(f"{3.14159:.2f}") # 格式化浮点数, 保留两位小数 print(f"{{}}") # 输出花括号 print(f"{1000000:,}") # 数字千位分隔符, 1,000,000 print(f"{'Alice':>10}") # 右对齐, Alice print(f"{'Bob':<10}") # 左对齐, Bob # 常用方法 s.upper() / s.lower() s.strip() / s.lstrip() / s.rstrip() # 去空白 s.split(",") / ",".join(["a","b"]) s.replace("old", "new") s.startswith("he") / s.endswith("lo") s.find("ll") # 返回索引，找不到返回 -1 s.count("l") s.format(name="Alice") # 旧式格式化 # 切片 s = "Hello" s[0] # 'H' s[-1] # 'o' s[1:3] # 'el' s[::-1] # 'olleH'（反转） # s[0] = "h" ❌ # 字符串是不可变的，会报错 列表 list lst = [1, 2, 3, "four", True] # 可混合类型 lst = list(range(5)) # [0,1,2,3,4] # 增删改查 lst.append(5) # 末尾添加 lst.insert(0, 99) # 指定位置插入 lst.extend([6, 7]) # 追加多个 lst.remove(99) # 删除第一个匹配值 popped = lst.pop() # 删除并返回末尾 popped = lst.pop(0) # 删除并返回指定索引 del lst[0] # 删除指定索引 lst[0] = 100 # 修改 # 查询 lst[0] # 索引访问 lst[-1] # 最后一个 lst[1:3] # 切片 len(lst) lst.index(2) # 返回索引 lst.count(2) # 计数 2 in lst # True/False # 排序 lst.sort() # 原地排序 lst.sort(reverse=True) lst.sort(key=lambda x: x[1]) # 自定义排序键 sorted(lst) # 返回新列表，不修改原列表 # 列表推导式（重要！） squares = [x**2 for x in range(10)] evens = [x for x in range(20) if x % 2 == 0] flat = [item for sublist in [[1,2],[3,4]] for item in sublist] 元组 tuple t = (1, 2, 3) # 不可变 t = 1, 2, 3 # 括号可省略 t = (42,) # 单元素元组（注意逗号） t = tuple([1, 2, 3]) t[0] # 访问 a, b, c = t # 解包 len(t) t.count(1) # 统计元素出现的次数 t.index(2) # 返回元素第一次出现的索引 # 元组可作字典键（list 不行） d = {(0, 0): "origin"} 字典 dict d = {"name": "Alice", "age": 30} d = dict(name="Alice", age=30) d = {i: i**2 for i in range(5)} # 字典推导式 # 增删改查 d["name"] # 访问（KeyError if missing） d.get("name") # 安全访问，默认返回 None d.get("x", "default") # 指定默认值 d["email"] = "a@b.com" # 添加/修改 del d["age"] # 删除 d.pop("age", None) # 删除并返回（带默认值） # 遍历 d.keys() d.values() d.items() # (key, value) 对 for k, v in d.items(): print(k, v) # 合并（Python 3.9+） merged = d1 | d2 d1 |= d2 # 原地合并 # 其他 "name" in d # 检查 key 是否存在 d.setdefault("x", 0) # 不存在则设置默认值 d.update({"a": 1}) # 批量更新 集合 set s = {1, 2, 3} s = set([1, 2, 2, 3]) # {1, 2, 3}（自动去重） s = set() # 空集合（注意：{} 是空字典） s.add(4) s.remove(1) # KeyError if missing s.discard(99) # 安全删除，不存在不报错 # 集合运算 a | b # 并集 a & b # 交集 a - b # 差集（在 a 不在 b） a ^ b # 对称差（在 a 或 b，但不同时在） a.issubset(b) # a ⊆ b a.issuperset(b) # 集合推导式 s = {x**2 for x in range(10)} None 与布尔 x = None # 空值（类似 null） x is None # 推荐判断方式 # Falsy 值 bool(None) # False bool(0) # False bool("") # False bool([]) # False bool({}) # False bool(set()) # False # Truthy：其他所有值 七、控制流 条件 if x > 0: print("正数") elif x < 0: print("负数") else: print("零") # 三元表达式 result = "yes" if condition else "no" # match-case（Python 3.10+，类似 switch） match command: case "quit": quit() case "hello": print("Hello!") case {"action": action, "value": value}: # 匹配字典 print(action, value) case _: # 默认分支 print("Unknown") 循环 # for 循环 for i in range(5): # 0,1,2,3,4 print(i) for i in range(2, 10, 2): # 2,4,6,8（步长2） pass for item in [1, 2, 3]: pass for i, item in enumerate(["a","b","c"]): # 带索引 print(i, item) for k, v in d.items(): # 遍历字典 for a, b in zip([1,2,3], ["x","y","z"]): # 并行遍历 print(a, b) # while 循环 while condition: pass # 控制 break # 退出循环 continue # 跳到下一次 for ... else: # 循环正常结束（未被break）时执行 else pass else: print("loop done") 八、函数 基础 def greet(name, greeting="Hello"): # 默认参数 """函数文档字符串。""" return f"{greeting}, {name}!" # 调用 greet("Alice") greet("Alice", greeting="Hi") # 关键字参数 greet(greeting="Hi", name="Alice") # 关键字参数顺序无关 参数类型 符号 位置 规则 ​ ​/​ 参数列表之中 左边的参数必须用位置传参 ​ ​*​ 参数列表之中 右边的参数必须用关键字传参（key=value） 顺序 参数类型 描述 示例 1 必选参数 必须提供的基础参数 ​def func(a, b): 2 默认参数 带有默认值的参数 ​def func(a, b=10): 3 可变参数 收集多余的位置参数 (*args) ​def func(a, *args): 4 关键字可变参数 收集多余的键值对 (**kwargs) ​def func(a, **kwargs): def func(a, b, /, c, *, d, e): # a, b：仅位置参数（/前） # c：普通参数 # d, e：仅关键字参数（*后） pass def variadic(*args, **kwargs): print(args) # 元组 print(kwargs) # 字典 variadic(1, 2, 3, x=4, y=5) # args = (1, 2, 3) # kwargs = {'x': 4, 'y': 5} # 解包传参 lst = [1, 2, 3] func(*lst) # 解包列表 func(**{"a": 1}) # 解包字典 Lambda 函数 add = lambda x, y: x + y add(1, 2) # 3 # 常用于 sort/map/filter sorted(data, key=lambda x: x["age"]) list(map(lambda x: x*2, [1,2,3])) list(filter(lambda x: x > 0, [-1, 0, 1, 2])) 函数特性 # 函数是一等公民（可作参数、返回值） def apply(func, value): return func(value) apply(str.upper, "hello") # 闭包 def make_counter(): count = 0 def counter(): nonlocal count # 修改外部变量用 nonlocal count += 1 return count return counter c = make_counter() c() # 1 c() # 2 九、面向对象 基础类 什么时候使用：当你的类包含复杂的业务逻辑、需要复杂的继承体系，或者你需要严格控制属性的访问权限 class Animal: # 类变量（所有实例共享） species_count = 0 def __init__(self, name: str, age: int): # 实例变量，每个实例独有的 self.name = name self.age = age self._weight = 0 # 约定受保护 self.__secret = "..." # 名称改写（mangling） Animal.species_count += 1 def __repr__(self): """开发者表示，优先级高""" return f"Animal(name={self.name!r}, age={self.age})" def __str__(self): """用户友好表示""" return f"{self.name} ({self.age}岁)" def __len__(self): return self.age def __eq__(self, other): return isinstance(other, Animal) and self.name == other.name def speak(self): # 普通方法，必须由实例调用 raise NotImplementedError @classmethod # 类方法，第一个参数是类本身 def create(cls, name): """类方法，第一个参数是类本身""" return cls(name, 0) @staticmethod # 静态方法，是工具函数 def validate_age(age): """静态方法，与类/实例无关""" return age >= 0 @property # Getter，使用`a.weight`会调用这个函数 def weight(self): """属性装饰器（getter）""" return self._weight @weight.setter # Setter，`a.weight = -5`会调用这个函数 def weight(self, value): if value < 0: raise ValueError("体重不能为负") self._weight = value 继承 class Dog(Animal): def __init__(self, name, age, breed): super().__init__(name, age) # 调用父类初始化 self.breed = breed def speak(self): return "Woof!" def __repr__(self): return f"Dog(name={self.name!r}, breed={self.breed!r})" # 多继承 class C(A, B): pass # MRO（方法解析顺序）：C → A → B → object print(C.__mro__) 数据类（Python 3.7+） 什么时候使用：当你的类主要目的是存储数据（如数据库记录、配置信息、API 响应） from dataclasses import dataclass, field @dataclass class Point: x: float y: float z: float = 0.0 # 默认值 tags: list = field(default_factory=list) # 可变默认值用 field def distance(self): return (self.x**2 + self.y**2) ** 0.5 p = Point(1.0, 2.0) # 自动生成 __init__, __repr__, __eq__ @dataclass(frozen=True) # 不可变 class FrozenPoint: x: float y: float 抽象类 from abc import ABC, abstractmethod class Shape(ABC): @abstractmethod def area(self) -> float: pass @abstractmethod def perimeter(self) -> float: pass class Circle(Shape): def __init__(self, radius: float): self.radius = radius def area(self): import math return math.pi * self.radius ** 2 def perimeter(self): import math return 2 * math.pi * self.radius 十、模块与包 导入 import os # 导入模块 import os.path # 导入子模块 from os import path # 导入模块中的名称 from os.path import join, exists # 导入多个 from os import * # 导入全部（不推荐） import numpy as np # 别名（惯例） from . import utils # 相对导入（同包内） from ..models import User # 相对导入（上级包） __init__.py # my_package/__init__.py # 控制 from my_package import * 时暴露的内容 __all__ = ["MyClass", "my_function"] from .my_module import MyClass from .utils import my_function __version__ = "0.1.0" 十一、异常处理 # 捕获异常 try: result = 10 / 0 except ZeroDivisionError: print("除零错误") except (TypeError, ValueError) as e: print(f"类型或值错误: {e}") except Exception as e: print(f"未知错误: {e}") raise # 重新抛出 else: print("无异常时执行") finally: print("始终执行（清理资源）") # 抛出异常 raise ValueError("无效的值") raise ValueError("无效的值") from original_error # 异常链 # 自定义异常 class AppError(Exception): """应用基础异常""" pass class NotFoundError(AppError): def __init__(self, resource, id): self.resource = resource self.id = id super().__init__(f"{resource} with id={id} not found") # 常见内置异常 # Exception, ValueError, TypeError, KeyError, IndexError # AttributeError, NameError, ImportError, FileNotFoundError # RuntimeError, StopIteration, NotImplementedError # OverflowError, MemoryError, RecursionError 十二、文件操作 # 读文件（推荐 with 语句，自动关闭） with open("file.txt", "r", encoding="utf-8") as f: content = f.read() # 全部读取为字符串 lines = f.readlines() # 读取所有行为列表 for line in f: # 逐行读取（节省内存） print(line.strip()) # 写文件 with open("file.txt", "w", encoding="utf-8") as f: f.write("Hello\n") f.writelines(["line1\n", "line2\n"]) # 追加 with open("file.txt", "a") as f: f.write("new line\n") # 二进制 with open("image.png", "rb") as f: data = f.read() # 文件模式 # "r" 只读（默认） # "w" 写入（覆盖） # "a" 追加 # "x" 创建（已存在则报错） # "b" 二进制模式 # "+" 读写模式 # pathlib（现代文件路径，推荐） from pathlib import Path p = Path("./data") p.mkdir(parents=True, exist_ok=True) file = p / "output.txt" # 路径拼接 file.write_text("Hello", encoding="utf-8") content = file.read_text(encoding="utf-8") file.exists() file.is_file() / file.is_dir() file.suffix # ".txt" file.stem # "output" file.name # "output.txt" file.parent # Path("./data") list(p.glob("*.txt")) # 匹配文件 list(p.rglob("*.py")) # 递归匹配 # JSON import json with open("data.json", "w") as f: json.dump({"key": "value"}, f, indent=2, ensure_ascii=False) with open("data.json") as f: data = json.load(f) json.dumps(obj) # 对象 → 字符串 json.loads(s) # 字符串 → 对象 十三、迭代器与生成器 迭代器协议 # 实现 __iter__ 和 __next__ class Counter: def __init__(self, limit): self.limit = limit self.current = 0 def __iter__(self): return self def __next__(self): if self.current >= self.limit: raise StopIteration self.current += 1 return self.current 生成器（更简洁） # 生成器函数（含 yield） def countdown(n): while n > 0: yield n # 暂停并返回值 n -= 1 for x in countdown(5): print(x) # 生成器表达式（惰性求值，节省内存） gen = (x**2 for x in range(1000000)) # 不立即计算 next(gen) # 按需获取 # yield from（委托子生成器） def chain(*iterables): for it in iterables: yield from it # 实用函数 import itertools itertools.chain([1,2], [3,4]) # 串联 itertools.product([1,2], ["a","b"]) # 笛卡尔积 itertools.groupby(data, key=lambda x: x["type"]) itertools.islice(gen, 10) # 切片生成器 import functools functools.reduce(lambda a, b: a+b, [1,2,3,4]) # 折叠 十四、装饰器 import functools # 基础装饰器 def my_decorator(func): @functools.wraps(func) # 保留原函数元信息 def wrapper(*args, **kwargs): print("before") result = func(*args, **kwargs) print("after") return result return wrapper @my_decorator def say_hello(): print("Hello!") # 带参数的装饰器 def repeat(n): def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): for _ in range(n): result = func(*args, **kwargs) return result return wrapper return decorator @repeat(3) def greet(name): print(f"Hello, {name}!") # 常用内置装饰器 @staticmethod # 静态方法 @classmethod # 类方法 @property # 属性 @functools.lru_cache(maxsize=128) # 缓存（记忆化） @functools.cache # Python 3.9+，无大小限制的缓存 十五、上下文管理器 # 实现 __enter__ 和 __exit__ class Timer: import time def __enter__(self): self.start = self.time.time() return self def __exit__(self, exc_type, exc_val, exc_tb): self.elapsed = self.time.time() - self.start return False # False: 不抑制异常；True: 抑制异常 with Timer() as t: # do something pass print(f"耗时: {t.elapsed:.3f}s") # 使用 contextlib（更简洁） from contextlib import contextmanager @contextmanager def managed_resource(): print("获取资源") try: yield "resource" # yield 之前是 __enter__ finally: print("释放资源") # finally 是 __exit__ with managed_resource() as r: print(f"使用 {r}") 十六、并发编程 多线程（I/O 密集型） import threading def worker(n): print(f"线程 {n} 运行") threads = [threading.Thread(target=worker, args=(i,)) for i in range(5)] for t in threads: t.start() for t in threads: t.join() # 线程安全 lock = threading.Lock() with lock: # 临界区 pass 多进程（CPU 密集型） from multiprocessing import Pool def square(n): return n ** 2 with Pool(processes=4) as pool: results = pool.map(square, range(10)) 异步 I/O（asyncio） import asyncio async def fetch_data(url): await asyncio.sleep(1) # 模拟异步 I/O return f"data from {url}" async def main(): # 并发执行多个任务 tasks = [fetch_data(url) for url in ["a.com", "b.com", "c.com"]] results = await asyncio.gather(*tasks) print(results) asyncio.run(main()) # 运行事件循环 # async with / async for async def read_file(): async with aiofiles.open("file.txt") as f: # 需要 aiofiles 库 async for line in f: print(line) concurrent.futures（高层接口） from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor # 线程池 with ThreadPoolExecutor(max_workers=4) as executor: futures = [executor.submit(func, arg) for arg in args] results = [f.result() for f in futures] # map 方式（更简洁） with ThreadPoolExecutor() as executor: results = list(executor.map(func, args)) 十七、类型注解 # Python 3.10+ 推荐写法 from __future__ import annotations # Python 3.7-3.9 启用新语法 # 基础类型 x: int = 1 y: float = 3.14 s: str = "hello" b: bool = True n: None = None # 容器 lst: list[int] = [1, 2, 3] tpl: tuple[int, str, float] = (1, "a", 3.14) dct: dict[str, int] = {"a": 1} st: set[int] = {1, 2, 3} # 可选值 def func(x: int | None = None) -> str: # Python 3.10+ pass from typing import Optional def func(x: Optional[int] = None) -> str: # 旧写法 pass # Union（多类型） def func(x: int | str) -> None: pass # 可调用 from typing import Callable def apply(f: Callable[[int, int], int], a: int, b: int) -> int: return f(a, b) # 泛型 from typing import TypeVar, Generic T = TypeVar("T") def first(lst: list[T]) -> T: return lst[0] # 类型别名 Vector = list[float] Matrix = list[list[float]] # TypedDict from typing import TypedDict class UserDict(TypedDict): name: str age: int email: str # Protocol（结构化子类型） from typing import Protocol class Drawable(Protocol): def draw(self) -> None: ... # 静态检查工具 # mypy: pip install mypy && mypy my_module.py # pyright: pip install pyright 十八、常用标准库 os / sys / pathlib import os os.getcwd() # 当前目录 os.listdir(".") # 列出目录 os.makedirs("a/b/c", exist_ok=True) os.environ.get("HOME") # 环境变量 os.path.join("a", "b", "c") # 路径拼接 import sys sys.argv # 命令行参数 sys.path # 模块搜索路径 sys.exit(0) # 退出 sys.version # Python 版本 datetime from datetime import datetime, date, timedelta now = datetime.now() today = date.today() dt = datetime(2024, 1, 15, 10, 30, 0) # 格式化 dt.strftime("%Y-%m-%d %H:%M:%S") # datetime → str datetime.strptime("2024-01-15", "%Y-%m-%d") # str → datetime # 运算 tomorrow = today + timedelta(days=1) delta = datetime.now() - dt delta.days delta.total_seconds() collections from collections import ( defaultdict, # 带默认值的字典 Counter, # 计数器 OrderedDict, # 有序字典（Python 3.7+ 普通 dict 也有序） deque, # 双端队列 namedtuple, # 命名元组 ChainMap, # 多字典链 ) # defaultdict dd = defaultdict(list) dd["key"].append(1) # 无需检查 key 是否存在 # Counter c = Counter("abracadabra") c.most_common(3) # [('a', 5), ('b', 2), ('r', 2)] c["a"] # 5 # deque（O(1) 两端操作） dq = deque([1, 2, 3], maxlen=5) dq.appendleft(0) dq.popleft() dq.rotate(1) # 右旋 # namedtuple Point = namedtuple("Point", ["x", "y"]) p = Point(1, 2) p.x, p.y re（正则表达式） import re pattern = r"\d+" # r 前缀表示原始字符串 re.match(pattern, "123abc") # 从头匹配 re.search(pattern, "abc123") # 全文搜索，返回第一个 re.findall(pattern, "a1b2c3") # 返回所有匹配 ["1","2","3"] re.sub(pattern, "X", "a1b2") # 替换 → "aXbX" re.split(r"\s+", "a b c") # 分割 → ["a","b","c"] # 编译（多次使用时更高效） pat = re.compile(r"(?P<year>\d{4})-(?P<month>\d{2})") m = pat.search("date: 2024-01") m.group("year") # "2024" m.group("month") # "01" # 常用模式 # \d 数字 \w 字母数字下划线 \s 空白 # . 任意字符 ^ 开头 $ 结尾 # * 0+ + 1+ ? 0或1 {n,m} 次数 # (?:...) 非捕获组 (?=...) 前瞻 logging import logging # 基础配置 logging.basicConfig( level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", handlers=[ logging.StreamHandler(), logging.FileHandler("app.log"), ] ) logger = logging.getLogger(__name__) logger.debug("调试信息") logger.info("普通信息") logger.warning("警告") logger.error("错误") logger.critical("严重错误") logger.exception("带异常信息的错误") # 自动附加 traceback functools / itertools import functools functools.partial(pow, 2) # 偏函数：固定部分参数 functools.reduce(lambda a,b: a+b, lst) functools.lru_cache(maxsize=128) # 缓存装饰器 import itertools itertools.chain(*iterables) itertools.combinations([1,2,3], 2) # 组合 itertools.permutations([1,2,3], 2) # 排列 itertools.product("AB", repeat=2) # 笛卡尔积 itertools.cycle([1,2,3]) # 无限循环 itertools.islice(it, 10) # 切片迭代器 dataclasses / enum from enum import Enum, auto class Color(Enum): RED = 1 GREEN = 2 BLUE = auto() # 自动赋值 Color.RED Color.RED.value # 1 Color.RED.name # "RED" Color["RED"] # 按名称访问 list(Color) # 所有成员 typing / abc（见类型注解和抽象类章节） 十九、测试 pytest（推荐） pip install pytest pytest-cov pytest # 运行所有测试 pytest tests/test_foo.py # 运行指定文件 pytest -k "test_add" # 按名称过滤 pytest -v # 详细输出 pytest --cov=src --cov-report=html # 覆盖率报告 # tests/test_math.py import pytest from my_project.math import add, divide def test_add_positive(): assert add(1, 2) == 3 def test_add_negative(): assert add(-1, -1) == -2 def test_divide_by_zero(): with pytest.raises(ZeroDivisionError): divide(10, 0) @pytest.mark.parametrize("a,b,expected", [ (1, 2, 3), (0, 0, 0), (-1, 1, 0), ]) def test_add_parametrize(a, b, expected): assert add(a, b) == expected # conftest.py：共享 fixtures @pytest.fixture def user(): return {"name": "Alice", "age": 30} def test_user(user): assert user["name"] == "Alice" # Mock from unittest.mock import patch, MagicMock def test_with_mock(): with patch("my_module.requests.get") as mock_get: mock_get.return_value.json.return_value = {"key": "value"} result = my_function() mock_get.assert_called_once() 二十、常用第三方库速览 类别 库 说明 HTTP 客户端 ​requests 同步 HTTP HTTP 客户端 ​httpx 同步+异步 HTTP Web 框架 ​fastapi 现代异步 API 框架 Web 框架 ​flask 轻量 Web 框架 Web 框架 ​django 全栈 Web 框架 数据处理 ​pandas 表格数据分析 数值计算 ​numpy 数组/矩阵运算 数据库 ORM ​sqlalchemy 通用 ORM 数据库 ORM ​tortoise-orm 异步 ORM 数据验证 ​pydantic 数据模型/验证 环境变量 ​python-dotenv 加载 .env 文件 CLI 工具 ​typer 基于类型注解的 CLI CLI 工具 ​click 命令行接口框架 序列化 ​orjson 高性能 JSON 日期时间 ​arrow 友好的日期时间库 任务队列 ​celery 分布式任务队列 测试 Mock ​pytest-mock pytest Mock 插件 代码格式化 ​black 代码格式化 Linter ​ruff 极速 Linter+Formatter 类型检查 ​mypy 静态类型检查 附录：Python 与其他语言对比速查 概念 Python Java/C# JavaScript 空值 ​None ​null ​null/undefined 打印 ​print() ​System.out.println() ​console.log() 字符串插值 ​f"Hello {name}" ​$"Hello {name}"|​`Hello ${name}` 数组/列表 ​list ​ArrayList ​Array 字典/映射 ​dict ​HashMap ​Object/Map 接口 ​Protocol/ABC ​interface - 枚举 ​Enum ​enum - 异步 ​async/await ​async/await ​async/await 包管理 ​pip/uv ​Maven/Gradle ​npm/yarn 整除 ​// ​/(int) ​Math.floor(a/b) 幂运算 ​** ​Math.pow() ​** 逻辑运算符 ​and/or/not ​&&/||/! ​&&/||/! 本手册基于 Python 3.10+ 编写。建议配合官方文档 docs.python.org 深入学习。