Python编程完全指南

← 返回指南列表

Python编程完全指南

一、Python概述

1.1 语言简介

Python是由Guido van Rossum于1991年创建的高级编程语言,以简洁优雅的语法和强大的生态著称。

核心特性:

特性 说明
动态类型 变量无需声明类型,运行时确定
强类型 不同类型之间不会隐式转换
简洁语法 使用缩进定义代码块,可读性极高
解释型 逐行解释执行,支持交互式编程
面向对象 一切皆对象,支持继承、封装、多态
垃圾回收 自动内存管理(引用计数 + 标记清除)
跨平台 Windows/Linux/macOS均可运行
标准库丰富 “自带电池”,涵盖网络/文件/数据/测试等

1.2 版本选择

版本 发布时间 状态
Python 2.7 2010年 2020年停止支持
Python 3.6 2016年 f-string、类型注解
Python 3.8 2019年 海象运算符(:=)
Python 3.10 2021年 结构化模式匹配(match/case)
Python 3.11 2022年 性能大幅提升(25%)
Python 3.12 2023年 改进错误信息、类型变量

1.3 安装与环境

BASH
# Linux(Ubuntu/Debian)
sudo apt update
sudo apt install python3 python3-pip python3-venv

# macOS
brew install python3

# 验证安装
python3 --version
pip3 --version

# 虚拟环境
python3 -m venv myenv
source myenv/bin/activate    # Linux/macOS
myenv\Scripts\activate       # Windows
deactivate                   # 退出虚拟环境

# 包管理
pip install requests         # 安装
pip install -r requirements.txt  # 批量安装
pip freeze > requirements.txt    # 导出依赖列表
pip list                     # 列出已安装包
pip show requests            # 查看包详情

1.4 开发工具

工具 类型 特点
VS Code + Python插件 IDE 免费、轻量、功能强大
PyCharm IDE JetBrains出品,功能最全面
Jupyter Notebook 交互式 数据分析、教学首选
IDLE IDE Python自带,适合入门

二、基础语法详解

2.1 变量与数据类型

PYTHON
# ========== 变量声明(无需声明类型) ==========
name = "Python"
age = 30
pi = 3.14159
is_active = True

# 多变量赋值
a, b, c = 1, 2, 3          # 元组解包
x = y = z = 0              # 链式赋值

# 变量交换(无需临时变量)
a, b = b, a

# ========== 基本数据类型 ==========
# int:任意精度整数
num = 42
bignum = 10 ** 100         # 超大整数,无溢出
binary = 0b1010            # 二进制 (10)
octal = 0o12               # 八进制 (10)
hex_num = 0xFF             # 十六进制 (255)

# float:双精度浮点数(IEEE 754)
f = 3.14159
sci = 1.5e-3               # 科学计数法 (0.0015)

# complex:复数
c = 3 + 4j
print(c.real, c.imag)      # 3.0 4.0
print(abs(c))              # 5.0 (模长)

# bool:True/False(int的子类)
print(True == 1)           # True
print(False == 0)          # True
print(True + True)         # 2

# NoneType:唯一值 None
result = None

# str:字符串(不可变Unicode序列)
s1 = 'Hello'
s2 = "World"
s3 = """多行
字符串"""
s4 = f"格式化: {name} {age}"  # f-string (3.6+)

# bytes:不可变字节序列
b = b"hello"
print(b[0])                # 104

# ========== type() 和 isinstance() ==========
print(type(42))            # <class 'int'>
print(isinstance(42, int)) # True
print(isinstance(True, int))  # True(bool是int子类)

# ========== 动态类型演示 ==========
var = 42                   # int
print(type(var))
var = "hello"              # str
print(type(var))
var = [1, 2, 3]            # list
print(type(var))

2.2 数值运算

PYTHON
# ========== 算术运算符 ==========
a, b = 10, 3
print(a + b)    # 13  加法
print(a - b)    # 7   减法
print(a * b)    # 30  乘法
print(a / b)    # 3.333...  真除法(总是返回float)
print(a // b)   # 3   整除(向下取整)
print(a % b)    # 1   取余
print(a ** b)   # 1000  幂运算

# 注意:负数的整除
print(-10 // 3)  # -4(向下取整)
print(-10 % 3)   # 2(满足 a = b*q + r 且 0 <= r < |b|)

# ========== 赋值运算符 ==========
n = 10
n += 5     # n = 15
n -= 3     # n = 12
n *= 2     # n = 24
n /= 4     # n = 6.0
n //= 2    # n = 3
n **= 2    # n = 9

# 海象运算符(3.8+):赋值表达式中赋值
if (n := len("hello")) > 3:
    print(f"长度{n}大于3")

# ========== 比较运算符 ==========
print(5 == 5)    # True
print(5 != 3)    # True
print(5 > 3)     # True
print(5 >= 5)    # True
print("abc" < "abd")  # True(字典序)
print([1, 2] < [1, 3])  # True

# 链式比较
x = 5
print(3 < x < 10)  # True(等价于 3 < x and x < 10)

# ========== 逻辑运算符 ==========
print(True and False)  # False  短路求值
print(True or False)   # True
print(not True)        # False

# and/or 返回值(非布尔值)
print(0 and "hello")   # 0(短路,返回假值)
print("" or "default") # "default"(短路,返回真值)
print(3 and 5)         # 5(都为真,返回最后一个)

# ========== 位运算符 ==========
print(5 & 3)    # 1   (0101 & 0011 = 0001)
print(5 | 3)    # 7   (0101 | 0011 = 0111)
print(5 ^ 3)    # 6   (0101 ^ 0011 = 0110)
print(~5)       # -6  (~0101 = ...11111010)
print(5 << 1)   # 10  (0101 << 1 = 1010)
print(5 >> 1)   # 2   (0101 >> 1 = 0010)

# ========== 常用内置数学函数 ==========
print(abs(-42))           # 42
print(round(3.14159, 2))  # 3.14
print(pow(2, 10))         # 1024
print(divmod(10, 3))      # (3, 1)  商和余数
print(max(1, 5, 3))       # 5
print(min(1, 5, 3))       # 1
print(sum([1, 2, 3, 4]))  # 10

2.3 字符串操作

PYTHON
s = "Hello, Python!"

# ========== 基本操作 ==========
print(len(s))              # 14
print(s[0])                # 'H'(索引从0开始)
print(s[-1])               # '!'(负数从末尾开始)
print(s[0:5])              # 'Hello'(切片,不含索引5)
print(s[7:])               # 'Python!'
print(s[:5])               # 'Hello'
print(s[::2])              # 'Hlo yhn'(步长为2)
print(s[::-1])             # '!nohtyP ,olleH'(反转字符串)

# 字符串不可变
# s[0] = 'h'               # TypeError

# ========== 常用方法 ==========
print(s.upper())           # 'HELLO, PYTHON!'
print(s.lower())           # 'hello, python!'
print(s.capitalize())      # 'Hello, python!'
print(s.title())           # 'Hello, Python!'
print(s.swapcase())        # 'hELLO, pYTHON!'

# 查找
print(s.find("Python"))    # 7(返回索引,未找到返回-1)
print(s.index("Python"))   # 7(未找到抛出ValueError)
print(s.rfind("o"))        # 最后出现的位置
print(s.count("o"))        # 2

# 判断
print(s.startswith("He"))  # True
print(s.endswith("!"))     # True
print("Hello123".isalnum())  # True
print("123".isdigit())     # True
print("Hello".isalpha())   # True
print("  ".isspace())      # True

# 替换
print(s.replace("Python", "World"))  # 'Hello, World!'

# 分割与拼接
print(s.split(", "))       # ['Hello', 'Python!']
print(s.split("o"))        # ['Hell', ', Pyth', 'n!']
print("-".join(["a", "b", "c"]))  # 'a-b-c'

# 空白处理
print("  hello  ".strip())       # 'hello'
print("  hello  ".lstrip())      # 'hello  '
print("  hello  ".rstrip())      # '  hello'

# 填充
print("42".zfill(5))             # '00042'
print("42".rjust(5, "0"))        # '00042'
print("42".center(5, "-"))       # '-42--'

# ========== f-string格式化(3.6+)==========
name, age = "Alice", 25
print(f"我叫{name},今年{age}岁")
print(f"明年{age + 1}岁")
print(f"π = {3.1415926:.2f}")          # 保留2位小数
print(f"百分比: {0.857:.1%}")           # 百分比格式
print(f"{42:05d}")                       # 零填充: 00042
print(f"{'hello':>10}")                  # 右对齐10位
print(f"{'hello':<10}")                  # 左对齐10位
print(f"{'hello':^10}")                  # 居中对齐10位

# ========== 转义字符 ==========
print("Hello\nWorld")         # 换行
print("Hello\tWorld")         # 制表符
print("Hello \"World\"")      # 引号
print(r"C:\new\folder")       # 原始字符串(不转义)

# ========== bytes与字符串互转 ==========
b = "你好".encode("utf-8")
print(b)                      # b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(b.decode("utf-8"))      # '你好'

2.4 控制流

PYTHON
# ========== if/elif/else ==========
score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

# 三元运算符
status = "及格" if score >= 60 else "不及格"

# ========== for循环 ==========
# 遍历序列
for i in range(5):
    print(i, end=" ")        # 0 1 2 3 4

# range(start, stop, step)
for i in range(2, 10, 2):
    print(i, end=" ")        # 2 4 6 8

# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# 带索引遍历
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# 同时遍历多个序列
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name}: {age}")

# 遍历字典
person = {"name": "Alice", "age": 25, "city": "NYC"}
for key in person:
    print(key, person[key])
for key, value in person.items():
    print(f"{key}: {value}")

# ========== while循环 ==========
count = 0
while count < 3:
    print(count, end=" ")    # 0 1 2
    count += 1

# while True + break
while True:
    user_input = input("输入quit退出: ")
    if user_input == "quit":
        break

# ========== break/continue/pass ==========
for i in range(10):
    if i == 3:
        continue             # 跳过本次迭代
    if i == 7:
        break                # 退出循环
    print(i, end=" ")        # 0 1 2 4 5 6

# pass:占位符(什么都不做)
if True:
    pass                     # 语法上需要语句但逻辑上不需要

# ========== for/while else ==========
# else在循环正常结束(非break退出)时执行
for i in range(5):
    if i == 10:
        break
else:
    print("循环正常结束")    # 会执行(没有触发break)

for i in range(5):
    if i == 3:
        break
else:
    print("不会执行")        # 不会执行(被break退出)

# ========== match/case(3.10+)==========
def handle_status(code):
    match code:
        case 200:
            return "成功"
        case 404:
            return "未找到"
        case 500:
            return "服务器错误"
        case _:               # 默认匹配
            return "未知状态码"

2.5 函数定义

PYTHON
# ========== 基本函数 ==========
def greet(name):
    """返回问候语(docstring)"""
    return f"Hello, {name}!"

# ========== 参数类型 ==========
# 位置参数
def add(a, b):
    return a + b

# 默认参数(默认值只计算一次)
def create_user(name, role="user", active=True):
    return {"name": name, "role": role, "active": active}

print(create_user("Alice"))                    # 使用默认值
print(create_user("Bob", role="admin"))        # 按位置
print(create_user("Charlie", active=False))    # 混合

# 注意:默认参数陷阱
def bad_append(item, lst=[]):   # lst只在定义时创建一次
    lst.append(item)
    return lst

print(bad_append(1))  # [1]
print(bad_append(2))  # [1, 2]  ← 不是预期的[2]

# 正确的做法
def good_append(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

# 关键字参数
def describe(name, age, city="Unknown"):
    return f"{name}, {age}, {city}"

print(describe(name="Alice", age=25))
print(describe(age=30, name="Bob"))  # 关键字顺序可任意

# ========== *args:可变位置参数(元组)==========
def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3, 4, 5))  # 15

