AI 工程师之路
🐍

Python 编程基础

掌握 AI 开发必备的 Python 编程能力。涵盖 Python 语法、数据结构、函数式编程、面向对象编程及常用标准库，为后续 AI 开发打下坚实基础。

1

Python 基础语法

掌握 Python 的基本数据类型、控制流、函数定义、模块导入等核心语法。

入门

学习内容

新

Python 基础语法：零基础速通

如果你完全没写过代码，这篇文章就是为你准备的。不需要任何前置知识，跟着代码敲一遍，你就能看懂 Python 在说什么。

一、数据类型与变量：Python 里装东西的"盒子"

变量就像一个贴标签的盒子，你把数据放进去，以后用标签就能找到它。

# 数值：整数和小数
age = 25           # 整数（int）
price = 19.99      # 小数/浮点数（float）

# 字符串：一串文字，用单引号或双引号包起来
name = "Alice"
greeting = '你好，Python！'

# 列表：可以装很多东西，还能随时增删改
fruits = ["苹果", "香蕉", "橙子"]
fruits.append("葡萄")      # 添加元素
print(fruits[0])           # 输出：苹果（索引从0开始）

# 元组：和列表很像，但创建后不能修改
coordinates = (10, 20)

# 字典：键值对，像查字典一样用"键"找"值"
student = {
    "name": "小明",
    "age": 20,
    "score": 95.5
}
print(student["name"])     # 输出：小明

# 集合：自动去重，没有重复元素
tags = {"Python", "编程", "Python", "入门"}
print(tags)                # 输出：{'Python', '编程', '入门'}

一句话总结：

  • 列表用 []，能改；元组用 ()，不能改；字典用 {} 存键值对；集合用 {} 自动去重。

二、控制流与循环：让代码"有脑子"

2.1 条件判断：if / else

score = 85

if score >= 90:
    grade = "优秀"
elif score >= 60:
    grade = "及格"
else:
    grade = "不及格"

print(grade)   # 输出：及格

elif 是 "else if" 的缩写，表示"否则如果"。注意缩进！ Python 用缩进（通常是 4 个空格）来表示代码块，而不是大括号。

2.2 循环：重复做事

for 循环：遍历一个序列。

fruits = ["苹果", "香蕉", "橙子"]

for fruit in fruits:
    print(f"我喜欢吃{fruit}")

while 循环：条件满足就一直执行。

count = 0
while count < 3:
    print(f"第 {count + 1} 次")
    count += 1   # 等价于 count = count + 1

2.3 列表推导式：一行代码搞定循环

这是 Python 的"黑科技"，把循环和条件压缩成一行：

# 传统写法
squares = []
for x in range(1, 6):
    squares.append(x ** 2)

# 列表推导式（结果完全一样）
squares = [x ** 2 for x in range(1, 6)]
# 结果：[1, 4, 9, 16, 25]

# 还能加条件：只保留偶数的平方
even_squares = [x ** 2 for x in range(1, 6) if x % 2 == 0]
# 结果：[4, 16]

三、函数与模块：代码的"乐高积木"

3.1 定义函数

把一段常用代码打包成一个函数，以后直接调用：

def greet(name, greeting="你好"):
    """
    打招呼的函数
    name: 对方名字（必填）
    greeting: 问候语（选填，默认"你好"）
    """
    message = f"{greeting}，{name}！"
    return message

# 调用函数
print(greet("小明"))              # 输出：你好，小明！
print(greet("Alice", "Hello"))    # 输出：Hello，Alice！

参数传递规则：

  • name 是位置参数，调用时必须按顺序传。
  • greeting="你好" 是默认参数，不传就用默认值。

3.2 Lambda 表达式：迷你函数

如果函数只有一行，可以用 lambda 简写：

# 普通函数
def add(a, b):
    return a + b

# 等价 lambda
add = lambda a, b: a + b

print(add(3, 5))   # 输出：8

lambda 常用于排序、过滤等场景：

