Python面试必问的8个问题,会一半就能拿offer

今天我把Python面试最高频的8个问题整理出来，每个问题都给出详细，结合实际工作经验的回答。

问题一：Python里的列表和元组有什么区别？

标准答案是：列表是可变的，元组是不可变的。

但这个答案只对了一半，而且没体现你真正的理解。

真正重要的区别有三个层面。

第一层是性能。元组比列表更轻量，因为不可变，所以Python在底层做了很多优化。相同数量的元素，元组占用的内存更小，遍历速度更快。如果你定义一组常量，比如一年十二个月，用元组比用列表更合适。

第二层是语义。可变意味着可以被修改，不可变意味着不应该被修改。元组通常用来表示固定的结构，比如数据库里的一行记录、坐标(x,y)、一个RGB颜色值。当你看到代码里用的是元组，说明作者的意思是"这组数据不应该变"。列表则是用来表示"这组数据可能会变"。

第三层是实际应用。

比如在函数返回值的时候，如果你返回的是多个值，Python底层其实是返回一个元组。看这个例子：

defget_user_info():return"张三", 25, "北京"

这里的返回值看起来像是三个值，但实际上是一个元组。所以当你写函数返回多个值的时候，你返回的就是元组。

再比如字典的键，必须是可哈希的，也就是不可变的。列表不能作为字典的键，但元组可以（只要元组里的元素也是可哈希的）。

# 列表不能作为字典的键，会报错# d = {[1, 2]: "value"}  # TypeError# 元组可以作为字典的键，没问题d = {(1, 2): "value"}  # 正常

所以当你被问到这个问题的时候，不要只说"列表可变元组不可变"。加一句"元组可以作为字典的键"，加分。加一句"元组的遍历性能更好"，再加分。

问题二：什么是Python中的深拷贝和浅拷贝？

这个问题太重要了，面试中出现的频率极高，而且很多人答不好。

先说结论：浅拷贝只拷贝一层，嵌套对象仍然共享引用；深拷贝会递归拷贝所有层级，完全独立。

来，看个实际例子你就懂了。

import copyoriginal = [1, [2, 3], [4, 5]]# 浅拷贝shallow = copy.copy(original)# 深拷贝deep = copy.deepcopy(original)# 修改第一层shallow[0] = 100print(original[0])  # 1，没变print(shallow[0])  # 100# 修改第二层（嵌套列表）shallow[1][0] = 200print(original[1][0])  # 200，变了！print(shallow[1][0])  # 200print(deep[1][0])     # 2，没变

浅拷贝之后，修改第一层元素互不影响，但修改第二层的嵌套列表，原来的列表也会跟着变。这是因为浅拷贝只拷贝了外层的引用，内层的嵌套列表还是共享的。

深拷贝则完全不同，所有层级都完全独立，互不影响。

为什么要搞清楚这个？因为在实际工作中，稍不注意就会踩坑。

比如你写了一个函数，想对传入的列表做修改但不影响原数据：

defprocess_data(data):# 如果直接用 data，修改会影响到原数据    result = copy.deepcopy(data)# 对 result 做各种修改return result

这就是深拷贝的实际应用。如果你用的是浅拷贝，嵌套列表的修改会影响到原数据，导致bug。

面试官可能还会追问：Python里的赋值和拷贝有什么区别？

赋值只是创建了一个新的引用，指向同一个对象。比如：

a = [1, 2, 3]b = ab[0] = 100print(a[0])  # 100，a也跟着变了

所以赋值不是拷贝。拷贝需要显式地用copy.copy()或copy.deepcopy()。

问题三：Python中的装饰器是什么？怎么实现？

装饰器是Python里非常优雅的特性，用得好能让代码简洁很多。但很多人只会背概念，一让写代码就卡壳。

装饰器的本质是一个函数，它的参数是一个函数，返回值也是一个函数。它用来给已有函数增加额外的功能，而不改变原函数的代码。

先看一个最简单的装饰器：

defmy_decorator(func):defwrapper(*args, **kwargs):        print("函数开始执行")        result = func(*args, **kwargs)        print("函数执行结束")return resultreturn wrapper@my_decoratordefsay_hello(name):    print(f"你好，{name}")return"完成"say_hello("小明")

输出是：

函数开始执行你好，小明函数执行结束

@syntax是Python的语法糖，等价于：

say_hello = my_decorator(say_hello)

所以装饰器就是：把原函数传给装饰器函数，装饰器返回一个新函数，这个新函数在调用原函数的基础上，增加了额外的逻辑。

为什么要用装饰器？举一个实际的例子。

假设你在写一个Web API，每个接口都需要记录日志、计算执行时间、处理异常。你可以在每个函数里都写一遍，但这样代码会变得很冗余。用装饰器就简单了：

