Python 语言系统梳理

Python 是一种解释型、动态类型、面向对象的高级编程语言，由 Guido van Rossum 于 1991 年首次发布。其设计哲学强调代码可读性和简洁的语法。

当前主流版本为 Python 3.x（3.14 于 2025 年发布）。CPython 是官方参考实现，另有 PyPy（JIT）、Jython（JVM）、IronPython（.NET）等替代实现。

1. 概述

Python 语言的定义分为以下几个层面：

2. 行为图

2.1 用例图 — Python 使用场景

Python 核心用例图

2.2 活动图 — 源码到执行全流程

Python 并非纯粹的"解释型"语言——源码先被编译为字节码（bytecode），再由 Python 虚拟机（PVM）执行。

Python 源码 → 字节码 → 执行流程

Demo: 查看字节码

import dis

def add(a, b):
    return a + b

dis.dis(add)
# 输出：
#   1           0 RESUME                   0
#   2           2 LOAD_FAST                0 (a)
#               4 LOAD_FAST                1 (b)
#               6 BINARY_OP                0 (+)
#              10 RETURN_VALUE

2.3 活动图 — CPython 垃圾回收机制

CPython 使用引用计数（主策略）+ 分代循环检测（辅助策略）。引用计数能立即回收非循环垃圾，循环引用由 gc 模块分三代定期扫描。

CPython 内存回收流程

2.4 时序图 — import 模块加载流程

当执行 import foo 时，Python 按以下顺序查找并加载模块：sys.modules 缓存 → sys.meta_path finders → sys.path 路径搜索。

import foo 的完整时序

Demo: import 内部机制

import sys
import importlib

# 查看已加载模块
print("os" in sys.modules)  # False
import os
print("os" in sys.modules)  # True

# meta_path 上的 finders
for finder in sys.meta_path:
    print(type(finder).__name__)
# BuiltinImporter
# FrozenImporter
# PathFinder

# sys.path 搜索路径
for p in sys.path[:3]:
    print(p)
# (当前目录)
# /usr/lib/python312.zip
# /usr/lib/python3.12

2.5 时序图 — 函数调用全流程

从 Python 代码调用一个函数到 C 底层执行，涉及 Code Object、Frame Object、调用栈等多层抽象。

Python 函数调用完整链路

Demo: 函数对象内省

def greet(name):
    """Say hello to someone."""
    return f"Hello, {name}!"

# 函数是对象
print(type(greet))              # <class 'function'>

# 函数属性
print(greet.__name__)           # greet
print(greet.__doc__)            # Say hello to someone.
print(greet.__code__)           # <code object greet at ...>

# code 对象内省
co = greet.__code__
print(co.co_varnames)           # ('name',)
print(co.co_argcount)           # 1
print(co.co_consts)             # (None, 'Hello, ', '!')

2.6 状态机图 — Python 对象生命周期

Python 对象的生命周期由引用计数决定。对象从创建到销毁经历以下几个状态转移。

CPython 对象生命周期（引用计数视角）

Demo: 引用计数观察

import sys

a = []                     # refcount = 1
print(sys.getrefcount(a))  # 2 (参数传递临时+1)
b = a                      # refcount = 2
c = [a]                    # refcount = 3
del b                      # refcount = 2
del c                      # refcount = 1
del a                      # refcount = 0 → 对象被回收

2.7 状态机图 — GIL 与线程调度

CPython 默认使用 全局解释器锁（GIL），确保任意时刻只有一个线程执行 Python 字节码。I/O 操作时 GIL 被释放。3.13+ 支持 --disable-gil 自由线程模式。

GIL 线程调度状态机

3. 结构图

3.1 组件图 — CPython 核心架构

CPython 解释器由多个核心子系统构成，涵盖编译前端、运行时核心、内存管理、标准库等。

CPython 解释器核心组件架构

3.2 包图 — Python 标准库组织

Python 标准库（200+ 模块）按功能域组织。核心内置模块（sys, os, io 等）用 C 编写以保证性能。

Python 标准库功能域组织

3.3 类图 — Python 类型系统层次

Python 中一切皆对象，类型本身也是对象（type 的实例）。类型层次的核心是 object（所有类的基类）和 type（所有元类的基类）。

Python 类型系统层次结构

Demo: 类型关系验证

# 一切皆对象
print(isinstance(42, object))         # True
print(isinstance("hello", object))    # True
print(isinstance(int, object))        # True (类型也是对象)

# type 是自身的实例
print(type(type))                     # <class 'type'>
print(isinstance(type, type))         # True
print(isinstance(object, type))       # True

# object 没有基类
print(object.__bases__)               # ()

# 多继承 MRO
class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
print(D.__mro__)
# (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)