students = [("小明", 85), ("小红", 92), ("小刚", 78)]
# 按分数（索引1）排序
students.sort(key=lambda x: x[1])
print(students)   # [('小刚', 78), ('小明', 85), ('小红', 92)]

3.3 模块导入：站在巨人的肩膀上

Python 的强大在于它有海量的模块（别人写好的工具包）。

# 导入整个模块
import math
print(math.sqrt(16))   # 输出：4.0

# 只导入模块里的某个函数
from random import randint
print(randint(1, 100)) # 输出：1~100 之间的随机整数

# 给模块起别名（常用）
import datetime as dt
now = dt.datetime.now()
print(now)

包管理小贴士：

  • 标准库（如 math、random、datetime）安装 Python 自带，直接 import。
  • 第三方库（如 requests、pandas）需要先用 pip 安装： 
    pip install requests
    然后在代码里 import requests 即可使用。

四、速查表

知识点核心记忆点
变量= 赋值，不用声明类型
列表 []可变、有序、能重复
元组 ()不可变、有序
字典 {}键值对，键唯一
集合 {}无序、自动去重
if / else注意缩进！
for / whilefor 遍历，while 条件循环
列表推导式[表达式 for 变量 in 序列 if 条件]
def 函数return 返回值，默认参数放后面
lambdalambda 参数: 返回值
importimport 模块 或 from 模块 import 函数

推荐资源

📄Python 官方教程免费
2

面向对象编程

理解类与对象、继承、多态、封装等 OOP 核心概念，掌握 Python 中的面向对象设计。

入门前置要求：python-basics

学习内容

新

Python 面向对象编程

上一篇我们学会了用"盒子"装数据和用"积木"打包代码。这一篇，我们要学会用"模具造零件"——这就是面向对象编程（OOP）的核心思想。

一、类与对象：从"图纸"到"实物"

想象你要造一辆汽车。你不会每次造车都从头设计，而是先画一张图纸（类），然后照着图纸造出很多辆汽车（对象）。

# 定义一个"类"（图纸）
class Dog:
    # 类的属性：所有狗共有的特征
    species = "犬科"

    # 构造方法：创建对象时自动执行，用来初始化对象
    def __init__(self, name, age):
        self.name = name   # 实例属性：每只狗自己的名字
        self.age = age     # 实例属性：每只狗自己的年龄

    # 类的方法：对象能做的事
    def bark(self):
        return f"{self.name} 说：汪汪！"

# 照着图纸，创建两个"对象"（实例）
dog1 = Dog("旺财", 3)
dog2 = Dog("来福", 5)

print(dog1.name)        # 输出：旺财
print(dog1.bark())      # 输出：旺财 说：汪汪！
print(dog2.bark())      # 输出：来福 说：汪汪！

三个关键概念：

  • class：定义类的关键字，相当于图纸。
  • __init__：构造函数，创建对象时自动调用，self 代表对象自己（相当于"我"）。
  • 实例属性：每个对象独有的数据，通过 self.xxx 定义。

二、封装：把内部细节"藏"起来

封装的意思是：把复杂的东西包起来，只暴露简单的接口。

比如，你的手机只需要按一个按钮就能开机，不需要你亲自去连接每一根电线。

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance   # 双下划线开头 = 私有属性，外部不能直接访问

    def deposit(self, amount):
        """存钱"""
        if amount > 0:
            self.__balance += amount
            return f"存入 {amount} 元，当前余额：{self.__balance} 元"
        return "金额必须大于0"

    def withdraw(self, amount):
        """取钱"""
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return f"取出 {amount} 元，当前余额：{self.__balance} 元"
        return "余额不足或金额无效"

    def get_balance(self):
        """查看余额（对外提供的安全接口）"""
        return self.__balance

# 使用账户
account = BankAccount("小明", 1000)

# 外部无法直接修改余额（封装保护）
# print(account.__balance)   # 报错！AttributeError

