1. 面试准备：为什么Python面试题总绕不开这些点？

又到了招聘季，最近帮团队面试了不少Python方向的候选人，也和一些做技术面试官的朋友聊了聊。大家普遍有个感觉：市面上Python面试题看似五花八门，但翻来覆去，核心考点就那么几块。很多候选人刷了不少题，背了不少答案，但一遇到稍微变形的问题，或者需要结合实际场景解释原理时，就露怯了。这背后反映出的，其实是对Python语言特性和常用技术栈的理解深度不够。

Python作为一门“胶水语言”，应用场景极其广泛，从Web后端、数据分析、自动化脚本到人工智能，都有它的身影。因此，面试官考察的不仅仅是语法，更是你如何运用这门语言解决实际问题的思维和能力。那些高频出现的面试题，恰恰是检验你是否具备一名合格Python开发者基本功的试金石。它们通常围绕语言核心（如数据结构、内存管理、面向对象）、关键特性（如装饰器、生成器）、常用模块（如并发、网络）以及生态工具（如Web框架、数据库ORM）展开。

今天，我们不搞题海战术，而是从我作为面试官和多年开发者的双重角度，为你拆解最常见的35个Python面试题。我的目标不是给你一份标准答案让你去背，而是带你理解每个问题背后的“为什么”，以及在实际工作中它们是如何体现的。当你真正理解了原理，无论题目怎么变，你都能从容应对。

2. Python语言核心与高级特性深度剖析

这一部分是面试的重灾区，也是区分“会用Python”和“理解Python”的关键。很多问题看似基础，但深挖下去，能很好地考察候选人的知识体系是否扎实。

2.1 可变对象与不可变对象：一切行为的根源

这几乎是必问题。一个典型的问法是：“说说Python中可变对象和不可变对象的区别，并举例说明。”

核心答案要点：不可变对象（如int, float, str, tuple, frozenset）一旦创建，其内容（值）就不能改变。对不可变对象的操作（如字符串拼接）实际上是创建了一个新的对象。可变对象（如list, dict, set）的内容可以在原地修改。

但面试官想听的远不止这些。他会期待你进一步阐述这背后的影响：

1. 函数参数传递：Python的参数传递是“对象引用传递”。对于不可变对象，函数内部对形参的赋值不会影响外部实参，因为修改意味着创建新对象，形参指向了新对象。对于可变对象，函数内部对形参内容的修改（如append）会直接影响外部实参，因为操作是在原对象上进行的。

   def update_list(lst): lst.append(4) # 修改原对象，外部受影响 lst = [7, 8, 9] # 将形参lst指向了新对象，外部不受影响 my_list = [1, 2, 3] update_list(my_list) print(my_list) # 输出：[1, 2, 3, 4]

2. 字典的键：字典的键必须是不可变对象。因为字典依赖键的哈希值进行快速查找，如果键是可变对象且其内容被修改，哈希值就会变，导致字典内部定位混乱。这就是为什么list和dict不能作为字典的键，而tuple只有当其包含的所有元素都是不可变对象时才能作为键。

3. 性能与内存：频繁修改字符串（不可变）会产生大量临时对象，影响性能，此时应考虑使用io.StringIO或列表拼接后再join。而小整数的缓存（如-5到256）也是基于不可变性的优化。

我的踩坑经验：曾经在写一个缓存函数时，用了一个tuple作为字典的键，这个tuple里包含了一个自定义对象。后来修改了那个对象的__hash__方法，导致所有缓存的键都失效了，引发了诡异的Bug。教训是：即使使用tuple作为键，也要确保其元素的哈希值在其生命周期内稳定。

2.2 装饰器：不仅仅是语法糖

“手写一个记录函数运行时间的装饰器。”这是装饰器相关最经典的考题。

基础实现大家都会：

import time def timer(func): def wrapper(*args, **kwargs): start = time.time() result = func(*args, **kwargs) end = time.time() print(f"{func.__name__} executed in {end - start:.4f} seconds") return result return wrapper

但这里至少有3个进阶考察点：

