Python 程序设计：
从语法基础到 AI 应用的完整学习教程

# 检查版本
$ python3 --version
Python 3.12.0

# 进入交互式解释器
$ python3
>>> 2 + 3
5
>>> print("Hello")
Hello
>>> exit()

# hello.py —— 最简单的 Python 程序
print("Hello, World!")

$ python3 hello.py
Hello, World!

if score >= 60:
    print("及格")
    print("加油")
else:
    print("不及格")

# 缩进不一致会报错
# IndentationError: unexpected indent

# 单行注释：以 # 开头

"""
多行字符串 / 文档字符串（docstring）：
- 模块、类、函数的首行可以用三引号说明
- 可以通过 __doc__ 访问
"""

def add(a, b):
    """返回 a + b 的和"""
    return a + b

# 整数 int
age = 18

# 浮点 float
score = 95.5

# 复数 complex
z = 1 + 2j

# 字符串 str
name = "Python"

# 布尔 bool
ok = True

# 空值 NoneType
result = None

# 动态类型：变量可随时指向新类型
x = 10
x = "hello"      # ✔ OK

x = 3.14

type(x)              # <class 'float'>
isinstance(x, float)  # True（推荐）

# 显式转换
int("123")         # 123
float("3.14")     # 3.14
str(42)           # '42'
bool(0)           # False
list("abc")       # ['a', 'b', 'c']

# Python 特有的
7 / 2     # 3.5（真除法）
7 // 2    # 3（整除，向下取整）
2 ** 10   # 1024

# 链式比较
1 < x < 10     # ✔ Python 支持链式比较

# 海象运算符（Python 3.8+）
if (n := len(name)) > 5:
    print(n)

s = "Python"
s[0]      # 'P'   （正向）
s[-1]     # 'n'   （反向）

# 多行字符串
text = """第一行
第二行
第三行"""

# 转义
s = "他说：\"你好\""
print("a\nb")   # 换行
print(r"C:\Users")  # 原始字符串，不转义

s = "Hello, World!"

s[0:5]       # 'Hello'    （包头不包尾）
s[7:]        # 'World!'   （从 7 到最后）
s[:-1]      # 'Hello, World' （去掉最后）
s[::2]      # 'Hlo ol!'   （步长 2）
s[::-1]     # '!dlroW ,olleH' （反转）

name = "Tom"
age = 20
pi = 3.14159

print(f"姓名：{name}, 年龄：{age}")             # 姓名：Tom, 年龄：20
print(f"PI 保留两位：{pi:.2f}")          # 3.14
print(f"十六进制：{255:#x}")            # 0xff
print(f"右对齐：{'hi':>10}|")      # '        hi|'

# 表达式与调试 = （Python 3.8+）
print(f"{name=}, {age=}")            # name='Tom', age=20

nums = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True, [1, 2]]    # 元素类型可以混合

nums[0]          # 1
nums[-1]         # 5（最后一个）
nums[1:4]        # [2, 3, 4]
nums[::2]        # [1, 3, 5]
nums[::-1]       # [5, 4, 3, 2, 1]（反转）

len(nums)        # 5
nums[0] = 100      # ✔ 可修改

a = [1, 2, 3]

# 添加
a.append(4)             # [1,2,3,4]
a.extend([5, 6])         # [1,2,3,4,5,6]
a.insert(1, 99)         # [1,99,2,3,4,5,6]

# 删除
a.remove(99)            # 按值删第一个 99
a.pop()                 # 删末尾，返回值
a.pop(0)               # 删第一个
del a[0]              # 按下标删
a.clear()               # 清空 → []

# 排序
a.sort()                # 升序，原地
a.sort(reverse=True)   # 降序
sorted(a)             # 返回新列表，原列表不变

# 1~10 的平方
squares = [x * x for x in range(1, 11)]

# 偶数
evens = [x for x in range(10) if x % 2 == 0]

# 嵌套：二维拍平
matrix = [[1,2], [3,4], [5,6]]
flat = [x for row in matrix for x in row]   # [1,2,3,4,5,6]

point = (10, 20)
x, y = point       # 解包

# 单元素元组必须有逗号
t = (42,)         # tuple
t = (42)          # int

# 不可变：
# point[0] = 99    # ❌ TypeError

