Python进阶课程：从「能写代码」到「写出工程级代码」

在上一篇《Python入门课程》里，我们一起写出了第一个程序、掌握了变量、判断、循环和一个小计算器。如果你已经能独立写出几十行能跑的代码，那么恭喜你——你正站在新手和熟手之间的那道坎前。

这道坎，就是从「能跑」到「能维护」。 入门阶段我们关心"怎么让程序跑起来"，进阶阶段我们要关心：代码怎么组织才不乱、出错了怎么优雅处理、数据怎么读写、别人（包括三个月后的自己）怎么读懂、以及——怎么把 Python 接上 AI 能力做出真正有用的东西。这篇就带你把这几关一次打通。

一、函数进阶：把重复的代码"收"起来

入门时我们顺着写代码，进阶第一步就是学会用函数把逻辑封装、复用。函数不只是 def 那么简单，下面这几个用法是日常工程里最高频的。

1. 默认参数与关键字参数，让函数更灵活：

def greet(name, greeting="你好"):

    return f"{greeting}，{name}！"

print(greet("小明"))                 # 你好，小明！

print(greet("小红", greeting="欢迎"))  # 欢迎，小红！

2. 不定参数：*args（收成元组）与 **kwargs（收成字典）：

def total(*args):           # args 是一个元组

    return sum(args)

print(total(1, 2, 3, 4))    # 10

def profile(**kwargs):      # kwargs 是一个字典

    for k, v in kwargs.items():

        print(k, "=", v)

profile(name="小明", age=18, city="杭州")

3. 返回多个值（其实是返回一个元组）：

def divmod_(a, b):

    return a // b, a % b    # 商和余数一起返回

q, r = divmod_(17, 5)

print(q, r)                 # 3 2

经验之谈：一个函数最好只做一件事，函数名要能说清它做了什么。当一个函数超过 30 行，或者你给它起名时想用"and"，就该考虑拆分了。

二、用面向对象组织代码：类与对象

当数据和操作数据的函数总是成对出现时，就该用类（class）把它们打包在一起。这是从"脚本思维"走向"工程思维"的关键一跃。

用一个银行账户的例子理解类的四个核心概念：

class BankAccount:

    def __init__(self, owner, balance=0):  # 构造方法，创建对象时自动调用

        self.owner = owner                 # self 代表"这个对象自己"

        self.balance = balance

    def deposit(self, amount):             # 方法 = 属于对象的函数

        self.balance += amount

        return self.balance

    def withdraw(self, amount):

        if amount > self.balance:

            raise ValueError("余额不足")     # 出错就抛异常（下一节细讲）

        self.balance -= amount

        return self.balance

acc = BankAccount("小明", 100)   # 创建一个对象（实例）

acc.deposit(50)

print(acc.balance)               # 150

print(acc.owner)                 # 小明

四个要点对照理解：

概念	作用	例子
class	定义一类事物的"模板"	BankAccount
__init__	创建对象时的初始化	设置 owner、balance
self	指向"对象自己"，访问自己的数据	self.balance
方法	对象能做的动作	deposit / withdraw

继承让你在已有类基础上扩展，不必从零重写：

class VIPAccount(BankAccount):       # 继承 BankAccount

    def withdraw(self, amount):      # 重写：VIP 允许透支 500

        if amount > self.balance + 500:

            raise ValueError("超出透支额度")

        self.balance -= amount

        return self.balance

三、异常处理：让程序不再"一崩到底"

入门时程序一报错就整个停掉、红字一大片。进阶工程师的代码会预判错误、优雅处理，而不是听天由命。核心就是 try / except 四件套：

try:

    age = int(input("请输入年龄："))   # 可能出错的代码

    print(100 / age)

except ValueError:

    print("请输入数字，不要输入文字")    # 处理"转换失败"

except ZeroDivisionError:

    print("年龄不能为 0")              # 处理"除以零"

else:

    print("输入正常")                  # 没出错才执行

finally:

    print("无论如何都会执行（常用于关闭文件、释放资源）")

几个常见异常类型，遇到了能立刻反应过来是什么问题：