1. 保留原函数元信息：直接使用上面的装饰器，被装饰函数的__name__、__doc__等元信息会丢失（变成wrapper的）。需要使用functools.wraps来修复。

   from functools import wraps def timer(func): @wraps(func) # 关键在这里 def wrapper(*args, **kwargs): # ... 同上 return result return wrapper

2. 带参数的装饰器：如果需要装饰器本身也能接受参数（如@retry(times=3)），就需要再嵌套一层函数。

   def retry(times=3): def decorator(func): @wraps(func) def wrapper(*args, **kwargs): for i in range(times): try: return func(*args, **kwargs) except Exception as e: if i == times - 1: raise print(f"Retry {i+1}/{times} after error: {e}") return wrapper return decorator

3. 类装饰器：用类来实现装饰器，通过实现__call__方法。这在需要维护状态的装饰器中很有用。

   class CountCalls: def __init__(self, func): self.func = func self.num_calls = 0 wraps(func)(self) # 也可以用 self.__name__ = func.__name__ 等 def __call__(self, *args, **kwargs): self.num_calls += 1 print(f"Call {self.num_calls} of {self.func.__name__}") return self.func(*args, **kwargs)

面试官追问：“装饰器在Flask/Django里是怎么用的？”这时你可以结合Web框架的路由注册（@app.route）、权限验证（@login_required）等实际场景来回答，说明装饰器如何优雅地实现横切关注点（AOP）。

2.3 生成器与迭代器：惰性求值的艺术

“解释一下生成器和迭代器的区别与联系。”

标准回答：迭代器是一个实现了__iter__和__next__方法的对象，用于逐个访问集合元素。生成器是一种特殊的迭代器，使用yield关键字定义，在迭代时动态生成值，而不是一次性生成所有值并存储在内存中。

你需要展示的更深入理解：

1. 内存效率：这是生成器的核心优势。处理大规模数据集（如读取几个G的日志文件）时，使用生成器可以做到内存占用恒定，而用列表一次性加载会撑爆内存。

   # 糟糕的做法 with open('huge.log') as f: lines = f.readlines() # 一次性读入内存 for line in lines: process(line) # 正确的做法（生成器） def read_large_file(file_path): with open(file_path) as f: for line in f: # f本身就是一个返回行的迭代器 yield line.strip() for line in read_large_file('huge.log'): process(line)

2. 协程与yield from：生成器可以通过send()方法接收值，从而成为协程，用于简单的协作式多任务。yield from（Python 3.3+）可以简化生成器的委托，是async/await语法的基础。

   def sub_generator(): yield from range(5) # 委托给range迭代器 def main_generator(): yield from sub_generator() # 委托给另一个生成器 yield from (x*2 for x in range(3)) # 委托给生成器表达式

3. 迭代器协议的应用：很多内置函数和语法糖都依赖迭代器协议，如for循环、list()、sum()、*解包操作符。理解这一点，你就能明白为什么for item in my_dict:是在迭代键，而for value in my_dict.values():是在迭代值。

一个常见的坑：生成器只能迭代一次。迭代完后，生成器对象就 exhausted 了。如果你需要多次使用其数据，要么将其转换为列表（牺牲内存），要么重新创建生成器对象。

2.4 上下文管理器与with语句

“with语句有什么用？如何自己实现一个？”

基础回答：with语句用于确保一段代码执行完毕后，某项“清理”工作一定会被执行（如关闭文件、释放锁）。它背后是上下文管理器协议，即实现了__enter__和__exit__方法的对象。

手写一个上下文管理器：

class ManagedFile: def __init__(self, filename, mode='r'): self.filename = filename self.mode = mode self.file = None def __enter__(self): self.file = open(self.filename, self.mode) return self.file def __exit__(self, exc_type, exc_val, exc_tb): if self.file: self.file.close() # 如果返回True，则with块内的异常会被抑制 return False # 使用 with ManagedFile('test.txt', 'w') as f: f.write('hello')

更实用的技巧：使用contextlib模块的contextmanager装饰器，可以用生成器函数更简洁地实现上下文管理器。

from contextlib import contextmanager @contextmanager def managed_file(filename, mode='r'): try: f = open(filename, mode) yield f finally: f.close()

