Python 常见面试题及答案汇总（2026 最新版）

前言：为什么2026年你依然要学好Python？

当时间来到2026年，编程语言的江湖格局已经发生了微妙的变化。Rust在系统编程领域高歌猛进，Go在云原生领域继续扩张，Mojo凭借其惊人的性能吸引了无数开发者的目光。但即便如此，Python依然以22.61%的市场份额连续12个月蝉联TIOBE全球编程语言排行榜榜首，这已经是它连续第10年保持在前三名的位置。

更重要的是，Python已经从一门"胶水语言"彻底进化为全行业通用的第一生产力语言。在AI/机器学习领域，Python的渗透率超过85%；在数据科学与分析领域，这一数字达到了78%；在后端开发领域，Python与Java、Go形成了三足鼎立之势；甚至在游戏开发、嵌入式系统、边缘计算等传统上被C++和C语言统治的领域，Python也凭借其丰富的库生态和快速开发能力占据了一席之地。

根据猎聘网2026年第一季度发布的《中国互联网行业人才报告》，Python相关职位的招聘量同比增长18.7%，稳居所有编程语言第二位，仅次于Java。而在薪资方面，拥有3-5年经验的Python工程师平均年薪已经达到了35-50万元，AI方向的资深工程师年薪更是普遍超过80万元。

但与此同时，Python面试的难度也在逐年提升。过去那种"会写几个爬虫、能用Django做个博客"就能轻松拿到offer的时代已经一去不复返了。2026年的Python面试，不仅要求候选人有扎实的基础功底和工程能力，更要求候选人具备AI集成能力和系统思维。大模型相关知识已经从边缘考点变成了占比10-20%的核心模块，RAG、Agent、向量数据库等技术几乎成为了中高级Python工程师的必备技能。

本文将为你全面解析2026年Python面试的所有核心考点，从基础语法到面向对象编程，从数据结构到异步编程，从后端开发到AI/大模型应用，从工程化到部署。无论你是刚毕业的大学生，还是有多年经验的资深工程师，都能在这篇文章中找到你需要的内容。

一、2026年Python面试趋势深度解读

1.1 市场格局：Python的"不可替代性"在哪里？

很多人会问：Mojo这么火，会不会取代Python？我的答案是：至少在未来5年内不会。

Python的优势从来都不是性能，而是它那无可匹敌的生态系统和极低的学习门槛。经过二十多年的发展，Python已经积累了数百万个第三方库，覆盖了几乎所有你能想到的应用场景。从科学计算的NumPy、SciPy，到数据处理的pandas，再到机器学习的scikit-learn、TensorFlow、PyTorch，以及Web开发的Django、Flask、FastAPI，这些库都是经过了多年的打磨和验证，拥有庞大的用户群体和完善的文档。

更重要的是，Python已经成为了AI时代的通用语言。几乎所有的大模型框架和工具都是用Python开发的，所有的大模型厂商都提供了Python SDK。如果你想从事AI相关的工作，Python是你绕不开的选择。

当然，Python也有它的短板，比如性能问题、GIL锁的限制等。但这些问题正在被逐步解决。Python 3.13引入了实验性的无GIL模式，性能提升了约15%；PyPy解释器的性能已经接近C语言；而Cython、Numba等工具则可以让你在需要性能的地方轻松地编写高效的代码。

1.2 考核重点：从"会用"到"精通"的转变

2026年的Python面试，已经从过去的"考察你会不会用某个库"转变为"考察你是否真正理解Python的底层原理"。面试官不再满足于你能写出一个能运行的程序，而是更关心你写的程序是否高效、是否健壮、是否可维护。

具体来说，2026年Python面试的考核重点可以分为三个层次：

1.3 热点方向：2026年最值得关注的Python技术

• FastAPI异步后端：FastAPI已经彻底取代了Flask，成为了Python微服务架构的首选框架。它的性能接近Node.js和Go，同时又保持了Python的简洁和优雅。
• RAG检索增强生成：解决大模型"幻觉"问题的最有效方法，几乎所有的企业级大模型应用都会用到RAG技术。
• Agent智能体：大模型应用的下一个风口，能够让大模型自主完成复杂的任务。
• 向量数据库：AI时代的基础设施，用于存储和检索高维向量数据。
• 大模型本地部署与微调：随着开源大模型的性能不断提升，越来越多的企业开始选择在本地部署大模型，以保护数据安全和降低成本。

二、基础语法与核心概念：面试官最看重的基本功

很多人觉得基础语法太简单，不值得花太多时间去复习。但实际上，80%的面试失败都是因为基础不扎实。面试官通过基础问题，不仅能考察你对Python的熟悉程度，还能看出你的学习态度和思维方式。

2.1 list和tuple的区别：不仅仅是可变与不可变

这是Python面试中最经典的问题，没有之一。几乎每一场Python面试都会问到这个问题。但很多人的回答都只停留在"list可变，tuple不可变"这个层面，这只能让你拿到及格分。

想要拿到满分，你需要从以下几个方面来回答：

面试官的隐藏考点：既然tuple是不可变的，那为什么t = (1, [2, 3])中的列表可以修改？