# 常见用途：作为字典的 key、函数多返回值
def minmax(arr):
    return min(arr), max(arr)

mn, mx = minmax([3, 1, 4, 1, 5, 9, 2, 6])

s = {1, 2, 3, 2, 1}
print(s)        # {1, 2, 3}   自动去重

s.add(4)
s.remove(1)        # 不存在会抛异常
s.discard(1)      # 不存在静默

# 集合运算
a = {1, 2, 3}
b = {3, 4, 5}
a | b          # {1,2,3,4,5}  并集
a & b          # {3}         交集
a - b          # {1, 2}      差集
a ^ b          # {1,2,4,5}   对称差

student = {
    "name": "Tom",
    "age": 20,
    "score": 95,
}

# 增删改查
student["gender"] = "M"          # 添加
student["age"] = 21              # 修改
v = student.get("name", "N/A")     # 安全访问
del student["gender"]

# 遍历
for k, v in student.items():
    print(k, v)

# 字典推导式
squares = {x: x*x for x in range(5)}    # {0:0, 1:1, 2:4, 3:9, 4:16}

if score >= 90:
    print("A")
elif score >= 80:
    print("B")
elif score >= 60:
    print("C")
else:
    print("D")

# 三元表达式
msg = "及格" if score >= 60 else "不及格"

command = "quit"

match command:
    case "quit":
        print("退出")
    case "save" | "export":        # 多值
        print("保存")
    case var if var.startswith("load"):    # 守卫
        print("加载", var)
    case _:                              # 默认
        print("未知")

# while
n = 0
while n < 5:
    print(n)
    n += 1

# for + range
for i in range(5):          # 0..4
    print(i)

range(2, 10, 3)        # 2, 5, 8
range(10, 0, -1)      # 10..1

# 遍历列表 / 字典
for x in [1, 2, 3]:
    print(x)

for i, v in enumerate(["a", "b", "c"]):     # (0,a), (1,b), (2,c)
    print(i, v)

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}×{i}={i*j:<2}", end=" ")
    print()

def greet(name, greeting="Hello"):     # 默认参数
    return f"{greeting}, {name}!"

greet("Tom")                      # Hello, Tom!
greet("Tom", greeting="Hi")        # Hi, Tom!

# 关键字参数
greet(greeting="Hey", name="Alice")

# *args / **kwargs：可变参数
def add(*args, **kwargs):
    print(args)      # tuple (1, 2, 3)
    print(kwargs)    # dict {x: 1, y: 2}

add(1, 2, 3, x=1, y=2)

x = "global"

def outer():
    x = "enclosing"

    def inner():
        nonlocal x        # 修改外层（非全局）变量
        x = "local"

    inner()
    print(x)        # local

outer()

# global 关键字：声明使用全局变量
counter = 0
def inc():
    global counter
    counter += 1

# 函数是一等公民
f = abs
print(f(-5))      # 5

# 高阶函数：接受函数作为参数
def apply(func, x, y):
    return func(x, y)

print(apply(lambda a, b: a * b, 3, 4))   # 12

# 递归
def factorial(n):
    if n <= 1: return 1
    return n * factorial(n - 1)

# 基本：[表达式 for 变量 in 可迭代对象]
squares = [x * x for x in range(10)]

# 条件：[表达式 for x in ... if 条件]
evens = [x for x in range(10) if x % 2 == 0]

# 多层 for
pairs = [(x, y) for x in [1, 2, 3] for y in ["a", "b"]]

# 字典
counts = {ch: s.count(ch) for ch in set(s)}

# 集合
unique = {x % 3 for x in range(10)}

# 生成器表达式（惰性、按需产出，节省内存）
gen = (x * x for x in range(1000000))
print(sum(gen))   # 不需要先存列表

import math
import numpy as np
from math import sqrt, pi
from os.path import join

print(math.sqrt(16))
print(np.array([1, 2, 3]))

# utils.py
def add(a, b):
    return a + b

if __name__ == "__main__":
    # 仅当直接运行此文件时执行，被 import 时不会
    print(add(3, 5))

# 读取整个文件
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

# 逐行读取（生成器）
with open("data.txt") as f:
    for line in f:        # 每行保留 \n
        print(line.rstrip())

# 写入
with open("out.txt", "w", encoding="utf-8") as f:
    f.write("Hello\n")