面试官可能追问的场景：

• 数据库连接：确保查询后连接被正确放回连接池。
• 锁的获取与释放：在多线程/多进程编程中，避免死锁。
• 临时状态修改与恢复：例如，临时修改某个全局配置，执行完操作后再恢复原状。
• __exit__中异常处理：__exit__方法接收三个异常参数，你可以在这里决定是吞掉异常、记录日志还是原样抛出。

理解上下文管理器，是写出健壮、资源安全的Python代码的重要一环。

3. 内存管理、并发与网络编程实战要点

这部分问题考察你是否了解Python程序的运行机制，以及如何应对实际开发中的性能与并发挑战。

3.1 垃圾回收机制：引用计数与循环引用

“Python的垃圾回收（GC）是如何工作的？”

千万不要只回答“引用计数”，那只是故事的一半。

完整的GC机制包括：

1. 引用计数（主要机制）：每个对象都有一个计数器，记录有多少引用指向它。当引用计数归零时，对象立即被销毁。这解释了为什么在函数内部创建的局部变量，在函数退出后会很快被回收。
2. 标记-清除（处理循环引用）：引用计数无法解决循环引用问题（如两个对象互相引用，或对象引用自身）。这时，Python的GC会定期启动，从一组根对象（如当前调用栈、全局变量）出发，标记所有可达的对象。未被标记的对象（即不可达的循环引用孤岛）则被清除。
3. 分代回收（提升效率）：基于“年轻对象更可能死掉”的假设，Python将对象分为0、1、2三代。新创建的对象在第0代。GC频繁检查第0代对象。存活下来的对象被移入第1代，第1代GC频率较低，以此类推。这大大减少了每次GC需要扫描的对象数量。

面试实战技巧：可以结合gc模块来展示你的理解。例如，如何手动触发GC（gc.collect()），如何查看和调试循环引用（gc.set_debug(gc.DEBUG_SAVEALL)），以及为什么在某些对延迟敏感的场景（如游戏主循环、高频交易）中，可能需要禁用或调整GC策略。

一个真实案例：我们曾遇到一个服务内存缓慢增长的问题。使用objgraph工具排查后，发现是某个缓存类实例与业务对象之间形成了复杂的循环引用网络。虽然GC最终会回收，但频率不够高，导致内存峰值过高。解决方案是使用弱引用（weakref）来打破循环，或者定期手动触发GC。

3.2 GIL全局解释器锁：性能瓶颈与应对策略

“谈谈你对GIL的理解，它会影响多线程性能吗？如何绕过GIL？”

这是Python面试的经典难题，也是考察你对并发编程理解深度的试金石。

GIL是什么：GIL是CPython解释器中的一个互斥锁，它确保同一时刻只有一个线程可以执行Python字节码。这意味着，即使在多核CPU上，一个Python进程中的多个线程也无法实现真正的并行计算。

GIL的影响：

• CPU密集型任务：多线程无法利用多核优势，性能甚至可能因为线程切换开销而比单线程更差。这是GIL最被诟病的地方。
• I/O密集型任务：当线程在执行I/O操作（如网络请求、磁盘读写）时，会释放GIL，其他线程可以运行。因此，对于I/O密集型任务，多线程仍然可以显著提升性能，因为大部分时间在等待I/O，而不是争夺CPU。

如何绕过或应对GIL：

1. 使用多进程（multiprocessing）：每个进程有独立的Python解释器和内存空间，因此也有独立的GIL。这是利用多核CPU进行并行计算最直接的方式。缺点是进程间通信（IPC）开销比线程间通信大。
2. 使用异步编程（asyncio）：在单线程内通过事件循环处理大量I/O操作，在等待时切换任务，避免线程阻塞和切换开销。非常适合高并发的I/O密集型服务（如Web服务器）。
3. 使用C扩展：将计算密集型部分用C/C++编写成扩展模块，在C代码中可以释放GIL，从而实现真正的并行。NumPy、SciPy等科学计算库就是这么做的。
4. 使用Jython或IronPython：这些实现没有GIL，但它们通常无法使用依赖于CPython C API的第三方库（如NumPy）。