答案：tuple的不可变性指的是tuple中元素的引用不可变，而不是元素本身不可变。在这个例子中，tuple中的第二个元素是一个列表的引用，这个引用是不可变的，但列表本身是可变的。

2.2 is和==：90%的人都会搞错的问题

这也是一个非常经典的问题，很多人都知道is比较的是身份，==比较的是值，但在实际应用中还是会出错。

• ==：比较两个对象的值是否相等。它会调用对象的__eq__()方法。
• is：比较两个对象的身份标识（内存地址）是否相等。它比较的是id(obj)的返回值。

常见的坑：小整数池和字符串驻留机制。

Python为了优化性能，会缓存一些常用的对象：

• 小整数池：缓存了-5到256之间的所有整数。
• 字符串驻留：缓存了由字母、数字和下划线组成的短字符串。

这就导致了以下看似奇怪的结果：

a = 100
b = 100
print(a is b) # True

a = 257
b = 257
print(a is b) # False

a = "hello"
b = "hello"
print(a is b) # True

a = "hello world"
b = "hello world"
print(a is b) # False

重要提醒：永远不要依赖小整数池和字符串驻留机制来使用is操作符。is只应该用于比较单例对象，比如None、True、False。

2.3 浅拷贝和深拷贝：面试官最喜欢的陷阱题

这是一个非常容易混淆的概念，也是面试官最喜欢出的陷阱题之一。

• 浅拷贝：创建一个新对象，但只复制原对象的引用，不复制嵌套对象。也就是说，原对象和新对象共享嵌套对象。
• 深拷贝：递归复制原对象及其所有嵌套对象。原对象和新对象完全独立，互不影响。

实现方式：

import copy

a = [1, [2, 3]]
b = copy.copy(a) # 浅拷贝
c = copy.deepcopy(a) # 深拷贝

a[0] = 100
a[1].append(4)

print(a) # [100, [2, 3, 4]]
print(b) # [1, [2, 3, 4]] 嵌套列表被修改了
print(c) # [1, [2, 3]] 完全没有被修改

哪些操作是浅拷贝？

• 切片操作：b = a[:]
• 工厂函数：b = list(a)、b = dict(a)
• copy.copy()函数

面试官的隐藏考点：如何实现一个自定义类的深拷贝？

答案：重写__deepcopy__()方法。

2.4 函数默认参数的坑：90%的Python开发者都踩过

这是Python中最著名的坑之一，几乎每一个Python开发者都踩过。

问题：为什么下面的函数每次调用都会返回不同的结果？

def func(a=[]):
a.append(1)
return a

print(func()) # [1]
print(func()) # [1, 1]
print(func()) # [1, 1, 1]

原因：Python函数的默认参数在函数定义时只计算一次，而不是在每次调用时计算。如果默认参数是可变对象（如列表、字典），那么多次调用函数会共享同一个对象。

正确的写法：使用None作为默认值，在函数内部创建新对象。

def func(a=None):
if a is None:
a = []
a.append(1)
return a

面试官的隐藏考点：为什么Python要这样设计？这样设计有什么好处？

答案：这样设计的好处是性能。如果默认参数在每次调用时都计算一次，那么对于那些计算成本很高的默认参数来说，会造成很大的性能浪费。

2.5 *args和**kwargs：灵活处理函数参数

*args和**kwargs是Python中非常强大的特性，允许函数接收任意数量的参数。

• *args：接收任意数量的位置参数，打包成一个元组。
• **kwargs：接收任意数量的关键字参数，打包成一个字典。

注意：在函数定义中，*args必须在**kwargs之前。

示例：

def func(*args, **kwargs):
print("位置参数:", args)
print("关键字参数:", kwargs)

func(1, 2, 3, name="Alice", age=25)
# 输出:
# 位置参数: (1, 2, 3)
# 关键字参数: {'name': 'Alice', 'age': 25}

进阶用法：解包参数。

def add(a, b):
return a + b

nums = [1, 2]
print(add(*nums)) # 3

params = {"a": 1, "b": 2}
print(add(**params)) # 3

三、面向对象编程：从入门到精通

面向对象编程是Python的核心特性之一，也是面试中必考的内容。面试官不仅会考察你对OOP基本概念的理解，还会考察你是否能够运用OOP的思想来设计和实现复杂的系统。

3.1 init__和__new：对象创建的完整流程

很多人都知道__init__方法是构造函数，用于初始化对象，但很少有人真正理解__new__方法的作用。

• __new__：创建对象时调用的第一个方法，负责创建并返回实例对象。它是一个类方法，第一个参数是cls。
• __init__：在__new__创建实例后调用，负责初始化实例对象。它是一个实例方法，第一个参数是self。

对象创建的完整流程：

什么时候需要重写__new__方法？

• 当你需要控制对象的创建过程时，比如实现单例模式。
• 当你需要继承不可变类型（如int、str、tuple）时。

示例：实现一个永远返回正数的整数类。

class PositiveInt(int):
def __new__(cls, value):
return super().__new__(cls, abs(value))

print(PositiveInt(–10)) # 10

3.2 实例方法、类方法和静态方法：别再傻傻分不清

这是OOP面试中最常问的问题之一，很多人都搞不清这三种方法的区别。

