本文目录导读：
Python面试常考案例主要围绕数据结构、算法、函数式编程、面向对象、错误处理、工程实践等核心知识点展开，下面我会从高频题型分类入手，先给出典型问题，再给出可直接运行的代码实现，并附上关键讲解。
基础数据结构与算法类（手写代码必考）
两数之和（Two Sum）给定一个整数数组 nums 和一个目标值 target，找出和为目标值的两个数的下标。
解法：哈希表（O(n)）
def two_sum(nums, target):
hash_map = {}
for i, num in enumerate(nums):
complement = target - num
if complement in hash_map:
return [hash_map[complement], i]
hash_map[num] = i
return []
# 测试
print(two_sum([2, 7, 11, 15], 9)) # [0, 1]
考察点：哈希表思想、空间换时间、循环与字典的熟练使用。
反转链表（手写链表）反转一个单链表（ListNode）。
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def reverse_list(head):
prev = None
curr = head
while curr:
next_node = curr.next # 保存下一个
curr.next = prev # 反转指针
prev = curr # 前移
curr = next_node # 前移
return prev
# 辅助测试函数
def list_to_linked(arr):
if not arr: return None
head = ListNode(arr[0])
cur = head
for val in arr[1:]:
cur.next = ListNode(val)
cur = cur.next
return head
def linked_to_list(head):
res = []
while head:
res.append(head.val)
head = head.next
return res
head = list_to_linked([1,2,3,4,5])
new_head = reverse_list(head)
print(linked_to_list(new_head)) # [5,4,3,2,1]
考察点：指针操作、链表的基本结构、边界条件（空链表、单节点）。
有效的括号（栈）给定一个只包括 的字符串，判断括号是否匹配。
def is_valid(s):
stack = []
mapping = {')': '(', '}': '{', ']': '['}
for char in s:
if char in mapping:
top = stack.pop() if stack else '#'
if mapping[char] != top:
return False
else:
stack.append(char)
return not stack
print(is_valid("()[]{}")) # True
print(is_valid("([)]")) # False
考察点：栈的 LIFO 特性、哈希表映射、空栈处理。
二叉树的中序遍历（递归 + 迭代）中序遍历 [1, null, 2, 3] -> [1, 3, 2]
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
# 递归
def inorder_recursive(root):
res = []
def dfs(node):
if not node: return
dfs(node.left)
res.append(node.val)
dfs(node.right)
dfs(root)
return res
# 迭代（栈）
def inorder_iterative(root):
res, stack = [], []
cur = root
while cur or stack:
while cur:
stack.append(cur)
cur = cur.left
cur = stack.pop()
res.append(cur.val)
cur = cur.right
return res
考察点：递归到迭代的转换、栈模拟、二叉树遍历模板。
函数式与装饰器类（Python 特色）
实现一个简单的装饰器（计时、权限校验）
import time
def timer(func):
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
end = time.perf_counter()
print(f"{func.__name__} 耗时 {end - start:.6f} 秒")
return result
return wrapper
@timer
def slow_sum(n):
total = 0
for i in range(n):
total += i
return total
print(slow_sum(1000000))
考察点：闭包、*args 和 **kwargs 透传、元编程思想。
使用 lambda 和 map/filter/reduce
from functools import reduce nums = [1, 2, 3, 4, 5] # map: 每个数平方 squared = list(map(lambda x: x**2, nums)) # [1, 4, 9, 16, 25] # filter: 筛选偶数 evens = list(filter(lambda x: x % 2 == 0, nums)) # [2, 4] # reduce: 累加 total = reduce(lambda a, b: a + b, nums) # 15
考察点：函数式编程思想、lambda 表达式、内置高阶函数。
面向对象与设计模式
单例模式（三种方式）
装饰器
def singleton(cls):
instances = {}
def get_instance(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return get_instance
@singleton
class Database:
pass
db1 = Database()
db2 = Database()
print(db1 is db2) # True
__new__
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
考察点：Python 对象创建流程、__new__ 与 __init__ 区别。
迭代器与生成器实现一个可以无限产生斐波那契数列的生成器。
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# 取前10个
fib = fibonacci()
print([next(fib) for _ in range(10)]) # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
考察点：yield 关键字、生成器惰性求值、内存高效。
异常处理与上下文管理器
自定义上下文管理器（with 语句）
class FileManager:
def __init__(self, filename, mode):
self.filename = filename
self.mode = mode
def __enter__(self):
self.file = open(self.filename, self.mode)
return self.file
def __exit__(self, exc_type, exc_val, exc_tb):
self.file.close()
# 返回 False 会传播异常，True 会吞掉异常
return False
# 使用
with FileManager("test.txt", "w") as f:
f.write("hello world")
考察点：__enter__ / __exit__ 协议、异常处理、资源管理。
工程与并发（中高级）
使用 threading 或 asyncio 模拟并发
多线程（I/O 密集型）
import threading
import time
def worker(n):
print(f"Worker {n} 开始")
time.sleep(1)
print(f"Worker {n} 结束")
threads = []
for i in range(3):
t = threading.Thread(target=worker, args=(i,))
threads.append(t)
t.start()
for t in threads:
t.join()
异步（asyncio 3.8+）
import asyncio
async def worker(n):
print(f"Worker {n} 开始")
await asyncio.sleep(1)
print(f"Worker {n} 结束")
async def main():
tasks = [worker(i) for i in range(3)]
await asyncio.gather(*tasks)
asyncio.run(main())
考察点：GIL 的理解、并发模型选择、join / await。
面试中如何高效准备？
| 类别 | 重点掌握 | 面试频率 |
|---|---|---|
| 数据结构 | 栈、队列、哈希表、链表、二叉树 | |
| 算法 | 双指针、滑动窗口、DFS/BFS、动态规划简单题 | |
| Python 特性 | 装饰器、生成器、迭代器、上下文管理器 | |
| 面向对象 | 封装、继承、多态、特殊方法（__xxx__） |
|
| 并发 | GIL、多线程 vs 多进程、asyncio | ⭐⭐（中高级） |
建议准备方式：
- 每个案例手写 2~3 遍。
- 理解为什么这样写,而不是只背代码。
- 面试时先说思路（暴力 → 优化 → 边界条件）,再写代码。
- 注意 PEP8 风格（变量命名、空行、注释）。
如果你希望我针对大厂高频真题（如字节、阿里、腾讯的 Python 面试题）做一份分类题库+解析，也可以告诉我,我可以专门为你整理。
标签： Python面试