面试回答策略：不要一味抨击GIL。要客观地指出，GIL简化了CPython内存管理（特别是引用计数）的实现，使得对象模型更简单、更安全。对于大多数Web应用（I/O密集型）和脚本任务，GIL不是问题。只有当遇到CPU密集型瓶颈时，才需要考虑上述绕过方案。

3.3 多进程、多线程与协程的选型

“在Python中，什么时候该用多进程，什么时候该用多线程，什么时候该用协程？”

这是一个典型的场景分析题，考察你对不同并发模型适用性的理解。

选型决策树（简化版）：

1. 任务是CPU密集型吗？ -> 是，选多进程。
2. 任务是I/O密集型，且并发量极高（成千上万）？ -> 是，选协程（asyncio）。
3. 任务是I/O密集型，但并发量一般，或代码中混有少量同步阻塞库？ -> 选多线程通常更简单实用。

重要提醒：在asyncio中混用阻塞代码是大忌。如果必须使用一个不支持异步的库（比如某个同步的数据库驱动），应该使用run_in_executor将其放到线程池中运行，避免阻塞事件循环。

3.4 Socket网络编程基础

“用Python写一个简单的TCP服务器和客户端。”

虽然现在直接手写Socket的机会不多，但理解其原理对理解HTTP、RPC等高层协议至关重要。

一个最简单的TCP Echo服务器：

# server.py import socket def start_server(host='127.0.0.1', port=65432): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((host, port)) s.listen() print(f"Server listening on {host}:{port}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) if not data: break conn.sendall(data) # Echo back if __name__ == "__main__": start_server()

对应的客户端：

# client.py import socket def start_client(host='127.0.0.1', port=65432): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((host, port)) s.sendall(b'Hello, world') data = s.recv(1024) print(f"Received: {data.decode()}") if __name__ == "__main__": start_client()

面试官可能追问的要点：

• AF_INETvsAF_INET6：IPv4和IPv6。
• SOCK_STREAMvsSOCK_DGRAM：TCP（流式，可靠）和UDP（数据报，不可靠但快）。
• bind(),listen(),accept(),connect(),send()/sendall(),recv()每个调用的作用。
• 粘包问题：TCP是流式协议，没有消息边界。recv(1024)可能收到少于或多于一条应用层消息的数据。解决方案是定义应用层协议，如“长度+内容”或使用分隔符。
• 非阻塞与select/poll/epoll：如何用单线程处理多个连接？这引出了事件循环的概念，也是asyncio和Nginx等高性能服务器的底层基础。

虽然现在我们都用requests、aiohttp或FastAPI，但亲手写过一次Socket，你对网络通信的理解会上一个台阶。

4. 常用模块、框架与数据库交互精要

这一部分考察你对Python生态的熟悉程度，以及如何运用这些工具解决实际问题。

4.1collections模块：被低估的数据结构工具箱

“除了list和dict，你还常用哪些内置数据结构？”

一个优秀的Python开发者应该能熟练运用collections模块中的特殊容器。

• defaultdict：带默认值的字典。避免在键不存在时写繁琐的if key not in dict判断。

  from collections import defaultdict # 统计单词频率 word_count = defaultdict(int) # 默认值为0 for word in words: word_count[word] += 1 # 分组 groups = defaultdict(list) for item in data: groups[item.category].append(item)

• Counter：计数器，是dict的子类。用于计数场景极其方便。

  from collections import Counter c = Counter('abracadabra') print(c) # Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}) print(c.most_common(3)) # [('a', 5), ('b', 2), ('r', 2)]

• deque（双端队列）：列表在头部插入删除是O(n)操作，而deque在两端都是O(1)。适用于队列、栈、滑动窗口等场景。

  from collections import deque dq = deque(maxlen=3) # 固定长度的滑动窗口 for i in range(5): dq.append(i) print(dq) # deque([0], maxlen=3) -> deque([0,1],...) -> deque([2,3,4],...)

• namedtuple：给元组字段命名，增强可读性。它是轻量级的、不可变的数据结构。

  from collections import namedtuple Point = namedtuple('Point', ['x', 'y']) p = Point(10, y=20) print(p.x, p.y) # 10 20