示例：

class MyClass:
class_var = 0 # 类属性

def __init__(self, instance_var):
self.instance_var = instance_var # 实例属性

def instance_method(self):
print(f"实例方法: {self.instance_var}, {self.class_var}")

@classmethod
def class_method(cls):
print(f"类方法: {cls.class_var}")
cls.class_var += 1

@staticmethod
def static_method():
print("静态方法")

面试官的隐藏考点：类方法和静态方法有什么区别？什么时候应该用类方法，什么时候应该用静态方法？

答案：类方法可以访问和修改类属性，而静态方法不能。如果你需要在方法中操作类属性，那么就用类方法；如果你的方法不需要访问类属性或实例属性，只是一个与类相关的工具函数，那么就用静态方法。

3.3 闭包：理解装饰器的前提

闭包是Python中一个非常重要的概念，也是理解装饰器的前提。很多人觉得闭包很抽象，难以理解，但实际上它非常简单。

什么是闭包？
闭包是指一个嵌套函数引用了外部函数作用域中的变量，并且外部函数返回了这个嵌套函数。闭包会保留外部函数的变量状态，即使外部函数已经执行完毕。

示例：

def outer(x):
def inner(y):
return x + y
return inner

add5 = outer(5)
print(add5(3)) # 8
print(add5(10)) # 15

在这个例子中，inner函数引用了外部函数outer的变量x，并且outer返回了inner函数。这就是一个闭包。当outer(5)执行完毕后，变量x的值5会被保留下来，供add5函数使用。

闭包的作用：

• 保留函数的状态。
• 实现数据隐藏。
• 是实现装饰器的基础。

3.4 装饰器：Python最优雅的特性之一

装饰器是Python中最优雅、最强大的特性之一。它允许你在不修改原函数代码的情况下，扩展函数的功能。

装饰器的本质：一个接收函数作为参数并返回新函数的高阶函数。

示例：实现一个计时装饰器。

import time

def timer(func):
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
print(f"{func.__name__}执行时间: {time.time()–start:.2f}秒")
return result
return wrapper

@timer
def my_func():
time.sleep(1)

my_func()

装饰器的进阶用法：

• 带参数的装饰器。
• 保留原函数的元数据（使用functools.wraps）。
• 类装饰器。

面试官的隐藏考点：如何实现一个带参数的装饰器？

答案：带参数的装饰器实际上是一个返回装饰器的函数。

def repeat(times):
def decorator(func):
def wrapper(*args, **kwargs):
for _ in range(times):
result = func(*args, **kwargs)
return result
return wrapper
return decorator

@repeat(3)
def say_hello():
print("Hello!")

say_hello() # 输出3次Hello!

3.5 单例模式：5种实现方式的优缺点对比

单例模式是最常用的设计模式之一，它确保一个类只有一个实例，并提供一个全局访问点。

Python中有多种实现单例模式的方式，每种方式都有其优缺点：

class Singleton:
_instance = None

def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance

优点：简单直观。
缺点：不是线程安全的。

def singleton(cls):
instances = {}

def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]

return wrapper

@singleton
class MyClass:
pass

优点：可以装饰多个类，代码复用性好。
缺点：不是线程安全的。

# singleton.py
class Singleton:
pass

singleton_instance = Singleton()

# 使用
from singleton import singleton_instance

优点：最简单、最推荐的方式。
缺点：不够灵活。

class SingletonMeta(type):
_instances = {}

def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]

class Singleton(metaclass=SingletonMeta):
pass

优点：真正的单例，线程安全。
缺点：比较复杂。

import threading

class Singleton:
_instance = None
_lock = threading.Lock()

def __new__(cls, *args, **kwargs):
if cls._instance is None:
with cls._lock:
if cls._instance is None:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance

优点：线程安全。
缺点：有一定的性能开销。

四、数据结构与算法：Python工程师的核心竞争力

数据结构与算法是所有程序员的基本功，也是面试中区分优秀工程师和普通工程师的关键。很多Python开发者觉得自己是做应用开发的，不需要懂太多算法，但实际上，掌握常用的数据结构和算法，能够让你写出更高效、更优雅的代码。

4.1 Python字典的底层原理：哈希表的艺术

Python字典是最常用的数据结构之一，它的性能非常出色，平均时间复杂度为O(1)。但你知道它的底层是如何实现的吗？

Python字典基于哈希表实现。哈希表是一种根据键（Key）直接访问值（Value）的数据结构。它的核心思想是将键通过哈希函数转换为一个索引，然后通过这个索引直接访问数组中的值。

Python字典的实现细节：

面试官的隐藏考点：为什么Python 3.3之前使用链表法解决哈希冲突，而3.3之后改用开放寻址法？

答案：开放寻址法的缓存局部性更好，因为所有的数据都存储在同一个数组中，而链表法需要访问多个分散的节点。这使得开放寻址法在现代CPU上的性能更好。

4.2 生成器：节省内存的利器

生成器是Python中一个非常强大的特性，它允许你按需生成元素，而不是一次性生成所有元素。这在处理大数据集时非常有用，可以节省大量的内存。