异常类型	什么时候出现
ValueError	类型对但值不对，如 int("abc")
TypeError	类型不对，如 "1" + 1
KeyError	字典里没有这个键
IndexError	列表索引越界
FileNotFoundError	要打开的文件不存在
ZeroDivisionError	除数为 0

重要原则：不要写空的 except: 把所有错误一律吞掉——那会让 bug 藏得更深。要么精确捕获你预期的异常，要么 raise 让它往上抛。

四、文件与数据：JSON 与 CSV 实战

真实程序几乎都要和数据打交道。先掌握最基础的文件读写（务必用 with，它会自动帮你关闭文件）：

# 写文件

with open("note.txt", "w", encoding="utf-8") as f:

    f.write("第一行\n第二行")

# 读文件

with open("note.txt", "r", encoding="utf-8") as f:

    content = f.read()

print(content)

JSON 是配置和接口数据最常见的格式，Python 用内置 json 模块处理，字典和 JSON 几乎一一对应：

import json

data = {"name": "小明", "skills": ["Python", "AI"], "age": 18}

# 字典 -> JSON 文件

with open("user.json", "w", encoding="utf-8") as f:

    json.dump(data, f, ensure_ascii=False, indent=2)

# JSON 文件 -> 字典

with open("user.json", "r", encoding="utf-8") as f:

    loaded = json.load(f)

print(loaded["skills"])    # [Python, AI]

CSV（表格数据，Excel 能直接打开）用内置 csv 模块：

import csv

rows = [["姓名", "成绩"], ["小明", 90], ["小红", 95]]

with open("scores.csv", "w", newline="", encoding="utf-8-sig") as f:

    writer = csv.writer(f)

    writer.writerows(rows)

with open("scores.csv", "r", encoding="utf-8-sig") as f:

    for row in csv.reader(f):

        print(row)

小贴士：中文写 CSV 用 utf-8-sig 编码，可以避免用 Excel 打开时中文乱码。

五、虚拟环境与第三方库：告别"在我电脑上能跑"

Python 最强大的地方是有几十万个第三方库。但不同项目依赖不同版本，全装在一起迟早冲突。专业做法是给每个项目建一个独立的虚拟环境（venv）。

在项目文件夹里执行（命令行/终端）：

# 1. 创建虚拟环境（生成一个 .venv 文件夹）

python -m venv .venv

# 2. 激活它

# Windows:

.venv\Scripts\activate

# macOS / Linux:

source .venv/bin/activate

# 3. 安装第三方库

pip install requests openai

# 4. 导出依赖清单（方便别人一键还原）

pip freeze > requirements.txt

# 别人拿到项目后，一行还原所有依赖：

pip install -r requirements.txt

记住这个工作流，你的项目从此可以在任何人的电脑、任何服务器上一致地运行——这正是"工程级"和"能跑就行"的分水岭。

六、三个进阶语法糖：推导式、生成器、装饰器

这三样是 Python 让人"真香"的特性，也是面试和代码 review 里高频出现的。

1. 列表 / 字典推导式——一行代码搞定循环+筛选：

nums = [1, 2, 3, 4, 5, 6]

squares = [n * n for n in nums]              # [1, 4, 9, 16, 25, 36]

evens   = [n for n in nums if n % 2 == 0]    # [2, 4, 6]

mapping = {n: n * n for n in nums}           # {1:1, 2:4, ...}

2. 生成器（yield）——处理大数据时不把所有结果一次性塞进内存：

def read_big_file(path):

    with open(path, encoding="utf-8") as f:

        for line in f:

            yield line.strip()      # 用一行、给一行，省内存

for line in read_big_file("huge.log"):

    process(line)

3. 装饰器（@）——在不改原函数的情况下，给它加功能（计时、重试、日志、权限校验）：

import time

def timer(func):

    def wrapper(*args, **kwargs):

        start = time.time()

        result = func(*args, **kwargs)

        print(f"{func.__name__} 耗时 {time.time() - start:.2f}s")

        return result

    return wrapper

@timer                  # 等价于 slow = timer(slow)