进阶：ChainMap用于链接多个映射，OrderedDict在Python 3.7后因dict已有序而重要性下降，但仍有move_to_end等特有方法。

4.2 虚拟环境与依赖管理：项目的基石

“你如何管理Python项目的依赖和环境？”

这是一个考察工程实践能力的问题。回答“我用pip install”是远远不够的。

标准工作流：

1. 为每个项目创建独立的虚拟环境：使用venv（Python 3.3+内置）或virtualenv。这能隔离不同项目所需的包版本，避免全局污染。

   python -m venv .venv # Windows .venv\Scripts\activate # Linux/Mac source .venv/bin/activate

2. 使用requirements.txt记录依赖：在激活的虚拟环境中，使用pip freeze > requirements.txt生成依赖列表。其他人可以通过pip install -r requirements.txt来安装。
3. 使用pip-tools或Poetry进行更精细的管理：requirements.txt无法区分生产依赖和开发依赖（如测试框架、代码检查工具）。pip-tools允许你维护一个requirements.in文件，通过pip-compile生成精确的requirements.txt。Poetry则是一个更现代的工具，可以同时管理虚拟环境、依赖（分生产/开发）和打包发布。

面试官想听的细节：

• requirements.txt的格式：可以使用==指定精确版本，>=指定最低版本，~=兼容版本等。
• 依赖冲突的解决：当两个包依赖同一个第三方包的不同版本时，如何解决？通常需要升级或降级某个包，或者寻找替代品。
• setup.pyvspyproject.toml：传统的打包配置是setup.py，新的标准是pyproject.toml（由PEP 518引入），它被pip、Poetry、Flit等工具支持，是未来的方向。
• 镜像源的使用：如何配置pip使用国内镜像（如清华、阿里云镜像）来加速下载。

4.3 ORM的使用与SQL优化意识

“在Django或SQLAlchemy中，N+1查询问题是什么？如何避免？”

无论你用Django ORM还是SQLAlchemy，这个问题都是考察数据库交互能力的核心。

什么是N+1查询问题： 假设你有Author和Book两个模型，一对多关系。你想获取所有作者及其所有的书籍。

# Django 示例 (SQLAlchemy思想类似) authors = Author.objects.all() for author in authors: books = author.book_set.all() # 这里会执行一次查询 print(author.name, [b.title for b in books])

上面的代码会执行1次查询获取所有作者，然后对于N个作者，在循环中又执行了N次查询来获取各自的书籍。总共是N+1次查询。当作者数量很大时，性能灾难就发生了。

解决方案：使用select_related或prefetch_related（Django） /joinedload或subqueryload（SQLAlchemy）。

• select_related/joinedload：使用SQL的JOIN语句，一次性将关联对象的数据取出。适用于“一对一”或“多对一”关系（外键在本地）。

  # Django authors = Author.objects.select_related('profile').all() # 假设有一个一对一Profile # SQLAlchemy stmt = select(Author).options(joinedload(Author.profile))

• prefetch_related/subqueryload或selectinload：对于“一对多”或“多对多”关系，JOIN会导致结果集重复。ORM会先执行一个查询获取主对象，再执行一个查询获取所有关联对象，然后在Python内存中进行匹配。这仍然是2次查询，但远好于N+1次。

  # Django (解决上面的N+1问题) authors = Author.objects.prefetch_related('books').all() for author in authors: print(author.name, [b.title for b in author.books.all()]) # 这里不会触发新查询 # SQLAlchemy stmt = select(Author).options(selectinload(Author.books))

更深入的讨论：

• 如何查看ORM生成的SQL？在Django中，可以设置settings.DEBUG=True并在日志中查看，或使用django-debug-toolbar。在SQLAlchemy中，可以设置echo=True或使用日志。
• 什么时候该用原生SQL？当ORM生成的查询过于复杂导致性能低下，或者需要用到数据库特定功能（如窗口函数、CTE）时。
• 索引的重要性：即使解决了N+1问题，如果WHERE或JOIN的字段没有索引，查询依然会慢。理解如何通过db_index（Django）或迁移命令来创建索引是必须的。