什么是生成器？
生成器是一种特殊的迭代器。它不需要实现__iter__()和__next__()方法，只需要使用yield关键字。

创建生成器的两种方式：

# 列表推导式：立即生成所有元素，占用大量内存
list_comp = [x*2 for x in range(1000000)]

# 生成器表达式：按需生成元素，几乎不占用内存
gen_exp = (x*2 for x in range(1000000))

def fibonacci(n):
a, b = 0, 1
for _ in range(n):
yield b
a, b = b, a + b

# 生成前10个斐波那契数
for num in fibonacci(10):
print(num)

生成器的优势：

• 节省内存：不需要一次性存储所有元素。
• 惰性计算：只有在需要时才生成元素。
• 可以表示无限序列。

4.3 迭代器：Python的统一访问接口

迭代器是Python中一个非常重要的概念，它提供了一种统一的方式来访问不同类型的集合。

什么是迭代器？
迭代器是实现了__iter__()和__next__()方法的对象。

• __iter__()：返回迭代器自身。
• __next__()：返回下一个元素，没有更多元素时抛出StopIteration异常。

什么是可迭代对象？
可迭代对象是可以被iter()函数转换为迭代器的对象。所有的序列类型（如list、tuple、str）和非序列类型（如dict、set、文件对象）都是可迭代对象。

迭代器的工作原理：

nums = [1, 2, 3]
it = iter(nums) # 获取迭代器

print(next(it)) # 1
print(next(it)) # 2
print(next(it)) # 3
print(next(it)) # 抛出StopIteration异常

for循环的本质：
for循环实际上是先调用iter()函数获取可迭代对象的迭代器，然后不断调用next()函数获取下一个元素，直到抛出StopIteration异常为止。

4.4 collections模块：Python内置的高效数据结构

Python的collections模块提供了一些内置数据结构的扩展，这些数据结构比普通的list、dict、tuple更加高效和灵活。

collections模块中最常用的类：

from collections import Counter

words = ["apple", "banana", "apple", "orange", "banana", "apple"]
count = Counter(words)
print(count) # Counter({'apple': 3, 'banana': 2, 'orange': 1})
print(count.most_common(2)) # [('apple', 3), ('banana', 2)]

from collections import defaultdict

d = defaultdict(int)
d["a"] += 1
print(d["a"]) # 1
print(d["b"]) # 0

from collections import deque

q = deque([1, 2, 3])
q.appendleft(0)
q.append(4)
print(q) # deque([0, 1, 2, 3, 4])
print(q.popleft()) # 0
print(q.pop()) # 4

from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(1, 2)
print(p.x) # 1
print(p.y) # 2

五、高级特性与性能优化：从中级到高级的必经之路

如果你想成为一名高级Python工程师，那么你必须掌握Python的一些高级特性，并且懂得如何优化Python代码的性能。

5.1 GIL：Python最受争议的特性

GIL（Global Interpreter Lock，全局解释器锁）是Python最受争议的特性之一，也是很多人诟病Python性能差的主要原因。

什么是GIL？
GIL是Python解释器中的一个互斥锁，它保证同一时刻只有一个线程执行Python字节码。

为什么要有GIL？
GIL的存在主要是为了简化Python解释器的实现，并且保证线程安全。在CPython的内存管理中，引用计数是一种非常重要的垃圾回收机制。如果没有GIL，那么多个线程同时修改同一个对象的引用计数，就会导致引用计数不准确，从而造成内存泄漏或者对象被错误释放。

GIL对Python的影响：

• CPU密集型任务：多线程无法利用多核优势，因为同一时刻只有一个线程在执行。
• I/O密集型任务：多线程仍然有效，因为在I/O等待时，线程会释放GIL，让其他线程执行。

如何绕过GIL的限制？

5.2 上下文管理器：自动管理资源的优雅方式

上下文管理器是Python中一种非常优雅的资源管理方式，它可以确保资源在使用后被正确释放，无论是否发生异常。

什么是上下文管理器？
实现了__enter__()和__exit__()方法的对象就是上下文管理器。

with语句的工作原理：

with context_manager as var:
# 执行代码

示例：实现一个文件上下文管理器。

class File:
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()
return False

with File("test.txt", "w") as f:
f.write("Hello, World!")

更简单的方式：使用contextlib装饰器

from contextlib import contextmanager

@contextmanager
def file(filename, mode):
f = open(filename, mode)
try:
yield f
finally:
f.close()

with file("test.txt", "w") as f:
f.write("Hello, World!")

5.3 asyncio异步编程：Python高并发的解决方案

异步编程是Python 3.5+引入的一个非常重要的特性，它允许你在单线程中实现高并发，特别适合I/O密集型任务。

asyncio的核心概念：

示例：一个简单的异步程序。

import asyncio

async def say_hello(name, delay):
await asyncio.sleep(delay)
print(f"Hello, {name}!")

async def main():
# 创建两个任务
task1 = asyncio.create_task(say_hello("Alice", 1))
task2 = asyncio.create_task(say_hello("Bob", 2))

# 等待两个任务完成
await task1
await task2

asyncio.run(main())

异步编程的优势：

