今年夏天，我用了一个不太常规的方式搭建了这个博客——通过 Codex（GPT-5）全程对话协作，从初始化到配置、UI 打磨、再到 Git 版本管理，每一步都是人与 AI 共同完成的。

1. 学习路线总览

入门基础          →  进阶提升          →  专业方向
┌─────────┐       ┌─────────┐         ┌──────────┐
│ 语法基础 │       │ 面向对象 │         │ Web 开发  │
│ 数据类型 │       │ 装饰器   │         │ 数据分析  │
│ 流程控制 │  ──→  │ 生成器   │   ──→   │ 自动化运维│
│ 函数     │       │ 并发编程 │         │ 机器学习  │
│ 文件IO   │       │ 标准库   │         │ 爬虫     │
└─────────┘       └─────────┘         └──────────┘

1.1 分阶段路线

2. 核心知识图谱

2.1 必须扎实掌握

语言核心：
├── 数据类型（list / dict / set / tuple / str）
├── 控制流（if / for / while / break / continue）
├── 函数（参数 / 返回值 / 作用域 / 闭包）
├── 面向对象（类 / 继承 / 多态 / 魔术方法）
├── 异常处理（try/except/finally / 自定义异常）
├── 文件操作（读写 / 上下文管理器）
├── 模块与包（import / __init__.py / 相对导入）
└── 迭代协议（迭代器 / 生成器 / yield）

2.2 进阶必备

高级特性：
├── 装饰器（函数装饰器 / 类装饰器 / 带参数）
├── 上下文管理器（__enter__ / __exit__ / contextlib）
├── 描述符（__get__ / __set__ / __delete__）
├── 元类（type / __init_subclass__ / metaclass）
├── 反射（getattr / hasattr / __getattr__）
├── 类型提示（typing / Generic / Protocol）
└── 数据类（dataclass / pydantic）

2.3 并发编程

并发模型：
├── 多线程（threading / GIL / 线程池）
├── 多进程（multiprocessing / 进程池 / 进程通信）
├── 异步 IO（asyncio / await / Task / 事件循环）
└── 并发工具（concurrent.futures / queue / Lock）

3. 专业方向选择

3.1 Web 后端开发

技术栈：
├── 框架：FastAPI（推荐）/ Django / Flask
├── 数据库：PostgreSQL / MySQL + SQLAlchemy
├── 缓存：Redis
├   消息队列：Celery + RabbitMQ
├── 部署：Docker + Gunicorn + Nginx
└── 监控：Prometheus + Grafana

进阶路线：
1. 掌握一个框架（FastAPI）
2. 学习数据库设计与 ORM
3. 理解 RESTful / GraphQL API 设计
4. 学习认证授权（JWT / OAuth2）
5. 实践微服务架构

3.2 数据分析与科学计算

技术栈：
├── 核心：NumPy / Pandas
├── 可视化：Matplotlib / Seaborn / Plotly
├── 机器学习：Scikit-learn
├   深度学习：PyTorch / TensorFlow
├── 数据处理：Jupyter Notebook
└── 大数据：PySpark / Dask

进阶路线：
1. 熟练 Pandas 数据操作
2. 掌握统计基础与数据可视化
3. 学习 Scikit-learn 经典算法
4. 深入 PyTorch 深度学习
5. 实践端到端数据项目

3.3 自动化与运维

技术栈：
├── 脚本：Python 标准库 / Click / Typer
├── 自动化：Selenium / Playwright
├   运维：Ansible / Fabric
├── 定时任务：APScheduler / Celery Beat
├── 监控：psutil / logging
└── 配置管理：pydantic-settings

3.4 爬虫与数据采集

技术栈：
├── 请求：requests / httpx / aiohttp
├── 解析：BeautifulSoup / lxml / parsel
├── 框架：Scrapy
├   动态页面：Playwright / Selenium
├── 反爬：代理池 / 验证码识别 / 指纹伪装
└── 存储：SQLite / MongoDB / Elasticsearch

4. 推荐书籍

4.1 入门到进阶

4.2 专业方向

5. 在线文档与资源

5.1 官方文档

Python 官方文档      https://docs.python.org/zh-cn/3/
PEP 索引            https://peps.python.org/
FastAPI 文档         https://fastapi.tiangolo.com/zh/
Django 文档          https://docs.djangoproject.com/zh-hans/
Flask 文档           https://dormousehole.readthedocs.io/
Pandas 文档          https://pandas.pydata.org/docs/

5.2 学习平台