# ========== **kwargs:可变关键字参数(字典)==========
def build_config(**kwargs):
    return kwargs

print(build_config(host="localhost", port=8080, debug=True))
# {'host': 'localhost', 'port': 8080, 'debug': True}

# ========== 组合使用 ==========
def func(a, b, *args, c=10, **kwargs):
    print(f"a={a}, b={b}, args={args}, c={c}, kwargs={kwargs}")

func(1, 2, 3, 4, 5, c=20, x=100, y=200)
# a=1, b=2, args=(3,4,5), c=20, kwargs={'x':100,'y':200}

# ========== 参数转发 ==========
def wrapper(*args, **kwargs):
    return func(*args, **kwargs)

# ========== 类型注解(3.5+)==========
def typed_add(a: int, b: int) -> int:
    """类型注解仅作提示,运行时不强制"""
    return a + b

from typing import List, Dict, Optional, Union, Callable

def process(data: List[int], config: Dict[str, str]) -> Optional[int]:
    return data[0] if data else None

# ========== lambda 匿名函数 ==========
square = lambda x: x ** 2
print(square(5))             # 25

# 常用于排序、过滤等
pairs = [(1, "one"), (3, "three"), (2, "two")]
pairs.sort(key=lambda p: p[0])
print(pairs)  # [(1,'one'),(2,'two'),(3,'three')]

numbers = [1, 2, 3, 4, 5]
filtered = list(filter(lambda x: x % 2 == 0, numbers))
print(filtered)  # [2, 4]
mapped = list(map(lambda x: x * 2, numbers))
print(mapped)  # [2, 4, 6, 8, 10]

2.6 闭包与装饰器

PYTHON
# ========== 闭包 ==========
def make_multiplier(factor):
    """返回一个函数,该函数记住了外部变量factor"""
    def multiplier(x):
        return x * factor
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))   # 10
print(triple(5))   # 15

# ========== 装饰器:在不修改原函数的情况下增加功能 ==========
import time
import functools