• 单线程实现高并发，资源消耗低。
• 避免了多线程编程中的锁竞争问题。
• 代码结构清晰，可读性好。

注意：异步编程只适合I/O密集型任务，不适合CPU密集型任务。

5.4 类型提示：让Python代码更加健壮

类型提示是Python 3.5+引入的一个特性，用于标注变量、函数参数和返回值的类型。虽然Python是一门动态类型语言，但类型提示可以让你的代码更加可读、更加健壮。

类型提示的基本用法：

def add(a: int, b: int) –> int:
return a + b

name: str = "Alice"
age: int = 25

常用的类型：

• 基本类型：int、float、str、bool、None
• 容器类型：list[int]、dict[str, int]、tuple[int, str]、set[str]
• 联合类型：Union[int, str]（Python 3.10+可以写成int | str）
• 可选类型：Optional[int]（等价于Union[int, None]）
• 任意类型：Any

类型提示的好处：

六、后端开发：2026年Python最主流的就业方向

后端开发是Python最主流的就业方向之一。2026年，FastAPI已经彻底取代了Flask，成为了Python微服务架构的首选框架。

6.1 Django、Flask和FastAPI：三大框架的全面对比

FastAPI为什么这么火？

6.2 FastAPI核心特性深度解析

1. 路径参数和查询参数

from fastapi import FastAPI

app = FastAPI()

# 路径参数
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
return {"item_id": item_id, "q": q}

2. 请求体

from pydantic import BaseModel

class Item(BaseModel):
name: str
price: float
is_offer: bool | None = None

@app.post("/items/")
async def create_item(item: Item):
return item

3. 依赖注入

from fastapi import Depends

def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()

@app.get("/items/")
async def read_items(db: Session = Depends(get_db)):
return db.query(Item).all()

4. 认证与授权
FastAPI提供了多种认证方式，包括OAuth2、JWT等。

6.3 ORM与数据库：SQLAlchemy 2.0的新特性

ORM（Object-Relational Mapping，对象关系映射）将数据库表映射为Python类，将表记录映射为对象，让你可以用面向对象的方式来操作数据库，而不需要编写原生的SQL语句。

SQLAlchemy是Python最流行的ORM框架，2023年发布的SQLAlchemy 2.0带来了很多新特性和改进。

SQLAlchemy 2.0的核心概念：

示例：

from sqlalchemy import create_engine, Column, Integer, String, select
from sqlalchemy.orm import declarative_base, sessionmaker

# 创建引擎
engine = create_engine("sqlite:///test.db")

# 创建基类
Base = declarative_base()

# 定义模型
class User(Base):
__tablename__ = "users"

id = Column(Integer, primary_key=True)
name = Column(String)
age = Column(Integer)

# 创建表
Base.metadata.create_all(engine)

# 创建会话
Session = sessionmaker(bind=engine)
session = Session()

# 添加用户
user = User(name="Alice", age=25)
session.add(user)
session.commit()

# 查询用户
stmt = select(User).where(User.name == "Alice")
result = session.execute(stmt)
user = result.scalar_one()
print(user.name, user.age)

6.4 JWT认证：无状态认证的最佳实践

JWT（JSON Web Token）是一种无状态的认证机制，它将用户信息加密在令牌中，服务器不需要存储任何会话信息，非常适合分布式系统和微服务架构。

JWT的工作流程：

JWT的结构：
JWT由三部分组成，用点（.）分隔：

在FastAPI中使用JWT认证：

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from jose import JWTError, jwt
from passlib.context import CryptContext
from datetime import datetime, timedelta

# 配置
SECRET_KEY = "your-secret-key"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

# 密码上下文
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

# OAuth2方案
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

app = FastAPI()

# 模拟用户数据库
fake_users_db = {
"alice": {
"username": "alice",
"hashed_password": pwd_context.hash("secret"),
}
}

# 验证密码
def verify_password(plain_password, hashed_password):
return pwd_context.verify(plain_password, hashed_password)

# 创建访问令牌
def create_access_token(data: dict, expires_delta: timedelta | None = None):
to_encode = data.copy()
if expires_delta:
expire = datetime.utcnow() + expires_delta
else:
expire = datetime.utcnow() + timedelta(minutes=15)
to_encode.update({"exp": expire})
encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
return encoded_jwt

# 获取当前用户
async def get_current_user(token: str = Depends(oauth2_scheme)):
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
try:
payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
username: str = payload.get("sub")
if username is None:
raise credentials_exception
except JWTError:
raise credentials_exception
user = fake_users_db.get(username)
if user is None:
raise credentials_exception
return user

# 登录接口
@app.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
user = fake_users_db.get(form_data.username)
if not user or not verify_password(form_data.password, user["hashed_password"]):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Incorrect username or password",
headers={"WWW-Authenticate": "Bearer"},
)
access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
access_token = create_access_token(
data={"sub": user["username"]}, expires_delta=access_token_expires
)
return {"access_token": access_token, "token_type": "bearer"}

# 受保护的接口
@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
return current_user

七、数据科学与AI/大模型：2026年最热门的Python方向

AI/大模型是2026年最热门的技术方向，也是Python薪资溢价最高的领域。几乎所有的大模型框架和工具都是用Python开发的，掌握Python是进入AI领域的必备条件。