# 只能通过规定的方法操作
print(account.deposit(500))     # 存入 500 元，当前余额：1500 元
print(account.withdraw(200))    # 取出 200 元，当前余额：1300 元
print(account.get_balance())    # 1300

封装的好处：

  • 防止外部随意修改内部数据，保证数据安全。
  • 使用者只需要知道 deposit 和 withdraw 怎么用，不用管里面怎么算的。

三、继承：站在父辈的肩膀上

继承让子类"自动拥有"父类的所有属性和方法，还能自己扩展新功能。

# 父类：动物
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "某种动物叫声"

    def introduce(self):
        return f"我是 {self.name}"

# 子类：狗（继承自 Animal）
class Dog(Animal):
    def speak(self):   # 重写父类方法
        return f"{self.name} 说：汪汪！"

# 子类：猫（继承自 Animal）
class Cat(Animal):
    def speak(self):   # 重写父类方法
        return f"{self.name} 说：喵喵！"

# 使用
dog = Dog("旺财")
cat = Cat("咪咪")

print(dog.introduce())   # 我是 旺财（继承自父类）
print(dog.speak())       # 旺财 说：汪汪！（子类重写）
print(cat.speak())       # 咪咪 说：喵喵！

继承的核心：

  • class Dog(Animal)：Dog 继承了 Animal 的一切。
  • 重写（Override）：子类可以覆盖父类的方法，实现自己的逻辑。
  • super()：如果想在子类里调用父类的方法，可以用 super().方法名()。

四、多态：同一种调用，不同的表现

多态的字面意思是"多种形态"。在 Python 中，不同的对象可以对同一个消息做出不同的响应。

# 一个函数，接收任何 Animal 的子类对象
def animal_concert(animal):
    print(animal.speak())

# 传入不同的对象，产生不同的结果
animal_concert(Dog("旺财"))   # 旺财 说：汪汪！
animal_concert(Cat("咪咪"))   # 咪咪 说：喵喵！

为什么这很强大？

假设你要开发一个游戏，里面有 100 种怪物。如果没有多态，你可能要写 100 个 if/else：

# 笨办法（不要这样写）
if monster_type == "狗":
    dog.attack()
elif monster_type == "猫":
    cat.attack()
# ... 写100个 elif

有了多态，只需要一行：

monster.attack()   # 不管是什么怪物，自动调用它自己的 attack 方法

五、综合实例：设计一个小游戏角色系统

把上面学的全部串起来：

class Character:
    """游戏角色基类"""
    def __init__(self, name, hp):
        self.name = name
        self.__hp = hp          # 私有：生命值
        self.__max_hp = hp

    def take_damage(self, damage):
        self.__hp = max(0, self.__hp - damage)
        return f"{self.name} 受到 {damage} 点伤害，剩余 HP：{self.__hp}"

    def is_alive(self):
        return self.__hp > 0

    def attack(self):
        return f"{self.name} 发起攻击！"


class Warrior(Character):
    """战士：高血量，普通攻击"""
    def attack(self):
        return f"{self.name} 挥舞大剑，造成 15 点伤害！"


class Mage(Character):
    """法师：低血量，魔法攻击"""
    def __init__(self, name, hp, mp):
        super().__init__(name, hp)   # 调用父类构造
        self.mp = mp

    def attack(self):
        if self.mp >= 10:
            self.mp -= 10
            return f"{self.name} 释放火球术，造成 30 点伤害！剩余 MP：{self.mp}"
        return f"{self.name} MP 不足，只能普通攻击！"


# 实战演示
warrior = Warrior("亚瑟", 100)
mage = Mage("甘道夫", 60, 20)

team = [warrior, mage]

for member in team:
    print(member.attack())   # 多态：同样是 attack()，表现完全不同

六、速查表