Real Python          https://realpython.com/      （高质量教程）
PyCoder's Weekly     https://pycoders.com/         （每周周刊）
Python Weekly        https://www.pythonweekly.com/ （新闻聚合）
Stack Overflow       https://stackoverflow.com/    （问答社区）

5.3 中文资源

廖雪峰 Python 教程   https://liaoxuefeng.com/books/python/
菜鸟教程             https://www.runoob.com/python3/
掘金 / SegmentFault  技术社区

6. 优质开源项目学习

6.1 阅读源码提升

6.2 参与开源

# 1. 从 Good First Issue 开始
#    GitHub 搜索 label:"good first issue" language:Python

# 2. 阅读贡献指南（CONTRIBUTING.md）

# 3. 从文档改进、Bug 修复开始

# 4. 逐步参与功能开发

7. 编码能力提升方法

7.1 刷题练习

LeetCode        https://leetcode.cn/        （算法面试）
HackerRank      https://www.hackerrank.com/  （Python 专项）
Codewars        https://www.codewars.com/    （游戏化练习）
Exercism        https://exercism.org/        （代码评审）

建议：
- 每日 1-2 题，坚持 3 个月
- 先独立思考，再看题解
- 注重时间/空间复杂度分析

7.2 项目实战

进阶项目建议（由易到难）：

1. 命令行待办工具（argparse + JSON 存储）
2. 个人博客系统（FastAPI + SQLite）
3. 股票数据分析仪表盘（Pandas + Plotly）
4. 分布式爬虫系统（Scrapy + Redis）
5. 即时聊天应用（WebSocket + asyncio）
6. 微服务电商后台（FastAPI + Docker + PostgreSQL）

7.3 代码审查

# 审查自己代码的检查清单：

# □ 命名是否清晰（变量、函数、类）
# □ 函数是否单一职责（不超过 30 行）
# □ 是否有类型提示
# □ 异常是否被正确处理
# □ 是否有重复代码（DRY 原则）
# □ 是否有单元测试
# □ 是否通过 ruff / mypy 检查
# □ 复杂逻辑是否有注释说明

8. Python 版本与生态趋势

3.1 近年重要特性

3.2 值得关注的新工具

uv        → 超快包管理（替代 pip/pip-tools）
ruff      → 超快 linter + formatter（替代 flake8/black/isort）
mypy      → 静态类型检查
pydantic  → 数据校验（v2 基于 Rust，性能大幅提升）

9. 持续学习建议

9.1 制定计划

每周学习节奏建议：

周一~周五：每天 1 小时
├── 30 分钟：学习新知识 / 阅读文档
└── 30 分钟：动手编码练习

周末：2-3 小时
├── 完整项目实战
└── 总结复盘 + 写技术笔记

9.2 知识管理

建立个人知识库：

1. 用 Markdown 记录学习笔记
2. GitHub 维护代码示例仓库
3. 写技术博客（输出倒逼输入）
4. 定期回顾与重构旧代码
5. 关注 PEP 提案，了解语言演进

9.3 社区参与

- 加入 Python 中文社区 / 本地 PyCon
- 参与开源项目贡献
- 在 Stack Overflow 回答问题
- 技术分享（公司内部 / 线上直播）

10. 小结

学习没有捷径，但方向比速度更重要。 扎实基础 → 选择方向 → 深度实战 → 持续输出，这是最可靠的成长路径。

]]> https://example.com/posts/language/python-54-python%E9%A1%B9%E7%9B%AE%E6%9C%80%E4%BD%B3%E5%AE%9E%E8%B7%B5/ Sat, 27 Dec 2025 00:00:00 +0000 ixiaoqiang0011@gmail.com (Qzai) https://example.com/posts/language/python-54-python%E9%A1%B9%E7%9B%AE%E6%9C%80%E4%BD%B3%E5%AE%9E%E8%B7%B5/ 学习目标：掌握 Python 项目的工程化最佳实践，涵盖目录结构、配置管理、依赖锁定、部署上线与 CI/CD。

---

1. 项目目录结构

1.1 标准结构

my_project/
├── pyproject.toml        # 项目元数据与依赖（现代标准）
├── requirements.txt      # 依赖锁定（兼容传统工具）
├── README.md             # 项目说明
├── .gitignore            # Git 忽略规则
├── .env.example          # 环境变量示例
├── Makefile              # 常用命令快捷方式
├── src/                  # 源码目录
│   └── my_package/
│       ├── __init__.py
│       ├── core/         # 核心逻辑
│       ├── models/       # 数据模型
│       ├── services/     # 业务服务
│       └── utils/        # 工具函数
├── tests/                # 测试目录
│   ├── conftest.py       # pytest 固件
│   ├── unit/             # 单元测试
│   └── integration/      # 集成测试
├── docs/                 # 文档
└── scripts/              # 脚本工具