7.1 NumPy与pandas：数据科学的基础

NumPy和pandas是Python数据科学栈的基础。NumPy提供了高性能的多维数组和数学函数，pandas则提供了高效的数据处理和分析工具。

NumPy数组与Python列表的区别：

为什么要避免在pandas中使用for循环？
pandas的for循环是纯Python实现的，速度非常慢。而pandas的向量化操作是基于C实现的，速度比for循环快100倍以上。

替代for循环的方法：

7.2 RAG检索增强生成：解决大模型"幻觉"的终极方案

大模型虽然强大，但它有一个致命的缺点：“幻觉”。大模型经常会编造一些不存在的事实，这在企业级应用中是不可接受的。

RAG（Retrieval-Augmented Generation，检索增强生成）是解决大模型"幻觉"问题的最有效方法。它的核心思想是：让大模型在回答问题之前，先从外部知识库中检索相关的信息，然后基于这些信息生成回答。

RAG的工作流程：

RAG的优势：

7.3 向量数据库：AI时代的基础设施

向量数据库是专门用于存储和检索高维向量数据的数据库。它支持相似性搜索，可以快速找到与查询向量最相似的向量。

2026年最流行的向量数据库：

在Python中使用Chroma：

import chromadb
from chromadb.utils import embedding_functions

# 创建客户端
client = chromadb.Client()

# 创建集合
collection = client.create_collection("my_collection")

# 添加文档
collection.add(
documents=["This is a document about cats", "This is a document about dogs"],
metadatas=[{"source": "animal_book"}, {"source": "animal_book"}],
ids=["doc1", "doc2"]
)

# 查询
results = collection.query(
query_texts=["What is a cat?"],
n_results=1
)

print(results)

7.4 Agent智能体：大模型应用的下一个风口

Agent智能体是大模型应用的下一个风口。它能够让大模型自主完成复杂的任务，而不仅仅是生成文本。

什么是Agent？
Agent是一个能够感知环境、做出决策并执行动作的智能体。一个典型的Agent由以下几个部分组成：

Agent的工作流程：

常用的Agent框架：

7.5 大模型本地部署与微调：企业级应用的必备技能

随着开源大模型的性能不断提升，越来越多的企业开始选择在本地部署大模型，以保护数据安全和降低成本。

常用的开源大模型：

大模型本地部署工具：

在Python中使用Ollama：

import ollama

response = ollama.chat(model='llama3', messages=[
{
'role': 'user',
'content': 'Why is the sky blue?',
},
])
print(response['message']['content'])

八、工程化与部署：从代码到生产的最后一公里

写出能运行的代码只是第一步，写出能在生产环境中稳定运行的代码才是真正的挑战。工程化与部署能力是区分初级工程师和高级工程师的重要标志。

8.1 代码质量与测试：写出健壮的Python代码

代码质量：

• 遵循PEP 8编码规范。
• 使用有意义的变量名和函数名。
• 编写清晰的注释和文档字符串。
• 避免重复代码（DRY原则）。
• 保持函数和类的单一职责。

测试：
测试是保证代码质量的重要手段。Python中有两个常用的测试框架：unittest和pytest。

unittest vs pytest：

• unittest：Python内置的测试框架，基于类和方法，语法相对繁琐。
• pytest：第三方测试框架，语法更简洁，功能更强大，支持简单的函数式测试，拥有丰富的插件生态。

pytest示例：

# test_add.py
def add(a, b):
return a + b

def test_add():
assert add(1, 2) == 3
assert add(0, 0) == 0
assert add(–1, 1) == 0

8.2 虚拟环境与依赖管理：避免"在我电脑上能运行"

虚拟环境是一个独立的Python运行环境，包含自己的解释器、库和脚本。使用虚拟环境可以隔离不同项目的依赖，避免版本冲突。

常用的虚拟环境工具：

poetry的基本用法：

# 创建新项目
poetry new my_project

# 进入项目目录
cd my_project

# 添加依赖
poetry add requests

# 安装依赖
poetry install

# 运行脚本
poetry run python script.py

8.3 部署：将Python应用推向生产

常见的Python应用部署方式：

九、常见算法手写题：面试必背

算法手写题是Python面试中必考的内容，尤其是大厂面试。以下是最常考的几道算法题，一定要熟练掌握。

9.1 LRU缓存

from collections import OrderedDict

class LRUCache:
def __init__(self, capacity: int):
self.cache = OrderedDict()
self.capacity = capacity

def get(self, key: int) –> int:
if key not in self.cache:
return –1
self.cache.move_to_end(key)
return self.cache[key]

def put(self, key: int, value: int) –> None:
if key in self.cache:
self.cache.move_to_end(key)
self.cache[key] = value
if len(self.cache) > self.capacity:
self.cache.popitem(last=False)

9.2 快速排序

def quicksort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quicksort(left) + middle + quicksort(right)

9.3 二分查找

def binary_search(arr, target):
left, right = 0, len(arr) – 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid – 1
return –1

9.4 反转链表

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

9.5 两数之和

def two_sum(nums, target):
num_map = {}
for i, num in enumerate(nums):
complement = target – num
if complement in num_map:
return [num_map[complement], i]
num_map[num] = i
return []