概念一句话解释Python 写法
类对象的图纸class Dog:
对象/实例根据图纸造出来的实物dog = Dog()
__init__构造函数，创建对象时自动执行def __init__(self, name):
self代表对象自己，必须作为第一个参数self.name = name
实例属性每个对象独有的数据self.age = 5
类属性所有对象共享的数据species = "犬科"
方法对象能做的事def bark(self):
封装把内部细节藏起来，只暴露接口__balance（私有属性）
继承子类自动拥有父类的一切class Dog(Animal):
重写子类覆盖父类的方法同名方法重新定义
多态同一个调用，不同对象表现不同animal.speak()

OOP 的本质不是语法，而是思维方式。 当你看到任何问题都下意识想"这里该定义一个什么类"时，你就真正入门了。

推荐资源

📄Real Python OOP 教程免费
3

Python 进阶特性

学习装饰器、生成器、上下文管理器、迭代器等 Python 高级特性，提升代码质量和开发效率。

进阶前置要求：python-oop

学习内容

新

Python 进阶特性

当你已经会写函数和类，下一步就是学会 Python 的"秘密武器"——它们能让你的代码更简洁、更高效、更优雅。这篇不需要你提前掌握复杂理论，跟着代码敲一遍，你会发现"原来还能这样写"。

一、迭代器：逐个"拿"东西，而不是一次性"搬"回家

迭代器是一个记住遍历位置的对象，它一次只给你一个元素，而不是把所有元素一股脑塞给你。

# 列表是可迭代对象，但不是迭代器
my_list = [1, 2, 3]

# 用 iter() 把它变成迭代器
it = iter(my_list)

# 用 next() 逐个取值
print(next(it))   # 1
print(next(it))   # 2
print(next(it))   # 3
# print(next(it)) # 报错！StopIteration，已经取完了

为什么要用迭代器？ 想象你在看一本 1000 页的书。列表相当于把整本书复印一份给你，迭代器相当于一次只翻开一页给你看——省内存。

自己写一个迭代器：

class CountDown:
    """从 n 倒数到 1 的迭代器"""
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.start <= 0:
            raise StopIteration   # 迭代结束的信号
        self.start -= 1
        return self.start + 1

# 使用
for num in CountDown(5):
    print(num)   # 输出：5, 4, 3, 2, 1

二、生成器：用函数写迭代器，一行 yield 搞定

如果你觉得上面的类太麻烦，生成器就是救星。它用普通函数的写法，实现迭代器的功能。

def countdown(n):
    """从 n 倒数到 1"""
    while n > 0:
        yield n   # yield 会"暂停"函数，记住当前状态，下次从这里继续
        n -= 1

# 使用
for num in countdown(5):
    print(num)   # 输出：5, 4, 3, 2, 1

yield 和 return 的区别：

  • return：函数结束，返回值，下次调用从头再来。
  • yield：函数"暂停"，返回值，下次调用从暂停处继续。

生成器表达式：和列表推导式很像，只是把 [] 换成 ()：

# 列表推导式：一次性生成所有数据，占用内存
squares_list = [x**2 for x in range(1000000)]

# 生成器表达式：惰性求值，用的时候才生成，几乎不占内存
squares_gen = (x**2 for x in range(1000000))

print(sum(squares_gen))   # 可以正常计算，但内存占用极小

三、装饰器：给函数"穿外套"，不改动原代码加功能

装饰器本质上是一个接收函数作为参数，并返回一个新函数的函数。

3.1 最简单的装饰器

假设你想知道每个函数运行了多久：

import time

def timer(func):
    """计时装饰器"""
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} 运行了 {time.time() - start:.4f} 秒")
        return result
    return wrapper

# @timer 是语法糖，等价于：slow_function = timer(slow_function)
@timer
def slow_function():
    time.sleep(1)
    return "Done"

slow_function()
# 输出：slow_function 运行了 1.0012 秒

*args 和 **kwargs 是 Python 的"万能参数"，表示"不管传多少个位置参数和关键字参数，我都能接住"。

3.2 带参数的装饰器

如果你想让装饰器更灵活，可以套两层：