3.4 类图 — Python 对象模型核心

Python 对象模型的三个核心概念：对象（Object）、类型（Type）、引用（Reference）。对象的底层结构由 PyObject 和 PyVarObject C 结构体实现。

CPython 对象模型核心结构

3.5 部署图 — Python 运行时架构

Python 运行时层次：

1. 进程 — 全局资源（内存、文件句柄、信号等）
2. Python 全局运行时 — 管理多个解释器实例
3. Python 解释器 — 独立的执行环境（各自拥有 sys.modules、GIL 等）
4. 线程 — 执行 Python 字节码的线程，拥有独立的线程状态和调用栈

Python 运行时层级部署架构

4. 使用手册

4.1 安装

4.2 基础语法速览

# === 变量与基本类型 ===
x = 42                  # int（无限精度）
pi = 3.14               # float
name = "Python"         # str（Unicode）
flag = True             # bool（int 子类）
nothing = None          # NoneType 单例

# === 序列 ===
items = [1, 2, 3]              # list（可变）
point = (10, 20)               # tuple（不可变）
data = b"hello"                # bytes（不可变）
mutable_data = bytearray(b"hi")# bytearray（可变）

# === 集合与映射 ===
unique = {1, 2, 3}             # set（可变，元素唯一）
frozen = frozenset([1, 2, 3])  # frozenset（不可变）
d = {"key": "value", "a": 1}   # dict（保序，Python 3.7+）

# === 控制流（缩进定义代码块！）===
if x > 0:
    print("positive")
elif x < 0:
    print("negative")
else:
    print("zero")

for item in items:      # 遍历序列
    print(item)

i = 0
while i < 5:            # while 循环
    print(i)
    i += 1

# 模式匹配（Python 3.10+）
match point:
    case (0, 0):
        print("origin")
    case (x, 0):
        print(f"x-axis at {x}")
    case (0, y):
        print(f"y-axis at {y}")
    case (x, y):
        print(f"point at {x},{y}")
    case _:
        print("not a point")

4.3 模块与包

# === 导入模块 ===
import math
print(math.sqrt(16))           # 4.0

from math import sin, cos
from collections import defaultdict, Counter

# 相对导入（包内使用）
# from . import sibling_module
# from ..parent_pkg import module

# === __name__ 检测 ===
if __name__ == "__main__":
    print("作为脚本直接运行")
else:
    print("作为模块被导入")

__init__.py 的三重职责

目录下放置 __init__.py，该目录才被 import 系统识别为常规包（regular package）。它同时承担三个职责：

以本项目的 engine/movement/ 为例：符号实际定义在 engine.py 与 trend.py，但通过 __init__.py 聚合后，调用方可以直接从包顶层导入：

# movement/__init__.py —— 包门面
"""趋势识别引擎模块。"""
from .engine import (
    MovementParams, MovementSegment, MovementStream,
    ReversalParams, scan_key_ks, scan_movements, segments_to_signals,
)
from .trend import TrendGate, TrendParams
# 未定义 __all__，故 import * 会导出上述所有名字

# —— 调用方 ——
from engine.movement import MovementStream, TrendGate   # 无需关心内部拆分
# 等价于（但更耦合）：
# from engine.movement.engine import MovementStream
# from engine.movement.trend  import TrendGate

与 Java 的对比：为什么 Java 没有 __init__.py

Java 的包机制和 Python 的模块机制是两套不同设计，因此 Java 没有对应物。差异如下：

Java 中最接近的类比：

• package-info.java：给整个包挂 Javadoc / 包级注解，但不做初始化、不做导出。
• module-info.java（JDK 9+，JPMS）：模块级（比包更粗）的 exports / requires 声明，才是 Java 里最像“包级门面”的机制。

4.4 面向对象

# === 类定义 ===
class Animal:
    kingdom = "Animalia"  # 类变量

    def __init__(self, name, species):
        self.name = name      # 实例变量
        self._species = species  # 约定私有（单下划线）

    def speak(self):
        return "..."

    @staticmethod
    def info():
        return "All animals"

    @classmethod
    def create_dog(cls, name):
        return cls(name, "dog")

# === 继承 ===
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, "dog")
        self.breed = breed

    def speak(self):
        return f"{self.name} says woof!"

# === 属性装饰器 ===
class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("radius must be >= 0")
        self._radius = value

    @property
    def area(self):
        return 3.14159 * self._radius ** 2

# === 数据类 (Python 3.7+) ===
from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float
    label: str = ""

p = Point(1.5, 2.5)
print(p)  # Point(x=1.5, y=2.5, label='')

4.5 异常处理

# === try/except/finally/else ===
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
except (TypeError, ValueError):
    print("Type or value error")