十、面试备考建议与职业发展方向

10.1 面试备考建议

10.2 职业发展方向

结语

Python是一门非常强大的语言，它的应用场景非常广泛，从Web开发到数据科学，从机器学习到大模型应用，几乎无处不在。2026年，Python依然是最值得学习的编程语言之一。

但同时我们也要看到，Python面试的难度在不断提升，对工程师的要求也越来越高。过去那种"会写几个脚本就能找到工作"的时代已经一去不复返了。现在的Python工程师，不仅要有扎实的基础功底和工程能力，还要具备AI集成能力和系统思维。

希望这篇文章能够帮助你全面了解2026年Python面试的核心考点，顺利通过面试，拿到心仪的offer。记住，学习是一个持续的过程，只有不断学习，不断进步，才能在这个快速变化的行业中立于不败之地。

附录一：2026年字节/阿里/腾讯Python真实面经（第一季度）

字节跳动：算法硬功+工程能力双核心

面试风格：节奏快、压强高，算法占比40%，基础深挖到底，AI相关问题从2025年的15%提升至25%。一面必3道算法题限时30分钟，二面开始结合项目深挖技术细节。

后端开发工程师（3年经验，北京，年薪45W）

一面（技术面，60分钟）

二面（技术面，70分钟）

三面（技术面+HR面，60分钟）

大模型应用工程师（2年经验，上海，年薪55W）

一面（技术面，60分钟）

二面（技术面，70分钟）

阿里巴巴：业务理解+AI落地能力

面试风格：注重技术与业务的结合，大模型相关问题占比30%，喜欢问场景题和开放性问题。面试官会不断追问，直到你答不上来为止，考察你的思考深度。

大模型应用工程师（3年经验，杭州，年薪50W）

一面（技术面，60分钟）

二面（技术面，70分钟）

三面（技术面+HR面，60分钟）

后端开发工程师（2年经验，深圳，年薪40W）

一面（技术面，60分钟）

腾讯：底层原理+高并发场景

面试风格：非常看重底层原理和性能优化，算法占比35%，喜欢问网络和数据库的底层问题。后端岗位会重点考察高并发、分布式场景的处理能力。

后端开发工程师（3年经验，广州，年薪48W）

一面（技术面，60分钟）

二面（技术面，70分钟）

三面（技术面+HR面，60分钟）

附录二：3个月Python面试备考计划（2026版）

适用人群：有1-3年Python开发经验，准备跳槽到字节/阿里/腾讯等大厂的工程师。
每日学习时间：3-4小时（工作日），6-8小时（周末）。
核心目标：夯实基础，掌握后端和AI核心技术，刷完150道算法题，完成2个高质量项目，顺利通过大厂面试。

第一阶段：基础夯实期（第1-4周）

目标：彻底掌握Python核心概念和数据结构，解决80%的基础面试题。

第1周：Python核心语法

• 学习内容：
  • 变量与数据类型（重点：字符串、列表、字典、元组的特性和使用场景）
  • 控制流（if/for/while、列表推导式、生成器表达式）
  • 函数（参数、返回值、作用域、闭包、装饰器）
  • 异常处理（try/except/finally、自定义异常）
  • 模块与包（import机制、相对导入与绝对导入）
• 必做练习：
  • 实现一个带参数的计时装饰器
  • 实现一个简单的上下文管理器
  • 完成10道Python基础编程题
• 面试重点：
  • list和tuple的区别
  • is和==的区别
  • 浅拷贝和深拷贝的区别
  • 函数默认参数的坑
  • *args和**kwargs的作用

第2周：面向对象编程

• 学习内容：
  • 类与对象（属性、方法、构造函数）
  • 继承与多态（单继承、多继承、方法重写）
  • 特殊方法（init、new、str、__repr__等）
  • 访问控制（public、protected、private）
  • 设计模式（单例模式、工厂模式、观察者模式）
• 必做练习：
  • 用5种方式实现单例模式
  • 实现一个简单的工厂模式
  • 完成一个面向对象的小项目（如学生管理系统）
• 面试重点：
  • __init__和__new__的区别
  • 实例方法、类方法和静态方法的区别
  • 闭包和装饰器的原理
  • 单例模式的实现方式和优缺点

第3周：数据结构与算法基础

• 学习内容：
  • Python内置数据结构的底层实现（重点：字典、集合、列表）
  • 线性表（数组、链表）
  • 栈与队列
  • 树与二叉树（二叉树的遍历、二叉搜索树）
  • 哈希表
• 必做练习：
  • 实现一个链表
  • 实现一个栈和队列
  • 完成LeetCode简单题20道（数组、链表、哈希表专题）
• 面试重点：
  • 字典的底层原理
  • 生成器和迭代器的区别
  • collections模块的常用类
  • 常见数据结构的时间复杂度

第4周：Python高级特性

• 学习内容：
  • 内存管理（垃圾回收机制、引用计数、分代回收）
  • GIL锁（工作原理、影响、解决方案）
  • 并发编程（多线程、多进程、协程）
  • 上下文管理器
  • 类型提示