# 推荐：pathlib
from pathlib import Path
text = Path("data.txt").read_text(encoding="utf-8")
Path("out.txt").write_text("hello", encoding="utf-8")

import json

# 对象 ↔ JSON
data = {"name": "Tom", "age": 20}
s = json.dumps(data, ensure_ascii=False)    # → JSON 字符串
obj = json.loads(s)                         # ← JSON 字符串

import csv
with open("data.csv", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row["name"], row["age"])

try:
    n = int(input("数字："))
    result = 10 / n
except ValueError:
    print("请输入数字")
except ZeroDivisionError:
    print("不能为零")
except (TypeError, KeyError) as e:
    print(f"其他错误：{e}")
else:
    print("无异常，结果：", result)
finally:
    print("结束")

class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        super().__init__(f"余额 {balance}, 需 {amount}")
        self.balance = balance

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(balance, amount)
    return balance - amount

class Student:
    """学生类"""

    # 构造方法
    def __init__(self, name: str, age: int, score: float = 0.0):
        self.name = name      # 实例属性
        self._age = age        # 单下划线：约定"内部使用"
        self.score = score

    def study(self, subject: str) -> None:
        print(f"{self.name} 正在学 {subject}")

    def __repr__(self) -> str:
        return f"Student(name={self.name}, age={self._age})"

# 使用
s = Student("Alice", 20, 95.5)
s.study("Python")
print(s)              # Student(name=Alice, age=20)

class Account:
    def __init__(self, balance):
        self._balance = balance

    # @property：把方法变成属性（getter）
    @property
    def balance(self):
        return self._balance

    # setter
    @balance.setter
    def balance(self, value):
        if value < 0:
            raise ValueError("不能为负")
        self._balance = value

a = Account(100)
print(a.balance)      # 100（像属性一样访问）
a.balance = 200      # 自动走 setter

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hi(self):
        print(f"Hi, I'm {self.name}")

class Student(Person):
    def __init__(self, name, age, school):
        super().__init__(name, age)    # 调用父类
        self.school = school

    def say_hi(self):                  # 方法重写
        super().say_hi()
        print(f"I study at {self.school}")

s = Student("Alice", 20, "MIT")
s.say_hi()

# Python 的多态：鸭子类型 —— 只要有方法就能用
class Dog:
    def speak(self): print("汪")

class Cat:
    def speak(self): print("喵")

def make_speak(animal):
    animal.speak()

make_speak(Dog())   # 汪
make_speak(Cat())   # 喵

# 类方法、静态方法
class Circle:
    pi = 3.14159

    def __init__(self, r): self.r = r

    @classmethod
    def from_diameter(cls, d):
        return cls(d / 2)

    @staticmethod
    def is_valid_radius(r):
        return r > 0

class Vec2:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):       # 调试字符串
        return f"Vec2({self.x}, {self.y})"

    def __str__(self):        # 用户友好字符串
        return f"(<{self.x}, {self.y}>)"

    def __add__(self, other):  # +
        return Vec2(self.x + other.x, self.y + other.y)

    def __eq__(self, other):  # ==
        return self.x == other.x and self.y == other.y

    def __len__(self):       # len()
        return 2

    def __getitem__(self, i): # 下标访问
        return [self.x, self.y][i]

v = Vec2(3, 4)
print(v + Vec2(1, 2))    # Vec2(4, 6)
print(v[0])              # 3
print(len(v))             # 2

def counter(n):
    for i in range(n):
        yield i           # 暂停，返回值；下次 next() 时继续

g = counter(5)
print(next(g))      # 0
print(next(g))      # 1
for x in g:           # 继续迭代剩下的
    print(x)

# 生成器表达式（与列表推导式类似）
gen = (x * x for x in range(10 if x % 2 == 0)
print(sum(gen))    # 0+4+16+36+64 = 120

class Countdown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):       # 返回迭代器
        return self

    def __next__(self):       # 下一个值
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1

for i in Countdown(3):    # 3, 2, 1
    print(i)

square = lambda x: x * x
print(square(5))        # 25

# map: 对每个元素应用函数
nums = [1, 2, 3, 4]
sq = list(map(lambda x: x * x, nums))   # [1, 4, 9, 16]

# filter: 过滤
evens = list(filter(lambda x: x % 2 == 0, nums))