# 定义装饰器
def timer(func):
    @functools.wraps(func)  # 保留原函数的元信息
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} 耗时: {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(0.5)
    return "完成"

print(slow_function())

# ========== 带参数的装饰器 ==========
def repeat(n):
    """将函数重复执行n次"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()  # 打印3次Hello!

# ========== 类装饰器 ==========
class CountCalls:
    def __init__(self, func):
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"调用次数: {self.count}")
        return self.func(*args, **kwargs)

@CountCalls
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))
print(greet("Bob"))

三、容器类型详解

3.1 列表(List)

PYTHON
# ========== 创建列表 ==========
empty = []
nums = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]
nested = [[1, 2], [3, 4], [5, 6]]

# 列表推导式
squares = [x ** 2 for x in range(10)]
evens = [x for x in range(20) if x % 2 == 0]
matrix = [[i * j for j in range(1, 4)] for i in range(1, 4)]

# ========== 增删改查 ==========
lst = [1, 2, 3]

# 添加
lst.append(4)           # 末尾添加: [1,2,3,4]
lst.extend([5, 6])      # 扩展: [1,2,3,4,5,6]
lst.insert(1, 99)       # 指定位置插入: [1,99,2,3,4,5,6]

# 删除
lst.remove(99)          # 删除第一个匹配值
popped = lst.pop()      # 删除并返回末尾元素
popped2 = lst.pop(0)    # 删除并返回索引0的元素
lst.clear()             # 清空

lst = [1, 2, 3, 4, 5]
del lst[2]              # 删除索引2: [1,2,4,5]
del lst[1:3]            # 删除切片: [1,5]

# 查找
print(lst.index(1))     # 索引(首次出现)
print(lst.count(1))     # 出现次数

# ========== 切片 ==========
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lst[2:5])         # [2, 3, 4]
print(lst[2:])          # [2, 3, 4, 5, 6, 7, 8, 9]
print(lst[:5])          # [0, 1, 2, 3, 4]
print(lst[::2])         # [0, 2, 4, 6, 8]
print(lst[::-1])        # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 切片赋值
lst[2:5] = [20, 30, 40]
print(lst)              # [0, 1, 20, 30, 40, 5, 6, 7, 8, 9]

# ========== 排序 ==========
unsorted = [3, 1, 4, 1, 5, 9, 2, 6]
unsorted.sort()                    # 原地排序
print(unsorted)                    # [1, 1, 2, 3, 4, 5, 6, 9]

unsorted.sort(reverse=True)        # 降序
unsorted.sort(key=lambda x: -x)    # 自定义排序

# sorted():返回新列表
sorted_list = sorted([3, 1, 4], reverse=True)

# 列表反转
lst = [1, 2, 3]
lst.reverse()           # 原地反转
print(lst[::-1])        # 切片反转(新列表)

# ========== 复制 ==========
original = [1, [2, 3], 4]
shallow = original.copy()           # 浅拷贝
deep = __import__("copy").deepcopy(original)  # 深拷贝

shallow[1][0] = 99
print(original)  # [1, [99, 3], 4]  ← 原始也被修改

# ========== 列表推导式进阶 ==========
# 带条件
result = [x for x in range(10) if x % 2 == 0]

# if-else表达式
result = [x if x % 2 == 0 else -x for x in range(5)]
# [0, -1, 2, -3, 4]

# 嵌套推导
flat = [item for sublist in [[1, 2], [3, 4]] for item in sublist]
# [1, 2, 3, 4]

# ========== any() / all() ==========
print(any([False, False, True]))  # True
print(all([True, True, True]))    # True
print(all([x > 0 for x in [1, 2, 3]]))  # True

3.2 元组(Tuple)

PYTHON
# ========== 创建元组(不可变序列)==========
t = (1, 2, 3)
t2 = 1, 2, 3                           # 括号可省略
t3 = (1,)                              # 单元素元组必须有逗号
not_tuple = (1)                        # 这是int,不是元组

# 空元组
empty = ()

# ========== 访问 ==========
t = (10, 20, 30, 40, 50)
print(t[0])      # 10
print(t[-1])     # 50
print(t[1:4])    # (20, 30, 40)

# 元组不可修改
# t[0] = 100     # TypeError

# ========== 解包 ==========
a, b, c = (1, 2, 3)
print(a, b, c)   # 1 2 3

# 使用 * 收集剩余元素
first, *middle, last = (1, 2, 3, 4, 5)
print(first)     # 1
print(middle)    # [2, 3, 4]
print(last)      # 5

# 函数返回多个值
def min_max(nums):
    return min(nums), max(nums)

mn, mx = min_max([3, 1, 4, 1, 5])

# ========== 命名元组(namedtuple)==========
from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(10, 20)
print(p.x, p.y)   # 10 20
print(p[0], p[1]) # 10 20

# 转字典
print(p._asdict())  # {'x': 10, 'y': 20}

3.3 字典(Dict)

PYTHON
# ========== 创建字典 ==========
d1 = {"name": "Alice", "age": 25}
d2 = dict(name="Bob", age=30)
d3 = dict([("name", "Charlie"), ("age", 35)])

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

# ========== 基本操作 ==========
d = {"a": 1, "b": 2, "c": 3}

# 访问
print(d["a"])           # 1(键不存在抛出KeyError)
print(d.get("d"))       # None(安全访问)
print(d.get("d", 0))    # 0(提供默认值)

# 添加/修改
d["d"] = 4
d.update({"e": 5, "f": 6})  # 批量更新

# 删除
del d["a"]
popped = d.pop("b")     # 删除并返回值
last = d.popitem()      # 删除并返回最后一个键值对(3.7+有序)
d.clear()

# 检查
d = {"a": 1, "b": 2}
print("a" in d)         # True
print("c" not in d)     # True

# ========== 遍历 ==========
d = {"name": "Alice", "age": 25, "city": "NYC"}

for key in d:
    print(key, d[key])

for key, value in d.items():
    print(f"{key}: {value}")

for key in d.keys():
    print(key)

for value in d.values():
    print(value)

# ========== 合并字典(3.9+)==========
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
merged = d1 | d2          # {'a': 1, 'b': 3, 'c': 4}
d1 |= d2                  # 原地合并

# ========== 默认字典(defaultdict)==========
from collections import defaultdict

# 访问不存在的键自动创建默认值
dd = defaultdict(list)
dd["users"].append("Alice")
dd["users"].append("Bob")
print(dd)  # {'users': ['Alice', 'Bob']}

# 计数器
word_count = defaultdict(int)
for word in ["a", "b", "a", "c", "b", "a"]:
    word_count[word] += 1
print(word_count)  # {'a': 3, 'b': 2, 'c': 1}

# ========== 有序字典(3.7+普通dict也是有序的)==========
from collections import OrderedDict

# 容量有限的字典
from collections import OrderedDict

class LRUCache(OrderedDict):
    def __init__(self, capacity):
        super().__init__()
        self.capacity = capacity
    
    def __setitem__(self, key, value):
        if key in self:
            self.move_to_end(key)
        super().__setitem__(key, value)
        if len(self) > self.capacity:
            self.popitem(last=False)

# ========== Counter:计数器 ==========
from collections import Counter

text = "hello world"
counter = Counter(text)
print(counter)           # Counter({'l': 3, 'o': 2, ...})
print(counter.most_common(2))  # [('l', 3), ('o', 2)]

# 计数器运算
c1 = Counter(["a", "b", "a"])
c2 = Counter(["a", "c", "c"])
print(c1 + c2)           # Counter({'a': 3, 'c': 2, 'b': 1})
print(c1 - c2)           # Counter({'b': 1, 'a': 0})

3.4 集合(Set)

PYTHON
# ========== 创建集合 ==========
s1 = {1, 2, 3, 4, 5}
s2 = set([1, 2, 2, 3, 3, 4])  # {1, 2, 3, 4} 自动去重

# 空集合必须用set()
empty = set()  # {}创建的是空字典

# 集合推导式
squares = {x ** 2 for x in range(10)}

# ========== 基本操作 ==========
s = {1, 2, 3}

# 添加/删除
s.add(4)
s.remove(2)        # 元素不存在抛KeyError
s.discard(3)       # 元素不存在不报错
popped = s.pop()   # 随机删除一个
s.clear()

# 成员检查(O(1))
s = {1, 2, 3}
print(1 in s)      # True

# ========== 集合运算 ==========
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 并集
print(a | b)             # {1, 2, 3, 4, 5, 6}
print(a.union(b))

# 交集
print(a & b)             # {3, 4}
print(a.intersection(b))

# 差集
print(a - b)             # {1, 2}
print(a.difference(b))

# 对称差集(并集减交集)
print(a ^ b)             # {1, 2, 5, 6}
print(a.symmetric_difference(b))

# 子集/超集
print({1, 2} <= {1, 2, 3})  # True(子集)
print({1, 2, 3} >= {2, 3})  # True(超集)

# 原地运算
a |= b       # 原地并集
a &= b       # 原地交集
a -= b       # 原地差集

# ========== frozenset:不可变集合 ==========
fs = frozenset([1, 2, 3])
# fs.add(4)   # AttributeError
# 可哈希,可作为字典键
d = {fs: "value"}  # 合法

3.5 迭代器与生成器

PYTHON
# ========== 迭代器 ==========
# 可迭代对象(Iterable):实现了 __iter__ 方法
# 迭代器(Iterator):实现了 __iter__ 和 __next__ 方法

nums = [1, 2, 3]
it = iter(nums)
print(next(it))  # 1
print(next(it))  # 2
print(next(it))  # 3
# print(next(it))  # StopIteration

# 自定义迭代器
class CountDown:
    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 n in CountDown(3):
    print(n, end=" ")  # 3 2 1

# ========== 生成器(Generator)==========
# 使用 yield 的函数
def fibonacci(n):
    """生成前n个斐波那契数"""
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(10):
    print(num, end=" ")  # 0 1 1 2 3 5 8 13 21 34

# 生成器表达式(类似列表推导式但惰性求值)
squares_gen = (x ** 2 for x in range(10))
print(next(squares_gen))  # 0
print(list(squares_gen))  # [1, 4, 9, 16, 25, 36, 49, 64, 81]

# 注意:生成器只能遍历一次
gen = (x for x in range(3))
print(list(gen))  # [0, 1, 2]
print(list(gen))  # [] ← 已耗尽

# ========== yield from ==========
def chain_generators(*iterables):
    for it in iterables:
        yield from it     # 委托给子生成器

chained = chain_generators([1, 2], [3, 4], [5, 6])
print(list(chained))  # [1, 2, 3, 4, 5, 6]

# ========== itertools 模块 ==========
import itertools

# 无限迭代
counter = itertools.count(10, 2)  # 10, 12, 14, ...
# cycle = itertools.cycle("ABC")  # A, B, C, A, B, C, ...

# 分组
groups = itertools.groupby("aaabbcddd")
for key, group in groups:
    print(key, list(group))

# 排列组合
print(list(itertools.permutations([1, 2, 3], 2)))  # 排列
print(list(itertools.combinations([1, 2, 3], 2)))  # 组合
print(list(itertools.product([1, 2], ["a", "b"]))) # 笛卡尔积

# 链式迭代
print(list(itertools.chain([1, 2], [3, 4])))  # [1, 2, 3, 4]

四、面向对象编程

4.1 类与对象

PYTHON
class Person:
    """人类(文档字符串)"""
    
    # 类变量(所有实例共享)
    species = "Homo Sapiens"
    count = 0
    
    def __init__(self, name, age):
        """构造方法"""
        self.name = name        # 实例变量
        self._age = age         # 约定:单下划线表示"受保护"
        self.__secret = "xxx"   # 名称改写:_Person__secret
        Person.count += 1
    
    # 实例方法:第一个参数自动传入self
    def greet(self):
        return f"Hello, I'm {self.name}!"
    
    # property 装饰器:将方法变为属性访问
    @property
    def age(self):
        """Getter"""
        return self._age
    
    @age.setter
    def age(self, value):
        """Setter"""
        if value < 0 or value > 150:
            raise ValueError("无效年龄")
        self._age = value
    
    @age.deleter
    def age(self):
        raise AttributeError("不能删除年龄")
    
    # 类方法:第一个参数传入类本身
    @classmethod
    def get_count(cls):
        return cls.count
    
    @classmethod
    def from_string(cls, data_str):
        """工厂方法"""
        name, age = data_str.split(",")
        return cls(name.strip(), int(age))
    
    # 静态方法:不需要访问实例或类
    @staticmethod
    def is_adult(age):
        return age >= 18
    
    # 特殊方法(魔术方法)
    def __str__(self):
        """str() 和 print()"""
        return f"Person({self.name}, {self._age})"
    
    def __repr__(self):
        """repr() 和调试输出"""
        return f"Person(name='{self.name}', age={self._age})"
    
    def __eq__(self, other):
        """== 运算符"""
        if not isinstance(other, Person):
            return NotImplemented
        return self.name == other.name and self._age == other._age
    
    def __lt__(self, other):
        """< 运算符"""
        return self._age < other._age

# 使用
p1 = Person("Alice", 25)
p2 = Person("Bob", 30)
p3 = Person.from_string("Charlie, 35")

print(p1.greet())               # "Hello, I'm Alice!"
print(p1.age)                   # 25(通过property访问)
p1.age = 26                     # 通过setter设置

print(str(p1))                  # "Person(Alice, 26)"
print(repr(p1))                 # "Person(name='Alice', age=26)"
print(p1 == p2)                 # False
print(Person.get_count())       # 3
print(Person.is_adult(20))      # True

4.2 继承与多态

PYTHON
# ========== 单继承 ==========
class Student(Person):
    """学生类:继承Person"""
    
    def __init__(self, name, age, student_id):
        super().__init__(name, age)  # 调用父类构造
        self.student_id = student_id
        self._grades = []
    
    # 重写父类方法
    def greet(self):
        return f"{super().greet()} Student ID: {self.student_id}"
    
    # 新增方法
    def add_grade(self, grade):
        if 0 <= grade <= 100:
            self._grades.append(grade)
    
    @property
    def average_grade(self):
        return sum(self._grades) / len(self._grades) if self._grades else 0

# ========== 多继承 ==========
class Logger:
    def log(self, message):
        print(f"[LOG] {message}")

class Authenticator:
    def authenticate(self, user, password):
        return user == "admin" and password == "secret"

class AdminUser(Logger, Authenticator):
    """多继承示例"""
    def __init__(self, name):
        self.name = name

admin = AdminUser("SystemAdmin")
admin.log("系统启动")              # 来自Logger
print(admin.authenticate("admin", "secret"))  # True

# MRO(方法解析顺序)
print(AdminUser.__mro__)
# AdminUser → Logger → Authenticator → object

# ========== abstractmethod:抽象类 ==========
from abc import ABC, abstractmethod

class Shape(ABC):
    """抽象基类:不能实例化"""
    
    @abstractmethod
    def area(self):
        """计算面积"""
        pass
    
    @abstractmethod
    def perimeter(self):
        """计算周长"""
        pass
    
    def describe(self):
        """具体方法"""
        return f"面积={self.area():.2f}, 周长={self.perimeter():.2f}"

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14159 * self.radius ** 2
    
    def perimeter(self):
        return 2 * 3.14159 * self.radius

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

# 多态:用统一接口处理不同类型
shapes = [Circle(5), Rectangle(4, 6), Circle(3)]
for shape in shapes:
    print(shape.describe())

# ========== 协议(Duck Typing)==========
# Python不靠继承检查,而靠"行为"检查
class Duck:
    def quack(self):
        return "Quack!"

class Dog:
    def quack(self):
        return "Woof!(假装是鸭子)"

def make_quack(animal):
    print(animal.quack())

make_quack(Duck())  # "Quack!"
make_quack(Dog())   # "Woof!(假装是鸭子)"

4.3 数据类与泛型

PYTHON
# ========== dataclass(3.7+)==========
from dataclasses import dataclass, field

@dataclass
class User:
    name: str
    age: int
    email: str = ""  # 默认值
    tags: list = field(default_factory=list)  # 可变默认值
    
    def is_adult(self):
        return self.age >= 18

user = User(name="Alice", age=25, email="alice@example.com")
print(user)  # User(name='Alice', age=25, email='alice@...', tags=[])

# 不可变数据类
@dataclass(frozen=True)
class Point:
    x: float
    y: float

p = Point(10, 20)
# p.x = 30  # FrozenInstanceError

# ========== 泛型(3.12+简化语法)==========
from typing import TypeVar, Generic

T = TypeVar("T")
K = TypeVar("K")
V = TypeVar("V")

class Stack(Generic[T]):
    def __init__(self):
        self._items: list[T] = []
    
    def push(self, item: T) -> None:
        self._items.append(item)
    
    def pop(self) -> T:
        return self._items.pop()
    
    def peek(self) -> T:
        return self._items[-1]
    
    def __len__(self) -> int:
        return len(self._items)

# 使用
int_stack = Stack[int]()
int_stack.push(1)
int_stack.push(2)
print(int_stack.pop())  # 2

str_stack = Stack[str]()
str_stack.push("hello")
print(str_stack.pop())  # "hello"

# ========== 枚举 ==========
from enum import Enum, auto

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

class Status(Enum):
    PENDING = auto()   # 自动赋值
    PROCESSING = auto()
    COMPLETED = auto()
    FAILED = auto()

print(Color.RED)           # Color.RED
print(Color.RED.value)     # 1
print(Color.RED.name)      # 'RED'
print(Color(2))            # Color.GREEN

五、错误处理

5.1 异常处理机制

PYTHON
# ========== try/except/else/finally ==========
def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("除数不能为零")
        return None
    except TypeError as e:
        print(f"类型错误: {e}")
        return None
    else:
        print("没有异常发生")  # try块成功执行后运行
        return result
    finally:
        print("总是执行")     # 无论是否异常都执行

# ========== 捕获多个异常 ==========
try:
    value = int(input("输入数字: "))
    result = 100 / value
except (ValueError, ZeroDivisionError) as e:
    print(f"输入错误: {e}")
except Exception as e:
    print(f"未知错误: {e}")

# 不使用变量
try:
    risky_operation()
except RuntimeError:
    print("运行时错误")

# ========== 自定义异常 ==========
class ValidationError(Exception):
    """验证错误"""
    def __init__(self, message, field=None):
        super().__init__(message)
        self.field = field
        self.message = message

class DatabaseError(Exception):
    """数据库错误"""
    def __init__(self, message, code=500):
        super().__init__(message)
        self.code = code

def validate_age(age):
    if not isinstance(age, int):
        raise ValidationError("年龄必须是整数", field="age")
    if age < 0:
        raise ValidationError("年龄不能为负数", field="age")
    if age > 150:
        raise ValidationError("年龄超出合理范围", field="age")
    return True

# ========== raise 与 异常链 ==========
try:
    validate_age(-5)
except ValidationError as e:
    raise RuntimeError("处理失败") from e  # 异常链

# ========== assert 断言 ==========
def calculate_average(numbers):
    assert len(numbers) > 0, "列表不能为空"
    return sum(numbers) / len(numbers)

# assert 可通过 -O 标志禁用
# python -O script.py

5.2 上下文管理器

PYTHON
# ========== with 语句 ==========
# 自动管理资源的获取和释放

# 文件操作(文件自动关闭)
with open("file.txt", "r") as f:
    content = f.read()

# 等价于:
f = open("file.txt", "r")
try:
    content = f.read()
finally:
    f.close()

# ========== 自定义上下文管理器(类方式)==========
class Timer:
    def __enter__(self):
        self.start = __import__("time").time()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        elapsed = __import__("time").time() - self.start
        print(f"耗时: {elapsed:.4f}s")
        return False  # False:不抑制异常

with Timer():
    # 耗时操作
    __import__("time").sleep(0.5)

# ========== contextlib 工具 ==========
from contextlib import contextmanager

@contextmanager
def managed_file(filename, mode="r"):
    """生成器方式的上下文管理器"""
    f = open(filename, mode)
    try:
        yield f
    finally:
        f.close()

with managed_file("file.txt", "r") as f:
    content = f.read()

# 抑制特定异常
from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove("nonexistent.txt")

# 重定向输出
from contextlib import redirect_stdout
import io

f = io.StringIO()
with redirect_stdout(f):
    print("Hello")
    print("World")
print(f.getvalue())  # "Hello\nWorld\n"

六、文件I/O与序列化

6.1 文件操作

PYTHON
# ========== 打开文件 ==========
# 模式:r(读), w(写), a(追加), x(创建), b(二进制), t(文本,默认), +(读写)

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

# 逐行读取
with open("file.txt", "r") as f:
    for line in f:
        print(line.strip())

# readline:读一行
with open("file.txt", "r") as f:
    while line := f.readline():
        print(line.strip())

# readlines:读取所有行到列表
with open("file.txt", "r") as f:
    lines = f.readlines()

# ========== 写入文件 ==========
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Hello, World!\n")
    f.writelines(["Line 1\n", "Line 2\n", "Line 3\n"])

# 追加模式
with open("output.txt", "a") as f:
    f.write("追加的内容\n")

# ========== 文件指针操作 ==========
with open("file.txt", "rb") as f:
    f.seek(0, 2)        # 移到末尾(0=开头,1=当前,2=末尾)
    print(f.tell())     # 当前指针位置

# ========== pathlib(推荐替代os.path)==========
from pathlib import Path

p = Path("/home/user/docs/report.pdf")

print(p.name)           # "report.pdf"
print(p.stem)           # "report"
print(p.suffix)         # ".pdf"
print(p.parent)         # "/home/user/docs"
print(p.parts)           # ('/', 'home', 'user', 'docs', 'report.pdf')
print(p.exists())       # 文件是否存在

# 路径拼接
base = Path("/home/user")
full_path = base / "docs" / "file.txt"
print(full_path)        # "/home/user/docs/file.txt"

# 读取和写入(简化接口)
content = Path("file.txt").read_text(encoding="utf-8")
Path("output.txt").write_text("Hello!", encoding="utf-8")

# 遍历目录
for file in Path(".").glob("*.py"):
    print(file)

for file in Path(".").rglob("*.py"):  # 递归
    print(file)

# 创建目录
Path("new_dir/subdir").mkdir(parents=True, exist_ok=True)

# 获取文件大小和时间
from datetime import datetime
stat = p.stat()
print(f"大小: {stat.st_size} 字节")
print(f"修改时间: {datetime.fromtimestamp(stat.st_mtime)}")

6.2 JSON 处理

PYTHON
import json

# ========== 序列化 ==========
# dict → JSON字符串
data = {
    "name": "Alice",
    "age": 25,
    "skills": ["Python", "JavaScript"],
    "active": True,
    "address": None
}

json_str = json.dumps(data)
print(json_str)

# 带缩进
pretty = json.dumps(data, indent=2, ensure_ascii=False)
print(pretty)

# 写入文件
with open("data.json", "w") as f:
    json.dump(data, f, indent=2)

# ========== 反序列化 ==========
# JSON字符串 → dict
parsed = json.loads(json_str)
print(parsed["name"])

# 从文件读取
with open("data.json", "r") as f:
    loaded = json.load(f)

# ========== 自定义编码 ==========
from datetime import datetime

class DateTimeEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        return super().default(obj)

data = {"created_at": datetime.now()}
json_str = json.dumps(data, cls=DateTimeEncoder)
print(json_str)

# ========== 自定义解码 ==========
def datetime_decoder(dct):
    if "created_at" in dct:
        dct["created_at"] = datetime.fromisoformat(dct["created_at"])
    return dct

parsed = json.loads(json_str, object_hook=datetime_decoder)
print(type(parsed["created_at"]))  # <class 'datetime.datetime'>

6.3 CSV与数据序列化

PYTHON
import csv
import pickle

# ========== CSV 读取 ==========
with open("data.csv", "r", newline="") as f:
    reader = csv.reader(f)
    header = next(reader)  # 跳过标题行
    for row in reader:
        print(row)

# 以字典形式读取
with open("data.csv", "r", newline="") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['name']}: {row['age']}")

# ========== CSV 写入 ==========
data = [
    ["name", "age", "city"],
    ["Alice", "25", "NYC"],
    ["Bob", "30", "LA"],
]

with open("output.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerows(data)

# 字典形式写入
with open("output.csv", "w", newline="") as f:
    fields = ["name", "age", "city"]
    writer = csv.DictWriter(f, fieldnames=fields)
    writer.writeheader()
    writer.writerow({"name": "Alice", "age": 25, "city": "NYC"})

# ========== pickle:Python对象序列化 ==========
# 注意:仅用于Python之间,不安全(不加载不可信数据)
data = {"users": [{"name": "Alice", "age": 25}], "config": {"debug": True}}

# 序列化
with open("data.pkl", "wb") as f:
    pickle.dump(data, f)

# 反序列化
with open("data.pkl", "rb") as f:
    loaded = pickle.load(f)

# ========== YAML(需安装PyYAML)==========
# import yaml
# with open("config.yaml", "r") as f:
#     config = yaml.safe_load(f)

七、并发编程

7.1 多线程(threading)

PYTHON
import threading
import time

# ========== 创建线程 ==========
def worker(name, delay):
    """工作函数"""
    for i in range(3):
        time.sleep(delay)
        print(f"{name}: 第{i+1}次")

# 方式1:直接创建
t1 = threading.Thread(target=worker, args=("Thread-1", 0.5))
t2 = threading.Thread(target=worker, args=("Thread-2", 0.3))

t1.start()
t2.start()

t1.join()  # 等待线程结束
t2.join()
print("所有线程完成")

# 方式2:继承Thread类
class MyThread(threading.Thread):
    def __init__(self, name, delay):
        super().__init__()
        self.name = name
        self.delay = delay

    def run(self):
        worker(self.name, self.delay)

t3 = MyThread("MyThread-1", 0.5)
t3.start()
t3.join()

# ========== 线程同步 ==========
# Lock:互斥锁
counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:  # 自动获取和释放
            counter += 1

threads = [threading.Thread(target=increment) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(f"Counter: {counter}")  # 1000000

# RLock:可重入锁(同一线程可多次获取)
rlock = threading.RLock()

# Semaphore:信号量(限制同时访问资源的线程数)
semaphore = threading.Semaphore(3)  # 最多3个线程

def limited_access(name):
    with semaphore:
        print(f"{name} 获得访问权限")
        time.sleep(1)
        print(f"{name} 释放访问权限")

# Event:事件(线程间通信)
event = threading.Event()

def waiter():
    print("等待事件...")
    event.wait()            # 阻塞直到事件被设置
    print("事件已触发!")

def setter():
    time.sleep(1)
    print("设置事件")
    event.set()            # 触发事件

threading.Thread(target=waiter).start()
threading.Thread(target=setter).start()

# Condition:条件变量
condition = threading.Condition()
items = []

def producer():
    with condition:
        items.append("item")
        print("生产了一个item")
        condition.notify()  # 唤醒一个等待者

def consumer():
    with condition:
        while not items:
            condition.wait()  # 等待通知
        item = items.pop()
        print(f"消费了: {item}")

# ========== 线程池(concurrent.futures)==========
from concurrent.futures import ThreadPoolExecutor, as_completed

def task(n):
    time.sleep(0.5)
    return n * n

with ThreadPoolExecutor(max_workers=4) as executor:
    # 提交单个任务
    future = executor.submit(task, 5)
    print(f"结果: {future.result()}")
    
    # 批量提交
    futures = [executor.submit(task, i) for i in range(10)]
    for future in as_completed(futures):
        print(f"完成: {future.result()}")
    
    # map 方式
    results = executor.map(task, range(10))
    print(list(results))

7.2 多进程(multiprocessing)

PYTHON
import multiprocessing
import os
import time

# ========== 创建进程 ==========
def worker(name):
    print(f"{name} 进程号: {os.getpid()}")
    time.sleep(1)
    return f"{name} 完成"

if __name__ == "__main__":
    # 创建进程
    p = multiprocessing.Process(target=worker, args=("Process-1",))
    p.start()
    p.join()

    # ========== 进程池 ==========
    with multiprocessing.Pool(processes=4) as pool:
        # apply:阻塞
        result = pool.apply(worker, ("Task",))
        print(result)
        
        # apply_async:异步
        result = pool.apply_async(worker, ("AsyncTask",))
        print(result.get(timeout=5))
        
        # map:并行map
        results = pool.map(worker, [f"Task-{i}" for i in range(4)])
        print(results)
        
        # starmap:传递多个参数
        def add(a, b):
            return a + b
        
        results = pool.starmap(add, [(1, 2), (3, 4), (5, 6)])
        print(results)  # [3, 7, 11]

    # ========== 进程间通信 ==========
    # Queue
    q = multiprocessing.Queue()
    
    def producer(q):
        for i in range(5):
            q.put(i)
        q.put(None)  # 终止信号
    
    def consumer(q):
        while True:
            item = q.get()
            if item is None:
                break
            print(f"消费: {item}")
    
    p1 = multiprocessing.Process(target=producer, args=(q,))
    p2 = multiprocessing.Process(target=consumer, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

    # Pipe
    parent_conn, child_conn = multiprocessing.Pipe()
    
    # Manager:共享状态
    with multiprocessing.Manager() as manager:
        shared_list = manager.list()
        shared_dict = manager.dict()

7.3 异步编程(asyncio)

PYTHON
import asyncio
import time

# ========== 协程基础 ==========
# async def 定义协程
async def say_hello(name, delay):
    await asyncio.sleep(delay)  # 异步睡眠(不阻塞事件循环)
    print(f"Hello, {name}!")
    return f"{name} done"

# 运行协程
async def main():
    # 串行运行
    result1 = await say_hello("Alice", 0.5)
    result2 = await say_hello("Bob", 0.5)
    print(f"串行结果: {result1}, {result2}")

    # 并行运行
    results = await asyncio.gather(
        say_hello("Charlie", 0.3),
        say_hello("David", 0.5),
        say_hello("Eve", 0.2),
    )
    print(f"并行结果: {results}")

    # create_task(不等待)
    task = asyncio.create_task(say_hello("Frank", 0.5))
    # 做其他事情...
    result = await task
    print(f"任务结果: {result}")

    # ========== asyncio.wait ==========
    # 等待最先完成的
    tasks = [
        asyncio.create_task(say_hello(f"Task-{i}", i * 0.2))
        for i in range(1, 5)
    ]
    done, pending = await asyncio.wait(
        tasks, return_when=asyncio.FIRST_COMPLETED
    )
    print("最先完成:", [t.result() for t in done])

# Python 3.7+可直接运行
asyncio.run(main())

# ========== 异步上下文管理器 ==========
class AsyncResource:
    async def __aenter__(self):
        print("获取资源")
        await asyncio.sleep(0.1)
        return self
    
    async def __aexit__(self, *args):
        print("释放资源")
        await asyncio.sleep(0.1)

async def use_resource():
    async with AsyncResource() as r:
        print("使用资源中...")
        await asyncio.sleep(0.5)

# ========== 异步迭代器 ==========
class AsyncCounter:
    def __init__(self, start, end):
        self.start = start
        self.end = end
    
    def __aiter__(self):
        return self
    
    async def __anext__(self):
        if self.start >= self.end:
            raise StopAsyncIteration
        await asyncio.sleep(0.1)
        self.start += 1
        return self.start - 1

async def iterate_async():
    async for num in AsyncCounter(1, 5):
        print(num, end=" ")

八、标准库详解

8.1 os, sys, shutil:系统操作

函数 说明
os.getcwd() 当前工作目录
os.chdir(path) 切换目录
os.listdir(path) 列出目录内容
os.mkdir(path) 创建单层目录
os.makedirs(path) 递归创建目录
os.remove(path) 删除文件
os.rmdir(path) 删除空目录
os.removedirs(path) 递归删除空目录
os.rename(src, dst) 重命名/移动
os.environ 环境变量字典
os.path.join(a, b) 路径拼接
os.path.exists(path) 路径是否存在
os.path.isfile/islink/isdir 路径类型判断
os.path.abspath(path) 绝对路径
os.path.basename/dirname 路径解析
os.path.splitext(path) 分割文件名和扩展名
shutil.copy(src, dst) 复制文件
shutil.copytree(src, dst) 递归复制
shutil.rmtree(path) 递归删除
shutil.move(src, dst) 移动文件/目录
shutil.disk_usage(path) 磁盘使用情况
sys.argv 命令行参数列表
sys.exit(code) 退出程序
sys.platform 平台标识
sys.version Python版本
sys.path 模块搜索路径
sys.stdin/stdout/stderr 标准I/O流

8.2 datetime, time:时间处理

PYTHON
from datetime import datetime, date, time, timedelta
import time as time_module

# ========== 当前时间 ==========
now = datetime.now()
today = date.today()
print(now)       # 2024-06-15 14:30:00.123456
print(today)     # 2024-06-15

# ========== 创建时间对象 ==========
dt = datetime(2024, 6, 15, 14, 30, 0)
d = date(2024, 6, 15)
t = time(14, 30, 0)

# ========== 时间运算 ==========
# timedelta:时间差
delta = timedelta(days=7, hours=2, minutes=30)
future = now + delta
past = now - timedelta(days=30)
diff = future - past       # timedelta对象
print(diff.days)           # 天数

# ========== 格式化 ==========
# strftime:时间对象 → 字符串
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # "2024-06-15 14:30:00"
print(now.strftime("%Y年%m月%d日"))

# strptime:字符串 → 时间对象
parsed = datetime.strptime("2024-06-15", "%Y-%m-%d")
print(parsed)

# ISO格式
print(now.isoformat())     # "2024-06-15T14:30:00.123456"
print(datetime.fromisoformat("2024-06-15T14:30:00"))

# ========== 时间戳 ==========
timestamp = now.timestamp()  # float 秒
print(timestamp)
from_timestamp = datetime.fromtimestamp(timestamp)
print(from_timestamp)

# 毫秒时间戳
ms_timestamp = int(now.timestamp() * 1000)

# ========== 时区处理(3.9+)==========
from zoneinfo import ZoneInfo

shanghai = now.astimezone(ZoneInfo("Asia/Shanghai"))
utc = now.astimezone(ZoneInfo("UTC"))
print(shanghai, utc)

# ========== time 模块 ==========
print(time_module.time())    # 当前时间戳
time_module.sleep(1)         # 暂停1秒

8.3 re:正则表达式

PYTHON
import re

text = "The quick brown fox jumps over 42 lazy dogs."

# ========== 常用函数 ==========
# search:搜索第一个匹配
match = re.search(r"\d+", text)
print(match.group())  # "42"

# match:从开头匹配
print(re.match(r"The", text))  # 匹配成功

# findall:查找所有匹配
print(re.findall(r"\w+", text))

# finditer:返回迭代器
for m in re.finditer(r"\b\w{4}\b", text):
    print(m.group())  # 4字母的单词

# sub:替换
print(re.sub(r"\d+", "数字", text))

# split:分割
print(re.split(r"\s+", text))

# ========== 编译正则(重复使用时更高效)==========
pattern = re.compile(r"\b(\w+)@(\w+\.\w+)\b")
match = pattern.search("Contact: alice@example.com")
if match:
    print(f"用户名: {match.group(1)}")     # alice
    print(f"域名: {match.group(2)}")       # example.com
    print(f"完整匹配: {match.group(0)}")   # alice@example.com

# ========== 常用模式 ==========
# .    匹配任意字符(除换行)
# \d   数字 [0-9]
# \w   字母数字下划线 [a-zA-Z0-9_]
# \s   空白字符
# *    0次或多次
# +    1次或多次
# ?    0次或1次
# {n}  恰好n次
# {n,} 至少n次
# {n,m} n到m次
# ^    开头
# $    结尾
# \b   单词边界
# ()   捕获组
# (?:) 非捕获组
# (?P<name>) 命名捕获组

# ========== 标志 ==========
# re.I  忽略大小写
# re.M  多行模式(^$ 匹配行首尾)
# re.S  . 匹配换行
# re.X  详细模式(可写注释)

# 例子:提取日期
date_pattern = re.compile(
    r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})"
)
match = date_pattern.search("Date: 2024-06-15")
if match:
    print(match.groupdict())  # {'year':'2024','month':'06','day':'15'}

8.4 collections:高级容器

PYTHON
from collections import (
    Counter, defaultdict, OrderedDict,
    deque, namedtuple, ChainMap
)

# Counter(已在3.3节介绍)- 统计频次
# defaultdict(已在3.3节介绍)- 带默认值的字典

# ========== deque:双端队列 ==========
dq = deque([1, 2, 3])
dq.append(4)            # 右侧添加
dq.appendleft(0)        # 左侧添加
dq.pop()                # 右侧弹出
dq.popleft()            # 左侧弹出
dq.rotate(1)            # 向右旋转1位
print(dq)               # deque([3, 1, 2, 4])
dq.rotate(-1)           # 向左旋转1位

# 限制最大长度
limited = deque(maxlen=3)
limited.extend([1, 2, 3, 4, 5])
print(limited)          # deque([3, 4, 5], maxlen=3)

# ========== ChainMap:链式字典查找 ==========
defaults = {"theme": "light", "language": "en"}
user_settings = {"language": "zh"}
runtime = {"debug": True}

settings = ChainMap(runtime, user_settings, defaults)
print(settings["language"])   # "zh"(优先user_settings)
print(settings["theme"])      # "light"(fallback到defaults)

# 修改只影响第一个映射
settings["theme"] = "dark"    # 修改runtime
print(runtime)  # {"debug": True, "theme": "dark"}

8.5 random:随机数

PYTHON
import random

# 设置种子(可重现)
random.seed(42)

# 浮点随机数
print(random.random())          # [0.0, 1.0)
print(random.uniform(1, 10))    # [1.0, 10.0]

# 整数随机数
print(random.randint(1, 100))   # [1, 100]
print(random.randrange(0, 10, 2))  # 0, 2, 4, 6, 8

# 序列操作
items = [1, 2, 3, 4, 5]
print(random.choice(items))     # 随机选择
print(random.sample(items, 3))  # 随机3个(不重复)
random.shuffle(items)           # 原地打乱
print(items)

# 加权随机
choices = random.choices(
    ["A", "B", "C"],
    weights=[0.5, 0.3, 0.2],
    k=10
)
print(choices)

# ========== secrets:加密安全的随机数 ==========
import secrets

token = secrets.token_hex(16)   # 32字符十六进制
url_safe = secrets.token_urlsafe(16)
print(token, url_safe)

8.6 functools:函数工具

PYTHON
from functools import lru_cache, partial, reduce, wraps

# ========== lru_cache:缓存函数结果 ==========
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(100))  # 计算极快(结果被缓存)
print(fibonacci.cache_info())  # 缓存信息

# ========== partial:部分应用参数 ==========
def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
cube = partial(power, exponent=3)
print(square(5))  # 25
print(cube(5))    # 125

# ========== reduce:累积计算 ==========
from functools import reduce

numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 120

# 带初始值
total = reduce(lambda x, y: x + y, numbers, 100)
print(total)    # 115

8.7 subprocess:进程管理

PYTHON
import subprocess

# ========== run:运行命令并等待完成 ==========
# 基本用法
result = subprocess.run(["ls", "-la"], capture_output=True, text=True)
print("返回码:", result.returncode)
print("输出:", result.stdout)
print("错误:", result.stderr)

# 检查返回码(非0抛出异常)
try:
    result = subprocess.run(["ls", "nonexistent"], check=True, capture_output=True, text=True)
except subprocess.CalledProcessError as e:
    print(f"命令失败: {e}")

# 设置超时
try:
    result = subprocess.run(["sleep", "10"], timeout=2)
except subprocess.TimeoutExpired:
    print("命令超时")

# 传递输入
result = subprocess.run(
    ["python3", "-c", "print(input().upper())"],
    input="hello",
    capture_output=True,
    text=True,
)
print(result.stdout.strip())  # "HELLO"

# ========== Popen:高级进程管理 ==========
# 逐行读取输出
process = subprocess.Popen(
    ["ping", "-c", "3", "localhost"],
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    text=True
)

for line in process.stdout:
    print(line.strip())

return_code = process.wait()
print(f"退出码: {return_code}")

# Shell管道
result = subprocess.run(
    "cat file.txt | sort | uniq",
    shell=True,
    capture_output=True,
    text=True
)

九、网络编程

9.1 urllib 与 requests

PYTHON
# ========== 内置 urllib ==========
from urllib.request import urlopen, Request
from urllib.parse import urlencode, quote

# GET请求
with urlopen("https://jsonplaceholder.typicode.com/posts/1") as response:
    data = json.loads(response.read())
    print(data["title"])

# POST请求
data = urlencode({"key": "value"}).encode()
req = Request("https://httpbin.org/post", data=data, method="POST")
with urlopen(req) as response:
    print(response.read().decode())

# ========== requests(推荐第三方库)==========
# pip install requests

import requests

# GET
resp = requests.get(
    "https://jsonplaceholder.typicode.com/posts/1",
    params={"userId": 1}
)
print(resp.status_code)    # 200
print(resp.json()["title"])  # 自动解析JSON

# POST(JSON)
resp = requests.post(
    "https://jsonplaceholder.typicode.com/posts",
    json={"title": "Test", "body": "Content", "userId": 1}
)
print(resp.json())

# POST(表单)
resp = requests.post(
    "https://httpbin.org/post",
    data={"username": "admin", "password": "secret"}
)

# 请求头
resp = requests.get(
    "https://api.example.com",
    headers={
        "Authorization": "Bearer token123",
        "User-Agent": "MyApp/1.0",
    }
)

# 会话(保持Cookie)
session = requests.Session()
session.headers.update({"User-Agent": "MyApp/1.0"})
session.get("https://httpbin.org/cookies/set?name=value")
resp = session.get("https://httpbin.org/cookies")

# 超时
try:
    resp = requests.get("https://httpbin.org/delay/10", timeout=3)
except requests.Timeout:
    print("请求超时")

# 文件上传
with open("file.txt", "rb") as f:
    resp = requests.post(
        "https://httpbin.org/post",
        files={"file": f}
    )

# 下载
resp = requests.get("https://example.com/file.pdf", stream=True)
with open("download.pdf", "wb") as f:
    for chunk in resp.iter_content(chunk_size=8192):
        f.write(chunk)

9.2 Socket 编程

PYTHON
import socket

# ========== TCP 服务器 ==========
def tcp_server():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.bind(("localhost", 8000))
    server.listen(5)
    print("TCP服务器监听 8000 端口")

    while True:
        client, addr = server.accept()
        print(f"连接来自: {addr}")

        data = client.recv(1024)
        print(f"收到: {data.decode()}")

        client.send(b"HTTP/1.1 200 OK\r\n\r\nHello, World!")
        client.close()

# ========== TCP 客户端 ==========
def tcp_client():
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect(("localhost", 8000))
    client.send(b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")

    response = client.recv(4096)
    print(f"响应: {response.decode()}")
    client.close()

# ========== UDP 通信 ==========
def udp_example():
    # 服务端
    server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    server.bind(("localhost", 9000))

    data, addr = server.recvfrom(1024)
    print(f"收到UDP消息: {data.decode()} 来自 {addr}")
    server.sendto(b"ACK", addr)
    server.close()

    # 客户端
    client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    client.sendto(b"Hello UDP!", ("localhost", 9000))
    data, addr = client.recvfrom(1024)
    print(f"收到响应: {data.decode()}")
    client.close()

十、数据库操作

10.1 SQLite(内置)

PYTHON
import sqlite3

# ========== 连接与游标 ==========
conn = sqlite3.connect("example.db")
cursor = conn.cursor()

# ========== 创建表 ==========
cursor.execute("""
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        age INTEGER,
        email TEXT UNIQUE
    )