• 必做练习：
  • 用多线程和多进程分别实现一个爬虫
  • 用asyncio实现一个简单的异步HTTP服务器
  • 完成LeetCode简单题10道
• 面试重点：
  • GIL锁的工作原理和影响
  • 多线程和多进程的区别
  • 异步编程的核心概念
  • 上下文管理器的实现原理

第二阶段：进阶提升期（第5-8周）

目标：掌握后端开发和AI大模型应用的核心技术，完成2个高质量项目。

第5周：后端开发基础

• 学习内容：
  • FastAPI框架（路由、请求体、依赖注入、认证授权）
  • SQLAlchemy 2.0（ORM、查询、事务）
  • MySQL数据库（SQL语法、索引、事务、优化）
  • Redis（数据结构、持久化、缓存策略）
• 必做练习：
  • 用FastAPI+SQLAlchemy实现一个简单的博客系统
  • 完成10道MySQL复杂查询题
  • 学习Redis的5种数据结构的使用场景
• 面试重点：
  • FastAPI的核心优势
  • SQLAlchemy的核心概念
  • MySQL索引的底层原理
  • Redis的缓存问题（穿透、击穿、雪崩）

第6周：后端开发进阶

• 学习内容：
  • RESTful API设计
  • JWT认证
  • 消息队列（RabbitMQ、Kafka）
  • 微服务架构基础
  • Docker容器化
• 必做练习：
  • 给博客系统添加JWT认证
  • 用Docker打包博客系统
  • 学习消息队列的基本使用
• 面试重点：
  • JWT的工作原理
  • 微服务架构的优缺点
  • Docker的基本命令和原理
  • 消息队列的使用场景

第7周：AI大模型应用基础

• 学习内容：
  • 大模型API调用（OpenAI、通义千问、文心一言）
  • Prompt Engineering（基础技巧、Few-shot、CoT）
  • RAG检索增强生成（完整流程、向量数据库）
  • LangChain框架（核心组件、使用方法）
• 必做练习：
  • 调用大模型API实现一个简单的聊天机器人
  • 用LangChain+Chroma实现一个简单的RAG问答系统
  • 学习不同的Prompt技巧并实践
• 面试重点：
  • RAG的完整流程和每个环节的问题
  • 向量数据库的作用和常用产品
  • LangChain的核心组件
  • Prompt Engineering的常用技巧

第8周：AI大模型应用进阶

• 学习内容：
  • Agent智能体（核心模块、工作原理）
  • RAG优化技巧（Chunking、检索重排序、多轮检索）
  • 大模型本地部署（Ollama、transformers）
  • 大模型应用的评估方法
• 必做练习：
  • 用LangChain实现一个简单的Agent
  • 优化之前的RAG系统，提升回答准确率
  • 用Ollama本地部署一个开源大模型
• 面试重点：
  • Agent的核心模块和工作流程
  • RAG的优化方法
  • 大模型本地部署的工具和方法
  • 如何评估大模型应用的效果

第三阶段：冲刺准备期（第9-12周）

目标：刷完150道算法题，完善项目，进行模拟面试，准备简历和面试话术。

第9-10周：算法刷题

• 刷题计划：
  • 每天刷5道题，周末刷10道题，总共刷100道题
  • 重点刷：数组、链表、哈希表、树、动态规划、字符串专题
  • 必背题：LRU缓存、快速排序、二分查找、反转链表、两数之和、有效的括号
• 刷题方法：
  • 第一遍：自己做，不会就看题解，理解思路
  • 第二遍：不看题解，自己写出来
  • 第三遍：复习，总结解题思路和模板
• 面试重点：
  • 字节跳动：喜欢考动态规划、树、字符串
  • 阿里巴巴：喜欢考数组、哈希表、链表
  • 腾讯：喜欢考树、动态规划、数组

第11周：项目完善与简历准备

• 项目完善：
  • 完善之前做的FastAPI博客系统和RAG问答系统
  • 给项目添加更多功能，优化性能和代码质量
  • 准备项目讲解的STAR法则话术（Situation、Task、Action、Result）
  • 准备项目中可能被问到的技术问题
• 简历准备：
  • 突出Python相关的技能和项目经验
  • 量化项目成果（如：接口响应时间从500ms降到50ms，QPS提升10倍）
  • 避免写"精通Python"这种空话，要具体写掌握的技术栈
  • 简历控制在1-2页，重点突出

第12周：模拟面试与查漏补缺

• 模拟面试：
  • 找朋友或同事进行模拟面试，按照真实面试流程进行
  • 录制自己的面试过程，复盘表现
  • 重点练习自我介绍、项目讲解、算法题手写
• 查漏补缺：
  • 复习之前学过的所有知识点，重点看自己薄弱的部分
  • 看最新的面经，了解最新的面试趋势
  • 准备一些开放性问题的答案（如：职业规划、为什么想加入我们公司）
• 面试注意事项：
  • 提前10分钟进入面试会议室
  • 穿着整洁，保持良好的精神状态
  • 回答问题时要逻辑清晰，条理分明
  • 遇到不会的问题不要慌，诚实告诉面试官，并说出自己的思考过程
  • 面试结束后要向面试官表示感谢