# sorted + key
students = [{"name": "Tom", "score": 85}, {"name": "Alice", "score": 95}]
sorted(students, key=lambda s: s["score"], reverse=True)

# reduce（functools）
from functools import reduce
print(reduce(lambda a, b: a + b, [1, 2, 3, 4]))   # 10

def timer(func):
    """计时装饰器"""
    def wrapper(*args, **kwargs):
        import time
        t0 = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} 用时 {time.time() - t0}s")
        return result
    return wrapper

@timer
def slow():
    sum(range(1000000))

slow()    # slow 用时 0.03s

def retry(times=3):
    def decorator(func):
        from functools import wraps
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(times):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if i == times - 1: raise
        return wrapper
    return decorator

@retry(times=3)
def flaky_network_call():
    # ...
    pass

import re

text = "联系我：alice@mit.edu 或 138-1234-5678"

# 提取邮箱
emails = re.findall(r"[\w.]+@[\w.]+", text)

# 提取手机号
phones = re.findall(r"\d{3}-\d{4}-\d{4}", text)

# 替换
masked = re.sub(r"\d", "*", "我的卡号是 1234-5678")

# 校验格式
def is_email(s):
    return re.match(r"^[\w.]+@[\w.]+\.\w+$", s) is not None

from datetime import datetime, date, timedelta

now = datetime.now()
today = date.today()

# 构造与格式化
dt = datetime(2024, 3, 15, 10, 30)
s = dt.strftime("%Y-%m-%d %H:%M:%S")

# 解析
parsed = datetime.strptime("2024-03-15", "%Y-%m-%d")

# 时间差
delta = timedelta(days=7, hours=2)
next_week = now + delta

# 时间戳
ts = now.timestamp()           # 1742025667.123
dt2 = datetime.fromtimestamp(ts)

# 安装 / 卸载 / 升级
$ pip install requests
$ pip install requests==2.31.0     # 指定版本
$ pip install -r requirements.txt  # 从文件安装
$ pip install --upgrade numpy
$ pip uninstall pandas

# 查看 / 导出
$ pip list
$ pip show numpy
$ pip freeze > requirements.txt    # 导出依赖

# 创建虚拟环境
$ python3 -m venv .venv

# 激活
$ source .venv/bin/activate          # macOS / Linux
$ .venv\Scripts\activate            # Windows

# 在虚拟环境中安装包
(venv) $ pip install requests

# 退出
(venv) $ deactivate

name: str = "Tom"
age: int = 20
scores: list[int] = [90, 85, 95]

def add(a: int, b: int) -> int:
    return a + b

# 复杂类型
from typing import Optional, Union

def find_user(uid: int) -> Optional[str]:
    return None     # 或 str

def parse(x: Union[int, str]) -> int:
    return int(x)

import threading

counter = 0
lock = threading.Lock()

def worker():
    global counter
    for _ in range(10000):
        with lock:           # 互斥访问
            counter += 1

threads = [threading.Thread(target=worker) for _ in range(4)]
for t in threads: t.start()
for t in threads: t.join()

print(counter)   # 40000

from concurrent.futures import ThreadPoolExecutor

def fetch(url):
    # 模拟网络请求
    return f"data from {url}"

urls = [f"https://api.example.com/{i}" for i in range(10)]

with ThreadPoolExecutor(max_workers=5) as pool:
    results = list(pool.map(fetch, urls))

import asyncio

async def fetch(url):
    print(f"Fetching {url}...")
    await asyncio.sleep(1)        # 模拟 IO
    print(f"Done {url}")
    return f"data from {url}"

async def main():
    # 并发执行 3 个任务
    results = await asyncio.gather(
        fetch("a.com"),
        fetch("b.com"),
        fetch("c.com"),
    )

asyncio.run(main())

import aiohttp
import asyncio