""")

# ========== 插入 ==========
# 参数化查询(防SQL注入)
cursor.execute(
    "INSERT INTO users (name, age, email) VALUES (?, ?, ?)",
    ("Alice", 25, "alice@example.com")
)

# 批量插入
users = [
    ("Bob", 30, "bob@example.com"),
    ("Charlie", 35, "charlie@example.com"),
]
cursor.executemany(
    "INSERT INTO users (name, age, email) VALUES (?, ?, ?)",
    users
)
conn.commit()

# 获取自增ID
last_id = cursor.lastrowid
print(f"最后插入ID: {last_id}")

# ========== 查询 ==========
# 单条查询
cursor.execute("SELECT * FROM users WHERE name = ?", ("Alice",))
user = cursor.fetchone()
print(user)  # (1, 'Alice', 25, 'alice@example.com')

# 多条查询
cursor.execute("SELECT id, name, age FROM users WHERE age > ?", (20,))
for row in cursor.fetchall():
    print(f"ID:{row[0]}, Name:{row[1]}, Age:{row[2]}")

# dict格式
conn.row_factory = sqlite3.Row
cursor = conn.cursor()
cursor.execute("SELECT * FROM users LIMIT 1")
row = cursor.fetchone()
print(f"姓名: {row['name']}")

# ========== 更新/删除 ==========
cursor.execute(
    "UPDATE users SET age = ? WHERE name = ?",
    (26, "Alice")
)
cursor.execute("DELETE FROM users WHERE id = ?", (3,))
conn.commit()

# ========== 事务 ==========
# connect() 默认开启事务
# commit() 提交事务
# rollback() 回滚
try:
    cursor.execute("INSERT INTO users VALUES (?, ?, ?)", (4, "Dave", 40, "dave@example.com"))
    cursor.execute("INSERT INTO users VALUES (?, ?, ?)", (4, "Eve", 45, "eve@example.com"))  # 主键冲突
    conn.commit()
except sqlite3.IntegrityError:
    conn.rollback()
    print("事务回滚")

# 使用 context manager(自动提交/回滚)
with conn:
    conn.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Frank", 50))

conn.close()

10.2 其他数据库

PYTHON
# ========== MySQL / MariaDB ==========
# pip install mysql-connector-python
import mysql.connector

conn = mysql.connector.connect(
    host="localhost",
    port=3306,
    user="root",
    password="password",
    database="testdb"
)
# API 与 sqlite3 类似

# ========== PostgreSQL ==========
# pip install psycopg2-binary
import psycopg2

conn = psycopg2.connect(
    host="localhost",
    port=5432,
    dbname="testdb",
    user="postgres",
    password="password"
)

# ========== SQLAlchemy(ORM)==========
# pip install sqlalchemy
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import Session, DeclarativeBase

class Base(DeclarativeBase):
    pass

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    age = Column(Integer)

engine = create_engine("sqlite:///users.db")
Base.metadata.create_all(engine)

with Session(engine) as session:
    user = User(name="Alice", age=25)
    session.add(user)
    session.commit()
    
    users = session.query(User).filter(User.age > 20).all()

十一、测试

11.1 unittest(内置)

PYTHON
import unittest

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

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为零")
    return a / b

class TestMath(unittest.TestCase):
    """测试类:继承 unittest.TestCase"""
    
    # setUp 和 tearDown 在每个测试前后执行
    def setUp(self):
        self.data = [1, 2, 3, 4, 5]
    
    def tearDown(self):
        pass
    
    # 测试方法必须以 test_ 开头
    def test_add(self):
        self.assertEqual(add(2, 3), 5)
        self.assertEqual(add(-1, 1), 0)
        self.assertNotEqual(add(2, 2), 5)
    
    def test_divide(self):
        self.assertAlmostEqual(divide(10, 3), 3.333, places=2)
    
    def test_divide_by_zero(self):
        with self.assertRaises(ValueError):
            divide(10, 0)
    
    def test_divide_type_error(self):
        with self.assertRaises(TypeError):
            divide("10", 2)
    
    # 跳过测试
    @unittest.skip("暂时跳过")
    def test_skip(self):
        pass
    
    @unittest.skipIf(True, "条件跳过")
    def test_conditional_skip(self):
        pass

if __name__ == "__main__":
    unittest.main()

11.2 pytest(推荐第三方库)

PYTHON
# pip install pytest
# 不需要继承类,函数名以 test_ 开头即可

import pytest

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

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

def test_add_with_negative():
    assert add(-5, -3) == -8

# 参数化测试
@pytest.mark.parametrize("a,b,expected", [
    (2, 3, 5),
    (0, 0, 0),
    (-1, 1, 0),
    (100, 200, 300),
])
def test_add_parametrized(a, b, expected):
    assert add(a, b) == expected

# 异常测试
def test_divide_by_zero():
    with pytest.raises(ValueError, match="除数不能为零"):
        divide(10, 0)

# Fixture
@pytest.fixture
def sample_data():
    """提供测试数据"""
    return {"name": "Alice", "age": 25}

def test_with_fixture(sample_data):
    assert sample_data["name"] == "Alice"
    assert sample_data["age"] == 25

# Mock
from unittest.mock import Mock, patch

def test_with_mock():
    mock_fn = Mock(return_value=42)
    assert mock_fn(1, 2, key="val") == 42
    mock_fn.assert_called_once_with(1, 2, key="val")
BASH
# 运行测试
python3 -m pytest                    # 发现并运行所有测试
python3 -m pytest -v                 # 详细输出
python3 -m pytest -k "test_add"      # 运行名称匹配的测试
python3 -m pytest --cov=.            # 覆盖率(需安装pytest-cov)
python3 -m pytest -x                 # 首次失败后停止
python3 -m pytest --lf               # 只运行上次失败的测试

十二、常用第三方库

12.1 Flask:轻量Web框架

PYTHON
# pip install flask
from flask import Flask, request, jsonify, render_template

app = Flask(__name__)

@app.route("/")
def home():
    return "<h1>Welcome to Flask!</h1>"

@app.route("/api/users", methods=["GET"])
def get_users():
    return jsonify({"users": [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]})

@app.route("/api/users/<int:user_id>")
def get_user(user_id):
    return jsonify({"id": user_id, "name": f"User{user_id}"})

@app.route("/api/users", methods=["POST"])
def create_user():
    data = request.get_json()
    return jsonify({"id": 1, **data}), 201

if __name__ == "__main__":
    app.run(debug=True, port=5000)

12.2 FastAPI:现代异步框架

PYTHON
# pip install fastapi uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class UserCreate(BaseModel):
    name: str
    age: int
    email: str | None = None

@app.get("/")
async def root():
    return {"message": "Hello FastAPI"}

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    return {"user_id": user_id}

@app.post("/users")
async def create_user(user: UserCreate):
    return {"id": 1, **user.model_dump()}

# 启动:uvicorn main:app --reload

12.3 NumPy与Pandas

PYTHON
import numpy as np
import pandas as pd

# ========== NumPy ==========
arr = np.array([1, 2, 3, 4, 5])
print(arr * 2)         # [2, 4, 6, 8, 10]
print(arr.mean())      # 3.0

matrix = np.array([[1, 2, 3], [4, 5, 6]])
print(matrix.shape)    # (2, 3)

zeros = np.zeros((3, 4))
ones = np.ones((2, 3))
rand = np.random.randn(5, 3)

# ========== Pandas ==========
df = pd.DataFrame({
    "name": ["Alice", "Bob", "Charlie"],
    "age": [25, 30, 35],
    "city": ["NYC", "LA", "SF"]
})

print(df.head())
print(df.describe())
print(df[df["age"] > 25])

df_csv = pd.read_csv("data.csv")
df_csv.to_csv("output.csv", index=False)

十三、最佳实践

13.1 代码规范(PEP 8)

PYTHON
# ========== 命名规范 ==========
# 变量/函数:snake_case
user_name = "Alice"
def get_user_by_id(id): pass

# 类:PascalCase
class UserService: pass

# 常量:UPPER_SNAKE_CASE
MAX_RETRY = 3
API_BASE_URL = "https://api.example.com"

# 私有:单下划线前缀(约定)
class MyClass:
    _private_var = 42
    def _private_method(self): pass

# 特殊变量:双下划线(dunder)
# __init__, __str__, __repr__

# ========== 函数设计 ==========
# 单一职责
# 参数不超过5个
# 使用类型注解
def process_items(items: list[int], limit: int = 100) -> list[int]:
    return [x * 2 for x in items[:limit]]

# ========== 异常处理 ==========
# 捕获具体异常
try:
    risky_op()
except (ValueError, TypeError) as e:
    logger.error(f"Error: {e}")

# 使用上下文管理器
with open("file.txt") as f:
    data = f.read()

13.2 性能优化

PYTHON
# 1. 使用生成器(节省内存)
def read_large_file(filename):
    with open(filename) as f:
        for line in f:
            yield line.strip()

# 2. 列表推导式比循环快
squares = [x**2 for x in range(1000000)]

# 3. 使用set进行成员检查(O(1) vs O(n))
lookup = {1, 2, 3, 4, 5}
if 3 in lookup:  # O(1)

# 4. 预编译正则
import re
PATTERN = re.compile(r"\d+")
for text in texts:
    match = PATTERN.search(text)

# 5. 使用 __slots__ 减少内存
class Point:
    __slots__ = ("x", "y")  # 不再使用 __dict__
    def __init__(self, x, y):
        self.x, self.y = x, y

# 6. 缓存结果
from functools import lru_cache

@lru_cache(maxsize=256)
def expensive_computation(n):
    return n ** n

十四、总结

14.1 Python核心优势

优势 说明
简洁易读 语法接近自然语言,学习曲线平缓
生态丰富 PyPI 超过 40万包,覆盖所有领域
全民语言 从入门教学到专业开发皆可
数据科学 NumPy/Pandas/Matplotlib 统治数据领域
AI/ML TensorFlow/PyTorch 首选语言
自动化 脚本编写、自动化运维的首选

14.2 学习路径

CODE
基础语法 → 容器类型 → 函数进阶 → 面向对象 → 文件I/O → 标准库
    ↓          ↓          ↓          ↓          ↓         ↓
 变量类型   列表字典   闭包装饰器   继承多态    JSON/CSV   os/sys
 运算符     元组集合   生成器       魔术方法    pathlib   datetime
 控制流    迭代器      lambda       dataclass   序列化    collections

进阶方向:
  Web开发   → Flask/Django → REST API → 数据库 → 部署
  数据科学  → NumPy/Pandas → 可视化   → ML/AI
  自动化    → 脚本编写      → 爬虫     → 测试  → DevOps

14.3 推荐资源


祝你通过本书掌握Python语言,成为一名优雅的Python开发者!