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 推荐资源
- 官方文档: https://docs.python.org/zh-cn/3/
- Python官方教程: https://docs.python.org/zh-cn/3/tutorial/
- PyPI: https://pypi.org/
- Real Python: https://realpython.com/
- Python Cookbook: https://python3-cookbook.readthedocs.io/
- Awesome Python: https://github.com/vinta/awesome-python
祝你通过本书掌握Python语言,成为一名优雅的Python开发者!