def slow():

    time.sleep(1)

slow()                  # slow 耗时 1.00s

七、模块化与项目结构：从单文件到工程

当代码越写越长，就该拆成多个文件（模块），再用 import 组合起来。一个清晰的小项目结构通常长这样：

my_project/

|-- .venv/                # 虚拟环境（不上传 git）

|-- requirements.txt      # 依赖清单

|-- config.py             # 配置（API Key、base_url 等）

|-- utils.py              # 工具函数

|-- services/

|   `-- ai_client.py      # 封装 AI 调用

`-- main.py               # 程序入口

模块之间这样互相引用：

# utils.py

def clean(text):

    return text.strip()

# main.py

from utils import clean

from services.ai_client import AIClient

if __name__ == "__main__":   # 只有直接运行本文件才执行

    print(clean("  hello  "))

if __name__ == "__main__": 是 Python 的惯用法：它保证这段代码只在"直接运行该文件"时执行，被 import 时不会执行——这样模块既能被复用，也能单独测试。

八、实战：用 Python 调用大模型 API，做一个智能小工具

学到这里，你已经具备了写真实应用的全部基础。我们把它们串起来，做一个"智能命令行助手"——你问一句，大模型答一句。这也是当下最值钱的 Python 技能之一：把 AI 能力接进你自己的程序。

现在主流大模型几乎都兼容OpenAI 协议，所以用官方 openai 库就能调用。但真正动手时，新手往往卡在第一步：Claude、GPT、Gemini、DeepSeek、Qwen 各有各的账号、计费和接口，注册、充值、科学上网一套折腾下来，劝退了一大半人。

我自己日常用的解决办法是统一接入层 DreamRouter（API.dreamrouter.top）：一个 API Key、一个 base_url，就能调用全网主流模型，完全兼容 OpenAI 协议，国内直连不用梯子。对正在学 Python、想练手 AI 的人特别友好——你只需要专注写代码，不用在平台账号上耗时间。

先装库、配好密钥：

pip install openai

# config.py —— 把密钥和地址集中管理，不要硬编码到处都是

API_KEY  = "sk-你的-dreamrouter-key"

BASE_URL = "https://api.dreamrouter.top/v1"

把前面学的"类 + 异常处理 + 装饰器"用上，封装一个可复用的 AI 客户端：

# services/ai_client.py

from openai import OpenAI

from config import API_KEY, BASE_URL

class AIClient:

    def __init__(self):

        self.client = OpenAI(api_key=API_KEY, base_url=BASE_URL)

    def ask(self, prompt, model="claude-sonnet-4-6"):

        try:

            resp = self.client.chat.completions.create(

                model=model,        # 换成 gpt-5、deepseek-r1 等只需改这一行

                messages=[{"role": "user", "content": prompt}],

            )

            return resp.choices[0].message.content

        except Exception as e:

            return f"调用失败：{e}"

再写一个命令行入口，一个会聊天的小工具就成型了：

# main.py

from services.ai_client import AIClient

def main():

    ai = AIClient()

    print("AI 助手已就绪，输入 q 退出")

    while True:

        q = input("\n你：")

        if q.strip().lower() == "q":

            break

        print("AI：" + ai.ask(q))

if __name__ == "__main__":

    main()

运行 python main.py，你就拥有了人生第一个能对话的 AI 程序。把 ask() 里的 prompt 稍作加工，它立刻能变成：翻译器、文案助手、代码解释器、客服机器人……剩下的，就看你的想象力了。

想测不同模型谁更适合你的任务？在 DreamRouter 里只改 model 这一个参数即可横向对比 Claude / GPT / Gemini / DeepSeek，不用反复注册多个平台。接入文档：API.dreamrouter.top

九、并发入门：让程序"同时做多件事"

当你要同时下载 100 张图片、或同时请求 50 次 API 时，一个一个排队就太慢了。Python 提供了两种常用的并发方式，先建立概念即可：

方式	适合场景	一句话理解
threading 多线程	等待型任务（网络请求、读写文件）	趁等待的空档去干别的
asyncio 异步	海量网络请求 / 高并发 IO	单线程内用 async/await 调度
multiprocessing 多进程	计算密集型（图像处理、数值计算）	真正用满多核 CPU

