Python 语言进阶
生成式与工具模块
生成式（推导式）
# 字典生成式：价格>100的股票
prices = {'AAPL': 191, 'GOOG': 1186, 'IBM': 149}
high = {k: v for k, v in prices.items() if v > 100}
# 列表生成式
squares = [x**2 for x in range(10) if x % 2 == 0]
嵌套列表的坑
# 错误：[[...]] * n 共享同一内层列表
scores = [[None] * 3 for _ in range(5)] # 正确写法
常用标准库模块
# heapq - 找最大/最小的N个元素
import heapq
heapq.nlargest(3, [34, 12, 99, 87]) # [99, 87, 34]
heapq.nsmallest(2, data, key=lambda x: x['price'])
# itertools - 迭代工具
import itertools
list(itertools.permutations('ABC')) # 全排列
list(itertools.combinations('ABC', 2)) # 组合
list(itertools.product('AB', '12')) # 笛卡尔积
itertools.cycle('ABC') # 无限循环
# collections - 容器类型
from collections import Counter, defaultdict, namedtuple, deque, OrderedDict
# Counter - 统计元素出现次数
words = ['the', 'eyes', 'the', 'eyes']
Counter(words).most_common(2) # [('the', 2), ('eyes', 2)]
# deque - 双端队列（头尾操作O(1)）
dq = deque(maxlen=5) # 可设置最大长度
# namedtuple - 命令元组
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
# defaultdict - 提供默认值的字典
d = defaultdict(list)
d['key'].append(1) # 无需先判断key存在
数据结构和算法
时间复杂度
| 复杂度 |
典型算法 |
| O(1) |
哈希存储 |
| O(log n) |
二分查找 |
| O(n) |
顺序查找 |
| O(n log n) |
归并排序、快速排序 |
| O(n²) |
选择/冒泡/插入排序 |
| O(2ⁿ) |
汉诺塔 |
| O(n!) |
旅行商问题 |
基础排序
# 选择排序
def select_sort(items):
items = items[:]
for i in range(len(items)-1):
min_idx = i
for j in range(i+1, len(items)):
if items[j] < items[min_idx]:
min_idx = j
items[i], items[min_idx] = items[min_idx], items[i]
return items
# 冒泡排序（优化：提前终止）
def bubble_sort(items):
items = items[:]
for i in range(len(items)-1):
swapped = False
for j in range(len(items)-1-i):
if items[j] > items[j+1]:
items[j], items[j+1] = items[j+1], items[j]
swapped = True
if not swapped: break
return items
# 归并排序
def merge_sort(items):
if len(items) < 2: return items
mid = len(items) // 2
left = merge_sort(items[:mid])
right = merge_sort(items[mid:])
return merge(left, right)
def merge(a, b):
result = []
i = j = 0
while i < len(a) and j < len(b):
if a[i] <= b[j]:
result.append(a[i]); i += 1
else:
result.append(b[j]); j += 1
result += a[i:]; result += b[j:]
return result
基础查找
def seq_search(items, key): # O(n)
for i, v in enumerate(items):
if v == key: return i
return -1
def bin_search(items, key): # O(log n)，需有序数组
lo, hi = 0, len(items)-1
while lo <= hi:
mid = (lo+hi)//2
if key > items[mid]: lo = mid+1
elif key < items[mid]: hi = mid-1
else: return mid
return -1
常用算法思想
| 算法 |
核心思想 |
经典问题 |
| 穷举法 |
枚举所有可能性 |
百钱百鸡、五人分鱼 |
| 贪婪法 |
局部最优 |
背包问题（性价比优先） |
| 分治法 |
分而治之，递归合并 |
归并排序、快速排序 |
| 回溯法 |
试探 + 退回 |
骑士巡逻、八皇后、迷宫 |
| 动态规划 |
子问题复用，避免重复计算 |
最大子序列和、斐波那契 |
# 动态规划：子列表元素之和的最大值 O(n)
def max_subarray(items):
partial = overall = items[0]
for i in range(1, len(items)):
partial = max(items[i], partial + items[i])
overall = max(overall, partial)
return overall
函数进阶
参数类型
def func(pos, *args, default=1, **kwargs):
# pos: 位置参数
# *args: 可变参数（元组）
# default: 关键字参数（默认值）
# **kwargs: 关键字可变参数（字典）
pass
闭包与装饰器
from functools import wraps
import time
# 装饰器：记录函数执行时间
def record_time(output=print):
def decorate(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
output(func.__name__, time.time() - start)
return result
return wrapper
return decorate
@record_time() # 使用
def fetch_data(): pass
# 装饰器实现单例模式
def singleton(cls):
instances = {}
@wraps(cls)
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper
@singleton
class President: pass
面向对象进阶
三大特性：封装、继承、多态
from abc import ABCMeta, abstractmethod
class Employee(metaclass=ABCMeta):
@abstractmethod
def get_salary(self): pass
class Manager(Employee):
def get_salary(self): return 15000
class Programmer(Employee):
def __init__(self, hours):
self.hours = hours
def get_salary(self): return 200 * self.hours
类之间的关系
- is-a：继承（如
Dog(Animal)）
- has-a：关联/聚合（如
Player 持有 Card 列表）
- use-a：依赖（如函数参数）
内存管理与循环引用
- Python 用引用计数 + 标记-清除 + 分代收集管理内存
- 循环引用会导致内存泄漏（可用
weakref 解决）
del 变量减少引用计数，但不一定立即释放
设计原则（SOLID）
| 原则 |
含义 |
| 单一职责（SRP） |
一个类只做一件事 |
| 开闭原则（OCP） |
对扩展开放，对修改关闭 |
| 里氏替换（LSP） |
子类可替换父类 |
| 接口隔离（ISP） |
接口小而专 |
| 依赖倒置（DIP） |
面向抽象编程 |
常用设计模式
- 单例：全局唯一实例（装饰器/元类实现）
- 工厂模式：解耦对象创建
- 策略模式：可替换的算法族
- 观察者模式：订阅-发布机制
迭代器和生成器
# 迭代器：实现 __iter__ 和 __next__
class Fib:
def __init__(self, n):
self.n, self.a, self.b, self.i = n, 0, 1, 0
def __iter__(self): return self
def __next__(self):
if self.i < self.n:
self.a, self.b = self.b, self.a + self.b
self.i += 1
return self.a
raise StopIteration
# 生成器：yield 简化迭代器
def fib(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b
# 生成器作为协程
def calc_avg():
total = counter = 0
while True:
value = yield total / counter if counter else 0
total += value
counter += 1
gen = calc_avg()
next(gen)
print(gen.send(10)) # 10.0
并发编程
三种方案对比
| 方案 |
优势 |
劣势 |
适用场景 |
| 多线程 |
共享内存、简单 |
GIL限制、线程不安全 |
I/O密集型 |
| 多进程 |
充分利用多核 |
内存开销大、通信复杂 |
计算密集型 |
| 异步I/O |
高并发、资源少 |
需异步库、回调复杂 |
高I/O、高并发 |
多线程
import threading
from concurrent.futures import ThreadPoolExecutor
# 线程池
with ThreadPoolExecutor(max_workers=10) as pool:
futures = [pool.submit(task, arg) for arg in args]
for f in futures:
f.result()
# 线程同步：Lock / RLock / Condition / Semaphore
lock = threading.Lock()
with lock:
# 临界区
pass
多进程
from concurrent.futures import ProcessPoolExecutor
with ProcessPoolExecutor() as pool:
results = pool.map(is_prime, numbers)
异步编程（asyncio）
import asyncio
async def fetch(url):
await asyncio.sleep(1)
return url
async def main():
tasks = [fetch(url) for url in urls]
results = await asyncio.gather(*tasks)
asyncio.run(main())
总结
- 生成式/工具模块：
heapq、itertools、collections
- 算法：排序/查找/穷举/贪婪/分治/回溯/动态规划
- 函数：参数类型、闭包、装饰器
- 面向对象：三大特性、设计原则、设计模式
- 并发：多线程（I/O）、多进程（计算）、asyncio（高并发）