4.4 测试：单元测试与Mock技术

“如何为Python代码编写单元测试？Mock是用来做什么的？”

写出可测试的代码和编写测试本身一样重要。

单元测试框架：Python标准库的unittest和第三方pytest。pytest因其简洁的语法和强大的插件生态（如pytest-cov用于覆盖率，pytest-mock集成mock）而更受欢迎。

# pytest 示例 def add(a, b): return a + b def test_add(): assert add(1, 2) == 3 assert add(-1, 1) == 0

Mock技术：当你要测试的函数依赖于外部系统（如数据库、网络API、文件系统）时，为了隔离测试，你需要用模拟对象（Mock）来替换这些依赖。unittest.mock模块（Python 3.3+）是标准工具。

from unittest.mock import Mock, patch import requests def get_user_name(user_id): # 假设这个函数内部调用了某个外部API response = requests.get(f'https://api.example.com/users/{user_id}') return response.json()['name'] def test_get_user_name(): # 创建一个模拟的response对象 mock_response = Mock() mock_response.json.return_value = {'name': 'Alice'} # 使用patch临时替换requests.get with patch('requests.get', return_value=mock_response) as mock_get: result = get_user_name(1) mock_get.assert_called_once_with('https://api.example.com/users/1') assert result == 'Alice'

关键测试概念：

• 测试夹具（Fixture）：pytest的@pytest.fixture，用于提供测试所需的预设环境（如数据库连接、临时文件）。
• 参数化测试：用一组数据测试同一个函数。

  import pytest @pytest.mark.parametrize("a,b,expected", [(1,2,3), (0,0,0), (-1,1,0)]) def test_add_param(a, b, expected): assert add(a, b) == expected

• 测试覆盖率：使用coverage.py工具来衡量测试代码覆盖了多少业务代码。追求合理的覆盖率（如80%），而不是盲目追求100%。

测试的意义：不仅仅是发现Bug，更是推动你写出松耦合、高内聚的代码。一个难以测试的函数，往往意味着设计上有问题。

5. 系统设计、性能优化与编码习惯

最后这部分问题，往往出现在中高级面试中，考察你的综合能力和工程素养。

5.1 设计模式在Python中的体现

“你在Python项目中用过哪些设计模式？”

Python因其动态性和强大的内置功能，许多设计模式有更简洁的实现方式，甚至看起来“不像模式”。

• 单例模式（Singleton）：在Python中，通常直接用模块来实现。模块在第一次导入时被加载，之后导入的都是同一个实例。这是最Pythonic的单例。

  # singleton.py class _Singleton: pass instance = _Singleton() # other.py from singleton import instance # 到处导入的都是同一个instance

  如果需要更传统的类形式，可以用__new__方法或元类控制，但通常不推荐。

• 工厂模式（Factory）：根据输入参数创建不同类型的对象。

  class Dog: def speak(self): return "Woof!" class Cat: def speak(self): return "Meow!" def get_pet(pet_type): pets = {"dog": Dog, "cat": Cat} return pets.get(pet_type.lower())() if pet_type.lower() in pets else None

  更Pythonic的做法可能是使用字典将字符串映射到类。

• 策略模式（Strategy）：定义一系列算法，并使它们可以相互替换。在Python中，函数是一等公民，策略模式可以简化为传递函数。

  def strategy_add(a, b): return a + b def strategy_multiply(a, b): return a * b class Calculator: def __init__(self, strategy=strategy_add): self.strategy = strategy def execute(self, a, b): return self.strategy(a, b) calc = Calculator(strategy_multiply) print(calc.execute(3, 4)) # 12

• 装饰器模式：Python的装饰器语法本身就是这种模式的直接语言支持。

核心思想：不要生搬硬套GoF的设计模式。理解模式解决的问题，然后用Python最自然的方式去实现它。Pythonic的代码往往更简洁、更易读。

5.2 性能分析工具与优化思路

“如果发现一个Python程序运行很慢，你会如何排查和优化？”

这是一个开放式问题，考察你的问题排查方法论。

1. 测量，不要猜测：