else:
    print("No error occurred")  # 仅在无异常时执行
finally:
    print("Always runs")        # 始终执行（清理资源）

# === with 上下文管理器（自动清理）===
with open("file.txt", "r") as f:
    content = f.read()
# f.close() 自动调用，即使有异常

# === 自定义异常 ===
class ValidationError(Exception):
    def __init__(self, message, field):
        super().__init__(message)
        self.field = field

raise ValidationError("invalid", field="email")

4.6 异步编程

import asyncio

# === 协程函数 ===
async def fetch_data(url: str) -> str:
    print(f"Fetching {url}...")
    await asyncio.sleep(1)          # 模拟 I/O
    return f"Data from {url}"

# === 并发执行 ===
async def main():
    tasks = [
        fetch_data("api/users"),
        fetch_data("api/products"),
        fetch_data("api/orders"),
    ]
    results = await asyncio.gather(*tasks)
    for r in results:
        print(r)

# asyncio.run(main())  # 运行入口

# === 异步生成器 ===
async def async_range(n):
    for i in range(n):
        await asyncio.sleep(0.1)
        yield i

# === 异步上下文管理器 ===
class AsyncLock:
    async def __aenter__(self):
        print("acquiring lock...")
        return self
    async def __aexit__(self, *args):
        print("releasing lock...")

4.7 pip 与虚拟环境

# === 创建虚拟环境 ===
python -m venv myenv

# 激活（Unix/macOS）
source myenv/bin/activate

# 激活（Windows）
# myenv\Scripts\activate

# === 安装包 ===
pip install requests
pip install pytest==8.0.0
pip install -r requirements.txt

# === 常用命令 ===
pip list                    # 列出已安装包
pip show requests           # 查看包详情
pip freeze > requirements.txt  # 导出依赖
pip uninstall requests      # 卸载

# 退出虚拟环境
deactivate

4.8 常用标准库速查

5. 后端技术栈

以下梳理当前（2025-2026）Python 后端开发的主流技术栈，涵盖 Web 框架、数据库、消息队列、部署运维等全链路。

5.1 分层架构总览

Python 后端技术栈按关注点可划分为以下层次：

┌─────────────────────────────────────────────────┐
│              API Layer (HTTP / GraphQL / gRPC)   │
│         FastAPI · Django · Flask · Litestar      │
├─────────────────────────────────────────────────┤
│            Service / Business Logic Layer        │
│            Use Cases · Domain Services           │
├─────────────────────────────────────────────────┤
│            Data Access Layer                     │
│         SQLAlchemy · Django ORM · Tortoise ORM   │
├─────────────────────────────────────────────────┤
│            Data / Infra Layer                    │
│   PostgreSQL · Redis · Kafka · S3 · Elasticsearch│
├─────────────────────────────────────────────────┤
│            Background / Async Layer              │
│      Celery · Dramatiq · asyncio · Taskiq       │
├─────────────────────────────────────────────────┤
│            Observability Layer                   │
│    structlog · Prometheus · Sentry · Jaeger      │
└─────────────────────────────────────────────────┘

5.2 Web 框架

FastAPI 核心生态

Django 核心生态

5.3 API 协议与规范

RESTful + OpenAPI 是最主流的接口风格。FastAPI 自动生成 OpenAPI 3.1 JSON Schema，配合 /docs 实现交互式 API 浏览。

GraphQL 生态以 Strawberry（code-first，Pydantic 兼容）和 Ariadne（schema-first）为主流。

gRPC（grpcio + protobuf）适合微服务间高性能 RPC 通信。

WebSocket 推荐 FastAPI 原生支持或 Django Channels，轻量场景用 websockets 库。

5.4 ORM 与数据库

数据库选型

缓存层

5.5 数据验证与序列化

Pydantic v2 是 Python 数据验证的事实标准，底层用 Rust（pydantic-core）重写，速度比 v1 快 5-50 倍。支持类型注解驱动、JSON Schema 自动生成、ORM 集成（from_attributes = True）、自定义验证（@field_validator）。配合 pydantic-settings 从环境变量/.env 加载配置。

5.6 任务队列与消息队列

消息队列选型

5.7 认证与授权

JWT 方案（最流行的无状态认证）

OAuth2 / OpenID Connect

权限管理

5.8 可观测性

5.9 测试

5.10 DevOps 与部署

容器化

Docker 是 Python 应用部署的标准方式。推荐 python:3.12-slim 基础镜像，多阶段构建减少体积，uv 加速安装。

Web 服务器

CI/CD

典型 CI 流程：lint (ruff) → type check (mypy) → test (pytest) → build image → deploy。

5.11 开发工具链

包/环境管理

类型检查与代码质量

5.12 典型组合方案