import timefrom functools import wrapsdeflog_and_time(func):    @wraps(func)defwrapper(*args, **kwargs):        start = time.time()try:            result = func(*args, **kwargs)            print(f"{func.__name__} 执行成功")except Exception as e:            print(f"{func.__name__} 执行失败: {e}")raisefinally:            print(f"耗时: {time.time() - start:.2f}秒")return resultreturn wrapper@log_and_timedefget_user_info(user_id):# 模拟查询数据库    time.sleep(0.5)return {"id": user_id, "name": "张三"}

这样每个API函数加一个@log_and_time，就自动有了日志和计时功能，比在每个函数里重复写代码优雅多了。

问题四：Python中的生成器是什么？什么时候用？

生成器是Python里用来处理大数据的神器，但很多人觉得它很难理解，其实用一句话就能说清楚：生成器是一种特殊的函数，它不会一次性返回所有数据，而是一边计算一边返回，每次返回一个值。

普通函数用return返回，生成器用yield返回。看例子：

# 普通函数，一次性返回所有数据defget_all_squares(n):return [i**2for i in range(n)]# 生成器，按需返回defget_squares_generator(n):for i in range(n):yield i**2

调用普通函数，会立刻计算所有结果，存到列表里返回。如果n是一百万，一百万个平方都会被计算出来，占用大量内存。

调用生成器，它返回一个生成器对象，不做任何计算。只有当你真正遍历它，或者调用next()的时候，才会一个一个地计算并返回。这就是"惰性计算"，省内存。

什么时候用生成器？当你需要遍历大量数据，但不需要同时把所有数据加载到内存的时候。

比如读取一个大文件：

# 错误做法：一次性读入内存with open("huge_file.txt", "r") as f:    lines = f.readlines()  # 如果文件几个G，内存爆了# 正确做法：用生成器逐行读取defread_large_file(filename):with open(filename, "r") as f:for line in f:yield line.strip()for line in read_large_file("huge_file.txt"):# 处理每一行，每次只占用一行的内存    process(line)

再比如计算一亿个数的和：

# 错误做法total = sum([i for i in range(100000000)])  # 先创建一个亿的列表，内存爆炸# 正确做法total = sum(i for i in range(100000000))  # 用生成器表达式，不占内存

生成器还有一个很实用的用法：流水线处理。比如你需要对数据进行多步转换，每一步都涉及大量数据，用生成器可以形成一条管道，每一步只处理当前的数据，不需要一次性加载所有数据到内存。

问题五：Python的GIL是什么？它有什么影响？

GIL是Global Interpreter Lock的缩写，翻译过来叫全局解释器锁。这是Python面试里的高难度问题，答好的人不多。

先说结论：GIL是Python解释器（CPython）里的一把锁，它保证同一时刻只有一个线程在执行Python字节码。

这把锁的存在是因为Python的内存管理不是线程安全的。为了简化实现，Python干脆加了一把大锁，让同一时刻只有一个线程执行Python代码。这就是GIL。

GIL的影响是什么？答案是：在CPU密集型任务中，多线程并不能真正提升性能。因为线程们都在抢同一把锁，实际上还是串行执行的。

比如你用多线程同时计算一百万个数的平方和：

import threadingimport timedefcompute(start, end, results, index):    total = sum(i**2for i in range(start, end))    results[index] = total# 4个线程threads = []results = [0, 0, 0, 0]start = time.time()for i in range(4):    t = threading.Thread(target=compute, args=(i*2500000, (i+1)*2500000, results, i))    threads.append(t)    t.start()for t in threads:    t.join()print(f"结果: {sum(results)}, 耗时: {time.time() - start:.2f}")

这段代码跑起来，你会发现速度跟单线程差不多，因为GIL的存在，四个线程实际上是串行的。

但是！GIL只影响CPU密集型任务，不影响IO密集型任务。

IO密集型任务指的是等待网络请求、文件读写、数据库查询等操作。在等待IO的时候，线程会释放GIL，让其他线程执行。所以对于IO密集型的任务，多线程还是有用的。

比如爬虫程序，大部分时间都在等网络响应，多线程就能显著提升效率。

如果你需要真正利用多核CPU做CPU密集型计算，有两个选择：一是使用multiprocessing代替multithreading，因为每个进程有独立的Python解释器和独立的GIL；二是使用Cython、NumPy这些已经释放了GIL的库。

有意思的是，Python 3.8之后引入了PEP 703，正在逐步移除GIL，但完全移除可能还需要很多年。

问题六：Python中如何处理异常？

处理异常看起来简单，很多人会说"用try except"。但实际上一不小心就会写出有问题的代码。

先说基本的语法：

try:    result = 10 / 0except ZeroDivisionError as e:    print(f"除数不能为零: {e}")

但这里有个常见的坑：except后面的代码如果也出错了，会导致原来的异常信息丢失。

# 错误写法try:    result = 10 / 0except ZeroDivisionError:    print("出错了")# 如果这里也出错，你就不知道原来的异常是什么了

正确的做法是：