• 使用timeit模块：对小段代码进行精确的计时。

  import timeit timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)

• 使用cProfile或line_profiler：cProfile是标准库，可以给出函数调用次数和耗时。line_profiler（需要安装）可以逐行分析代码耗时，更精确。

  python -m cProfile -s time my_script.py

• 使用memory_profiler：分析内存使用情况，查找内存泄漏或内存占用过高的地方。

2. 常见的优化方向：

• 算法与数据结构：这是最大的优化来源。用O(n log n)的排序替代O(n^2)的算法，用集合（set）的O(1)查找替代列表（list）的O(n)查找。
• 减少函数调用开销：在极热点的循环内部，避免不必要的函数调用和属性查找。有时将循环内不变的计算提到循环外（循环外提）。
• 使用局部变量：在函数中，局部变量的访问速度比全局变量快。在密集循环中，可以将全局变量或属性赋值给局部变量。

  # 慢 for i in range(1000000): result.append(math.sqrt(i)) # 快 sqrt = math.sqrt for i in range(1000000): result.append(sqrt(i))

• 善用内置函数和库：它们通常是用C实现的，比纯Python循环快得多。例如，用map、filter、列表推导式，或用NumPy/Pandas处理数值计算。
• 字符串拼接：避免在循环中使用+=拼接字符串（因为字符串不可变，每次都会创建新对象）。应使用str.join()或io.StringIO。
• 使用__slots__：对于需要创建大量实例的类，定义__slots__可以显著减少内存占用，并稍微提升属性访问速度。但它限制了动态添加属性。

3. 终极武器：使用C扩展或Cython：将最耗时的部分用C/C++重写，或者使用Cython（一种Python的超集，可以编译成C扩展）。这是NumPy、Pandas等库高性能的秘诀。

优化格言：“过早优化是万恶之源”（Donald Knuth）。先保证代码正确、清晰，在性能成为真正瓶颈时，再基于 profiling 数据有针对性地优化。

5.3 代码风格与可维护性

“你如何看待PEP 8？除了PEP 8，还有哪些写出好代码的原则？”

这个问题考察你的工程素养和团队协作意识。

PEP 8是基础：它是Python的官方风格指南，规定了命名规范（如函数用小写加下划线my_function，类用驼峰MyClass）、缩进（4个空格）、行宽（79字符）、空格使用等。遵守PEP 8能让代码在团队中保持一致的、可读的风格。工具如autopep8、black（更激进但免于争论）可以自动格式化代码。

但好代码远不止格式：

1. DRY原则（Don‘t Repeat Yourself）：消除重复代码。重复是维护的噩梦。
2. 单一职责原则（SRP）：一个函数或类应该只做一件事，并且做好。这使代码更易于测试、理解和修改。
3. 显式优于隐式：代码的行为应该是明确的。避免使用过于巧妙的“魔法”或依赖隐晦的全局状态。
4. 错误处理要明确：使用具体的异常类型（如ValueError、KeyError），而不是通用的Exception。知道什么时候该捕获异常，什么时候该让它抛出。
5. 善用类型提示（Type Hints）：Python 3.5+引入了类型提示。它不会影响运行时，但可以被IDE（如PyCharm, VSCode）和静态类型检查工具（如mypy）用来提供更好的代码补全、错误检查和文档。

   from typing import List, Optional def greet_all(names: List[str]) -> None: for name in names: print(f"Hello, {name}") def find_user(user_id: int) -> Optional[User]: # ... 可能返回User对象，也可能返回None

6. 编写清晰的文档字符串（Docstring）：使用"""Triple quotes"""为模块、类、函数和方法编写文档。说明它做什么，参数是什么，返回什么，可能抛出什么异常。这比注释更有用。

工具链：一个专业的Python项目通常会配置pre-commit钩子，在提交代码前自动运行black（格式化）、isort（整理import）、flake8（检查PEP 8和常见错误）和mypy（类型检查）。这能保证代码库的质量一致性。

面试官问这个问题，是想知道你是否是一个有协作精神的、注重代码长期可维护性的开发者，而不仅仅是一个能写出跑通代码的“独狼”。