1.2 使用 src 布局的好处

# src 布局强制安装后才可导入，避免测试误用本地路径

# 传统布局（不推荐）
my_package/
    __init__.py
tests/
    test_xxx.py   # 可能直接 import my_package（未安装状态）

# src 布局（推荐）
src/
    my_package/
        __init__.py
tests/
    test_xxx.py   # 必须先 pip install -e . 才能导入

---

2. 项目配置

2.1 pyproject.toml（推荐）

# pyproject.toml
[build-system]
requires = ["setuptools>=68.0", "wheel"]
build-backend = "setuptools.backends._legacy:_Backend"

[project]
name = "my-package"
version = "1.0.0"
description = "我的 Python 项目"
requires-python = ">=3.10"
dependencies = [
    "requests>=2.31",
    "pydantic>=2.0",
]

[project.optional-dependencies]
dev = [
    "pytest>=7.0",
    "pytest-cov>=4.0",
    "ruff>=0.1",
    "mypy>=1.5",
]

[project.scripts]
my-tool = "my_package.cli:main"

# ruff 配置
[tool.ruff]
line-length = 100
target-version = "py310"

[tool.ruff.lint]
select = ["E", "F", "I", "N", "W"]

# pytest 配置
[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "-v --cov=my_package --cov-report=term-missing"

2.2 环境变量管理

# config.py
from pydantic_settings import BaseSettings
from functools import lru_cache


class Settings(BaseSettings):
    """应用配置（从环境变量读取）"""
    app_name: str = "My App"
    debug: bool = False
    database_url: str = "sqlite:///./app.db"
    secret_key: str = "change-me"
    api_timeout: int = 30

    class Config:
        env_file = ".env"
        env_file_encoding = "utf-8"


@lru_cache
def get_settings() -> Settings:
    """单例配置（缓存）"""
    return Settings()


# 使用
settings = get_settings()
print(settings.database_url)

# .env
DEBUG=true
DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
SECRET_KEY=your-production-secret

---

3. 依赖管理

3.1 使用 pip-tools 锁定依赖

# 安装
pip install pip-tools

# 编写 requirements.in（顶层依赖）
# requirements.in
fastapi
uvicorn[standard]
sqlalchemy

# 编译生成锁定的 requirements.txt
pip-compile requirements.in -o requirements.txt

# 安装精确版本
pip-sync requirements.txt

3.2 使用 uv（高性能替代）

# 安装 uv（Rust 编写，极快）
curl -LsSf https://astral.sh/uv/install.sh | sh

# 创建项目
uv init my_project
cd my_project

# 添加依赖
uv add fastapi uvicorn sqlalchemy
uv add --dev pytest ruff mypy

# 同步环境
uv sync

# 运行
uv run pytest

---

4. 日志与配置

4.1 结构化日志

# logging_config.py
import logging
import sys
from pathlib import Path


def setup_logging(log_file: str = "app.log", level: str = "INFO"):
    """配置日志"""
    log_format = "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s"
    date_format = "%Y-%m-%d %H:%M:%S"

    # 控制台 + 文件双输出
    logging.basicConfig(
        level=level,
        format=log_format,
        datefmt=date_format,
        handlers=[
            logging.StreamHandler(sys.stdout),
            logging.FileHandler(log_file, encoding='utf-8'),
        ],
    )

    # 降低第三方库日志级别
    logging.getLogger("urllib3").setLevel(logging.WARNING)


# 使用
logger = logging.getLogger(__name__)
setup_logging()
logger.info("服务启动")
logger.error("数据库连接失败", exc_info=True)

4.2 使用 loguru（更简洁）

from loguru import logger

# 自动带颜色、时间、文件位置
logger.info("用户登录: user_id={}", 123)

# 输出到文件并自动轮转
logger.add("app.log", rotation="10 MB", retention="7 days", encoding="utf-8")

# JSON 格式（便于日志收集）
logger.add("app.json", serialize=True)

try:
    1 / 0
except Exception:
    logger.exception("计算失败")

---

5. 错误处理架构

# errors.py
from enum import Enum
from dataclasses import dataclass


class ErrorCode(Enum):
    SUCCESS = 0
    PARAM_ERROR = 1001
    NOT_FOUND = 1002
    UNAUTHORIZED = 1003
    SERVER_ERROR = 5000


@dataclass
class AppError(Exception):
    """应用统一异常"""
    code: ErrorCode
    message: str

    def __post_init__(self):
        super().__init__(self.message)


# 业务中使用
def get_user(user_id: int, db):
    user = db.query(User).get(user_id)
    if not user:
        raise AppError(ErrorCode.NOT_FOUND, f"用户 {user_id} 不存在")
    return user


# 统一捕获
def handle_errors(func):
    """错误处理装饰器"""
    from functools import wraps
    @wraps(func)
    def wrapper(*args, **kwargs):
        try:
            result = func(*args, **kwargs)
            return {"code": 0, "message": "success", "data": result}
        except AppError as e:
            return {"code": e.code.value, "message": e.message, "data": None}
        except Exception as e:
            logger.exception("未预期错误")
            return {"code": 5000, "message": "服务器错误", "data": None}
    return wrapper

---

6. 部署上线

6.1 Docker 容器化

# Dockerfile
FROM python:3.12-slim

WORKDIR /app

# 安装依赖（利用缓存层）
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 拷贝源码
COPY src/ ./src/
COPY pyproject.toml .

# 安装项目
RUN pip install -e .

EXPOSE 8000

CMD ["uvicorn", "my_package.main:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml
version: "3.8"

services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
    depends_on:
      - db

  db:
    image: postgres:16
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: mydb
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine

volumes:
  pgdata:

# 构建并启动
docker-compose up -d --build

6.2 Gunicorn + Uvicorn 生产部署

# 安装
pip install gunicorn uvicorn[standard]

# 多 worker 部署
gunicorn my_package.main:app \
    -w 4 \
    -k uvicorn.workers.UvicornWorker \
    --bind 0.0.0.0:8000 \
    --timeout 120 \
    --access-logfile - \
    --error-logfile -

---

7. CI/CD 自动化

7.1 GitHub Actions

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.10", "3.11", "3.12"]

    steps:
      - uses: actions/checkout@v4

      - name: 安装 Python
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}

      - name: 安装依赖
        run: |
          pip install -e ".[dev]"

      - name: 代码检查
        run: |
          ruff check src/ tests/
          mypy src/

      - name: 运行测试
        run: pytest --cov

      - name: 上传覆盖率
        uses: codecov/codecov-action@v4

7.2 Makefile 快捷命令

# Makefile
.PHONY: install test lint format type-check clean

install:
	pip install -e ".[dev]"

test:
	pytest -v --cov

lint:
	ruff check src/ tests/

format:
	ruff format src/ tests/
	ruff check --fix src/ tests/

type-check:
	mypy src/

clean:
	find . -type d -name __pycache__ -exec rm -rf {} +
	find . -type d -name .pytest_cache -exec rm -rf {} +
	rm -rf .coverage htmlcov dist build *.egg-info

make install   # 安装
make test      # 测试
make lint      # 检查
make format    # 格式化

---

8. 性能优化要点

# 1. 使用 __slots__ 减少内存
class Point:
    __slots__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

# 2. 使用生成器处理大数据
def read_large_file(path):
    with open(path) as f:
        for line in f:
            yield line.strip()

# 3. 字符串拼接用 join
parts = ['a', 'b', 'c']
result = ''.join(parts)  # 比 += 快

# 4. 使用局部变量加速循环
def process(data):
    append = result.append  # 局部引用
    for item in data:
        append(item * 2)

# 5. 缓存计算结果
from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

---

9. 小结

维度	推荐方案
项目结构	src 布局 + pyproject.toml
依赖管理	uv / pip-tools 锁定版本
配置管理	pydantic-settings + .env
日志	loguru 或标准 logging
代码质量	ruff + mypy + pytest
容器化	Docker + docker-compose
生产部署	Gunicorn + Uvicorn
CI/CD	GitHub Actions

---

10. 练习题

1. 将之前的 API 项目改造为 src 布局，使用 pyproject.toml 管理依赖。
2. 为项目编写 Dockerfile 和 docker-compose.yml，实现一键部署。
3. 配置 GitHub Actions，实现推送代码自动运行 lint 和测试。
4. 使用 Makefile 整合 install、test、lint、format 命令。

---

下节预告：我们将梳理 Python 学习路线与推荐资源，为持续进阶指明方向。

]]>