async def fetch_all(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [session.get(u) for u in urls]
        responses = await asyncio.gather(*tasks)
        return [r.text() async for r in responses]

import requests

# GET 请求
r = requests.get("https://api.github.com/users/python")
print(r.json()["name"])

# 带参数 + POST
data = {"name": "Tom", "age": 20}
r = requests.post("https://httpbin.org/post", json=data, timeout=5)

# 错误处理
try:
    r.raise_for_status()      # 4xx / 5xx 自动抛异常
except requests.HTTPError as e:
    print(e)

import json, csv

# JSON
data = {"users": [{"name": "Tom", "age": 20}]}
print(json.dumps(data, indent=2, ensure_ascii=False))

# CSV：DictReader
with open("data.csv", newline="", encoding="utf-8") as f:
    for row in csv.DictReader(f):
        print(row["name"])

import sqlite3

conn = sqlite3.connect("school.db")
c = conn.cursor()

# 创建表
c.execute("""CREATE TABLE IF NOT EXISTS student(
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    age INTEGER)""")

# 插入（参数化防 SQL 注入）
c.execute("INSERT INTO student(name, age) VALUES(?, ?)", ("Tom", 20))
conn.commit()

# 查询
for row in c.execute("SELECT * FROM student WHERE age > ?", (18,)):
    print(row)

conn.close()

my_project/
├── pyproject.toml     # 现代项目配置（替代 setup.py）
├── README.md
├── .gitignore
├── requirements.txt
├── src/
│   └── myapp/
│       ├── __init__.py
│       ├── main.py
│       └── utils.py
├── tests/
│   ├── __init__.py
│   └── test_main.py
└── data/
    └── input.csv

from myapp.utils import add

def test_add():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, 1) == 0

import numpy as np

a = np.array([1, 2, 3, 4, 5])
print(a + 10)                # [11 12 13 14 15]（向量化）
print(a.mean(), a.std())

# 二维数组（矩阵）
m = np.array([[1, 2], [3, 4]])
print(m.T)         # 转置
print(m @ m)       # 矩阵乘法

import pandas as pd

# 读 CSV
df = pd.read_csv("students.csv")

print(df.head())            # 前 5 行
print(df.describe())        # 数值列统计
print(df.info())            # 数据类型概览

# 筛选、排序
adults = df[df["age"] >= 18]
top = df.sort_values("score", ascending=False)

# 分组统计
avg_by_class = df.groupby("class")["score"].mean()

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 100)

plt.figure(figsize=(8, 4))
plt.plot(x, np.sin(x), label="sin")
plt.plot(x, np.cos(x), label="cos")
plt.legend()
plt.title("三角函数")
plt.savefig("trig.png", dpi=100)
plt.show()

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model = RandomForestClassifier()
model.fit(X_train, y_train)
pred = model.predict(X_test)

print("准确率：", accuracy_score(y_test, pred))

import openai

client = openai.OpenAI(api_key="sk-xxx")

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "你是一个 Python 助手"},
        {"role": "user", "content": "什么是列表推导式？"},
    ],
)
print(response.choices[0].message.content)

import bisect

a = [1, 3, 5, 7, 9, 11]

# 二分查找（标准库）
bisect.bisect_left(a, 7)      # 3（第一个 ≥ 7 的位置）
bisect.bisect_right(a, 7)     # 4（第一个 > 7 的位置）

# 手写二分
def bsearch(a, target):
    lo, hi = 0, len(a) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if a[mid] == target:   return mid
        elif a[mid] < target: lo = mid + 1
        else:                hi = mid - 1
    return -1

# 链表节点
class Node:
    def __init__(self, v, n=None):
        self.v, self.n = v, n

# 快速排序
def qsort(a):
    if len(a) <= 1: return a
    p = a[0]
    return qsort([x for x in a[1:] if x < p]) + [p] + \
           qsort([x for x in a[1:] if x >= p])

print(qsort([5, 2, 8, 1, 9, 3]))   # [1, 2, 3, 5, 8, 9]

# 实战建议：直接用 sorted()
print(sorted([5, 2, 8, 1, 9, 3]))   # [1, 2, 3, 5, 8, 9]

# 1) 读文本
from pathlib import Path
text = Path("a.txt").read_text(encoding="utf-8")

# 2) 计时
import time
t0 = time.time()
# ...
print(f"{time.time() - t0:.2f}s")

# 3) 安全除法
def safe_div(a, b):
    return a / b if b != 0 else None

# 4) 链式比较 + 三元
status = "teen" if 13 <= age <= 19 else "adult"

# 5) 列表按字段排序
sorted(students, key=lambda s: s["score"], reverse=True)

# 6) 字典分组
from itertools import groupby
sorted(data, key=lambda x: x["class"])