# 正确写法：保留原始异常信息try:    result = 10 / 0except ZeroDivisionError as e:    print(f"除数不能为零: {e}")raise# 重新抛出异常，让上层处理

更优雅的做法是用logging记录异常：

import loggingtry:    result = 10 / 0except ZeroDivisionError as e:    logging.error(f"计算错误: {e}", exc_info=True)  # exc_info=True会包含完整的堆栈信息raise

在finally里做什么？finally里的代码无论是否发生异常都会执行，通常用来做清理工作，比如关闭文件、释放资源：

try:    file = open("data.txt", "r")    content = file.read()finally:    file.close()  # 无论是否出错，都确保文件被关闭

不过Python 3已经支持with语法了，更推荐这样写：

# 用with自动管理资源with open("data.txt", "r") as file:    content = file.read()# 文件自动关闭，不需要finally

还有一点很重要：不要用异常来控制业务逻辑。比如检查一个数是否为零，不要这样写：

# 错误：滥用异常try:    result = 10 / x    print("x不为零")except ZeroDivisionError:    print("x为零")

而是这样：

# 正确：用条件判断if x != 0:    result = 10 / x    print("x不为零")else:    print("x为零")

异常应该用于处理"意外"的情况，而不是控制正常的程序流程。

问题七：什么是Python的上下文管理器？如何自定义？

上下文管理器就是with语句。打开文件用with是最常见的例子：

with open("file.txt", "r") as f:    content = f.read()# 文件在这里自动关闭，不用手动f.close()

with的好处是：无论代码块是否正常执行结束，资源都会被正确释放。不需要担心忘记调用close()，也不需要担心中途出错导致资源泄漏。

自定义上下文管理器有两种方式。

第一种是用类实现，需要定义__enter__和__exit__两个方法：

classTimer:def__enter__(self):        self.start = time.time()return self  # 返回的值会绑定到 as 后面的变量def__exit__(self, exc_type, exc_val, exc_tb):        elapsed = time.time() - self.start        print(f"耗时: {elapsed:.2f}秒")returnFalse# 返回True会压制异常，不推荐# 使用with Timer() as t:    time.sleep(1)    print("任务完成")

第二种是用装饰器，更简洁：

from contextlib import contextmanagerimport time@contextmanagerdeftimer():    start = time.time()try:yield# yield之前的代码相当于__enter__，之后的相当于__exit__finally:        elapsed = time.time() - start        print(f"耗时: {elapsed:.2f}秒")# 使用with timer():    time.sleep(1)    print("任务完成")

在实际工作中，上下文管理器用处很多。比如数据库连接、锁的获取释放、临时修改某个全局状态然后恢复……用with语句能让代码更安全、更简洁。

问题八：Python中的map、filter、reduce函数怎么用？什么时候用？

这三个是函数式编程的工具，在处理数据的时候非常方便。

map对序列中的每个元素执行某个操作，返回一个迭代器：

# 传统写法numbers = [1, 2, 3, 4, 5]squares = []for n in numbers:    squares.append(n ** 2)# 用mapsquares = list(map(lambda x: x ** 2, numbers))# 或者用列表推导式（更Pythonic）squares = [x ** 2for x in numbers]

filter对序列进行过滤，返回符合条件的元素：

# 过滤出偶数numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]evens = list(filter(lambda x: x % 2 == 0, numbers))# 或者用列表推导式evens = [x for x in numbers if x % 2 == 0]

reduce对序列进行累积计算，把序列合并成一个值：

from functools import reduce# 计算乘积numbers = [1, 2, 3, 4, 5]product = reduce(lambda x, y: x * y, numbers)# 过程是：(((1*2)*3)*4)*5 = 120

什么时候用这三个函数？

在数据处理的场景里，它们比传统的for循环更简洁。比如处理一串数字：

# 计算列表中所有偶数的平方和numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]# 一步步来evens = [x for x in numbers if x % 2 == 0]squares = [x ** 2for x in evens]total = sum(squares)# 用函数式组合total = sum(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers)))# 或者用reducefrom functools import reducetotal = reduce(lambda acc, x: acc + x ** 2if x % 2 == 0else acc, numbers, 0)

不过要提醒一句：map、filter、reduce虽然强大，但不是所有场景都适合。如果逻辑复杂，用列表推导式或者普通的for循环往往更清晰。代码是写给人看的，不是写给机器看的，可读性永远比"酷"重要。

好，八个问题讲完了。总结一下：

列表和元组的区别要从性能、语义、实际应用三个层面讲；深拷贝和浅拷贝要能举出具体例子；装饰器要能写出来；生成器要理解惰性计算；GIL要理解它的影响和适用场景；异常处理要注意保留信息；上下文管理器要能自定义；map filter reduce要理解它们的组合用法。

面试Python不会只考你会不会写代码，更重要的是考你理不理解背后的原理。这些问题答好了，至少能证明你不是"调包侠"，而是真的理解Python是怎么工作的。