用 asyncio 并发请求的最小示例（比逐个请求快数倍）：

import asyncio

async def fetch(name):

    await asyncio.sleep(1)        # 模拟一次网络请求

    return f"{name} 完成"

async def main():

    tasks = [fetch(f"任务{i}") for i in range(5)]

    results = await asyncio.gather(*tasks)   # 5 个任务并发，总耗时约 1 秒

    print(results)

asyncio.run(main())

入门阶段不用深究，记住一个判断：任务在"等"（等网络、等磁盘）就用线程/异步；任务在"算"（大量计算）就用多进程。

十、3 个值得动手的进阶练习项目

看懂不等于会写，进阶唯一的捷径就是做项目。下面三个由易到难，覆盖了本文几乎所有知识点：

• 项目 1 · 个人记账工具：用类封装"账目"，数据存成 JSON/CSV，支持增删查、月度汇总。练的是：面向对象 + 文件数据 + 异常处理。
• 项目 2 · 批量文件整理器：扫描一个文件夹，按类型/日期自动归类重命名，跳过异常文件并记录日志。练的是：模块化 + 异常处理 + 装饰器（日志）。
• 项目 3 · AI 知识问答助手：读取本地若干 txt/markdown，结合大模型 API 做问答（最小版 RAG）。练的是：文件处理 + API 调用 + 项目结构。统一用 API.dreamrouter.top 调模型，省去多平台配置。

建议每个项目都用上"虚拟环境 + requirements.txt + 清晰目录结构"，把它们当成真实工程来写，而不是一个 .py 文件堆到底。

十一、总结：进阶的本质是"写给人看的代码"

回顾这一篇，我们从入门的"能跑"走到了进阶的"能维护"：

• 函数与面向对象——让代码有结构、可复用；
• 异常处理——让程序健壮、不轻易崩溃；
• 文件 / JSON / CSV——让程序能真正处理数据；
• 虚拟环境与第三方库——让项目在任何地方都能跑；
• 推导式 / 生成器 / 装饰器——写出更 Pythonic 的代码；
• 模块化与并发——从单文件走向真正的工程；
• 调用大模型 API——把 AI 能力接进自己的程序。

进阶的本质，是从"写给机器跑的代码"转向"写给人看、给团队维护的代码"。 而在 AI 时代，最值钱的进阶方向，就是让 Python 成为你调度 AI 能力的"遥控器"。当你能用几十行代码接通一个大模型，你写的就不再是练习题，而是真正能解决问题的产品。

附：用一个 API Key 调通所有主流模型（DreamRouter）

本文 AI 实战部分统一使用 DreamRouter 作为模型入口，原因很简单——对正在进阶的 Python 学习者来说，它把"接入 AI"这件事的门槛降到了最低：

• 一个 Key 调用全部主流模型：Claude Opus / Sonnet 4.x、GPT-5、Gemini 2.x、DeepSeek-R、Qwen3、Kimi K2 等几十种，换模型只改一个参数；
• 完全兼容 OpenAI 协议：现有代码改一个 base_url 即可，无需重写；
• 国内直连、低延迟：不用科学上网，省去新手最大的一道坎；
• 按量计费、无最低消费：练手阶段几乎零成本，注册有体验额度。

官网地址：api.dreamrouter.top —— 复制下面这段就能跑通你的第一个 AI 调用：

from openai import OpenAI

client = OpenAI(

    api_key="sk-your-dreamrouter-key",

    base_url="https://api.dreamrouter.top/v1",

)

resp = client.chat.completions.create(

    model="claude-sonnet-4-6",   # 也可换 gpt-5、deepseek-r1、qwen3 等

    messages=[{"role": "user", "content": "用一句话夸夸正在学 Python 的我"}],

—— 全文完。如果这篇对你有帮助，欢迎在评论区交流你正在做的进阶项目；下一篇我们手把手写一个完整的"AI 知识库问答助手"。

)

print(resp.choices[0].message.content)