def repeat(times):
    """让函数重复执行 n 次"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def say_hello():
    print("你好！")

say_hello()   # 输出 3 次"你好！"

四、上下文管理器：with 语句，自动帮你"善后"

打开文件后忘记关闭？获取锁后忘记释放？上下文管理器就是用来解决这类"用了要还"的问题。

4.1 基本用法：with 语句

# 传统写法（容易忘记关闭）
f = open("test.txt", "w")
f.write("hello")
f.close()

# 上下文管理器（自动关闭，即使出异常也会关闭）
with open("test.txt", "w") as f:
    f.write("hello")
# 出了 with 块，文件自动关闭

4.2 自己实现上下文管理器

class DatabaseConnection:
    """模拟数据库连接"""
    def __enter__(self):
        print("🔗 连接数据库...")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("🔒 关闭数据库连接...")
        # 如果返回 True，会吞掉异常；返回 None，异常正常抛出

    def query(self, sql):
        print(f"执行 SQL：{sql}")

# 使用
with DatabaseConnection() as db:
    db.query("SELECT * FROM users")
# 输出：
# 🔗 连接数据库...
# 执行 SQL：SELECT * FROM users
# 🔒 关闭数据库连接...

4.3 用 contextmanager 简化（推荐）

用装饰器写更简洁：

from contextlib import contextmanager

@contextmanager
def managed_resource(name):
    print(f"获取资源：{name}")
    yield name   # yield 之前的代码是 __enter__，之后的是 __exit__
    print(f"释放资源：{name}")

with managed_resource("数据库连接") as r:
    print(f"使用 {r} 中...")
# 输出：
# 获取资源：数据库连接
# 使用 数据库连接 中...
# 释放资源：数据库连接

五、综合实例：处理大文件的"最佳实践"

把四大特性串起来，写一个读取大日志文件并统计关键词的工具：

import time
from contextlib import contextmanager

# 1. 上下文管理器：安全打开文件
@contextmanager
def safe_open(filename):
    print(f"📂 正在打开 {filename}...")
    f = open(filename, "r", encoding="utf-8")
    try:
        yield f
    finally:
        f.close()
        print(f"📂 已关闭 {filename}")

# 2. 生成器：逐行读取，不占用大量内存
def line_generator(file_obj):
    for line in file_obj:
        yield line.strip()   # strip() 去掉换行符

# 3. 装饰器：统计处理时间
def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"⏱️ {func.__name__} 耗时：{time.time() - start:.4f} 秒")
        return result
    return wrapper

# 4. 综合使用
@timer
def count_keyword(filename, keyword):
    count = 0
    with safe_open(filename) as f:
        # 迭代器 + 生成器：逐行处理，内存友好
        for line in line_generator(f):
            if keyword in line:
                count += 1
    return count

# 假设有一个大日志文件，统计"ERROR"出现次数
# result = count_keyword("app.log", "ERROR")
# print(f"找到 {result} 处错误")

六、速查表

特性核心作用关键语法记忆口诀
迭代器逐个取值，省内存__iter__() + __next__()"翻书一页一页看"
iter() / next()把可迭代对象变成迭代器it = iter(list)"造个迭代器"
生成器用函数写迭代器yield"暂停魔法"
生成器表达式惰性求值的推导式(x for x in range(100))"圆括号省内存"
装饰器不改动原函数，加功能@decorator"给函数穿外套"
*args / **kwargs接收任意参数def func(*args, **kwargs)"万能口袋"
上下文管理器自动获取和释放资源with ... as ..."用了自动还"
__enter__ / __exit__上下文管理器的两个钩子类方法实现"进门出门"
@contextmanager用生成器简化上下文管理器yield 分割前后逻辑"装饰器版 with"

进阶特性的本质，是让代码写得更"Pythonic"。 不要追求炫技，而是在合适的场景用合适的工具。当你习惯用 with 管理资源、用 yield 处理大数据、用装饰器解耦功能时，你就从"会写 Python"变成了"写好 Python"。

推荐资源

📄Python 进阶教程免费
4

科学计算库入门

初步了解 NumPy 数值计算、Pandas 数据处理、Matplotlib 数据可视化等 AI 开发必备库。

进阶前置要求：python-advanced

学习内容

新

Python 科学计算库入门

如果说 Python 是 AI 世界的"普通话"，那么 NumPy、Pandas、Matplotlib 就是这门语言里的"三板斧"。学会它们，你就拿到了进入数据科学和 AI 大门的钥匙。

一、NumPy：让 Python 算得飞快

Python 自带的列表算数学很慢。NumPy 提供了数组（ndarray），让你像写数学公式一样批量计算。

import numpy as np

# 创建数组：比 Python 列表快几十倍
arr = np.array([1, 2, 3, 4, 5])

# 批量运算：每个元素同时操作
print(arr * 2)          # [ 2  4  6  8 10]
print(arr + 10)         # [11 12 13 14 15]

# 二维数组：像数学里的矩阵
matrix = np.array([[1, 2], [3, 4], [5, 6]])
print(matrix.shape)     # (3, 2)  3行2列

# 常用计算：求和、平均、最大
print(np.sum(arr))      # 15
print(np.mean(arr))     # 3.0
print(np.max(arr))      # 5

一句话记住 NumPy： 把一堆数字装进一个"超级列表"，一次性算完，不用写循环。

二、Pandas：Excel 表格的 Python 版

Pandas 用 DataFrame（数据框）来管理表格数据，就像 Python 里的 Excel。

import pandas as pd

# 创建一张表格
data = {
    "姓名": ["小明", "小红", "小刚"],
    "年龄": [20, 22, 21],
    "分数": [85, 92, 78]
}
df = pd.DataFrame(data)

# 查看数据
print(df.head(2))       # 看前2行
print(df["分数"])       # 取某一列
print(df[df["分数"] > 80])  # 筛选：分数大于80的行

# 统计摘要
print(df.describe())    # 自动算平均、最大、最小等

读取真实文件：

# 读取 CSV（最常用）
df = pd.read_csv("data.csv")

# 保存结果
df.to_csv("result.csv", index=False)

一句话记住 Pandas： 用代码操作 Excel 表格，筛选、统计、读写文件，几行搞定。

三、Matplotlib：把数据画成图

数据藏在表格里看不出趋势？画出来就一目了然。

import matplotlib.pyplot as plt

# 数据
months = ["1月", "2月", "3月", "4月", "5月"]
sales = [120, 150, 180, 140, 200]

# 画折线图
plt.plot(months, sales, marker="o", color="red")
plt.title("月度销售额")
plt.xlabel("月份")
plt.ylabel("销售额（万元）")
plt.grid(True)
plt.show()

常用图表类型：

# 柱状图
plt.bar(months, sales, color="skyblue")

# 散点图
plt.scatter([1, 2, 3], [4, 5, 6])

# 饼图
plt.pie([30, 20, 50], labels=["A", "B", "C"], autopct="%1.1f%%")

一句话记住 Matplotlib： 给数据拍张照，折线、柱状、饼图，选一种让数字开口说话。

四、4 分钟速查表

库核心对象常用操作什么时候用
NumPyndarray 数组np.array()、np.sum()、np.mean()大量数字计算、矩阵运算
PandasDataFrame 表格pd.read_csv()、df["列名"]、df.describe()处理表格数据、数据清洗
Matplotlibplt 画图模块plt.plot()、plt.bar()、plt.show()数据可视化、出报告

NumPy 负责算，Pandas 负责管，Matplotlib 负责看。 这三个库配合起来，就是 AI 开发最基础的数据流水线。先把这"三板斧"练熟，后面的机器学习库（如 Scikit-learn、PyTorch）学起来会轻松很多。

推荐资源

📄NumPy 官方文档免费📄Pandas 入门教程免费
返回学习路线