Python 面试高频题：从可变对象到垃圾回收机制

💡 加分句：

'我曾在一个配置管理系统中误用了浅拷贝，导致修改一个实例的配置影响了全局。后来统一改用 deepcopy，虽然牺牲一点性能，但保证了安全性。'

🎯 3. return 和 yield 的区别

关键词：函数 vs 生成器、一次性返回 vs 惰性迭代、状态保存

✅ 标准回答：

两者都用于从函数中'产出'值，但本质不同：

🔸 return：

• 结束函数执行，返回一个值（或 None）。
• 函数调用后立即释放栈帧，无法恢复状态。
• 适合计算并返回单一结果。

🔸 yield：

• 将函数变为生成器函数，每次调用返回一个值并暂停执行。
• 下次调用时从上次暂停处继续，保留局部变量状态。
• 适合处理大数据流、无限序列、节省内存。

🔹 示例：

def func_return():
    return [1, 2, 3] # 立即构建完整列表

def func_yield():
    yield 1
    yield 2
    yield 3 # 按需生成，占用内存小

g = func_yield()
print(next(g)) # 1
print(next(g)) # 2

💡 加分句：

'我在处理日志文件解析时，用 yield 逐行读取，避免一次性加载大文件到内存。而 return 更适合像数学计算这样需要立即得到结果的场景。'

🎯 4. 用过 Python 中的 Lambda 函数没？说一下理解吧

关键词：匿名函数、单表达式、函数式编程、map/filter/sorted

✅ 标准回答：

Lambda 是 Python 中的匿名函数，语法简洁，适用于简单逻辑。

🔸 语法：

lambda 参数：表达式

• 只能包含一个表达式，不能有复杂语句（如 if/for/try）。
• 通常配合 map, filter, sorted 等高阶函数使用。

🔹 示例：

# 排序按第二个元素
pairs = [(1, 'one'), (2, 'two'), (3, 'three')]
sorted(pairs, key=lambda x: x[1])

# 过滤偶数
evens = list(filter(lambda x: x % 2 == 0, range(10)))

⚠️ 注意：

• 不要过度使用 lambda，复杂逻辑应定义为普通函数，提高可读性。
• Lambda 不能包含赋值、循环、异常处理等语句。

💡 加分句：

'我习惯在 sorted/key 或回调函数中用 lambda，但在业务逻辑中会避免它——毕竟'代码是写给人看的'，命名函数更清晰。'

🎯 5. 装饰器用过没？说一下是什么？怎么实现？以及用处在哪？

关键词：高阶函数、闭包、@语法、AOP 思想、日志/权限/缓存

✅ 标准回答：

装饰器是在不修改原函数代码的前提下，为其添加额外功能的机制，本质是高阶函数 + 闭包。

🔸 基本原理：

def decorator(func):
    def wrapper(*args, **kwargs):
        print("Before")
        result = func(*args, **kwargs)
        print("After")
        return result
    return wrapper

@decorator
def say_hello():
    print("Hello")

say_hello() # 输出:
            # Before
            # Hello
            # After

🔹 常见用途：

• 日志记录
• 权限校验
• 缓存（memoization）
• 事务控制
• 性能计时

🔸 带参数的装饰器：

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

@repeat(3)
def greet():
    print("Hi")

💡 加分句：

'我在 Web 项目中用装饰器做了统一的 JWT 鉴权和接口耗时统计，极大减少了重复代码。记住：装饰器要尽量轻量，避免嵌套过深影响调试。'

🎯 6. 用 Python 实现一个单例模式

关键词：new、metaclass、模块级单例、线程安全

✅ 标准回答：

Python 有多种实现单例的方式，推荐以下三种：

🔸 方法一：重写 new（经典）

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

🔸 方法二：使用 metaclass（优雅）

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 Database(metaclass=SingletonMeta):
    pass

🔸 方法三：模块级单例（最简单）

# singleton.py
_instance = None
def get_instance():
    global _instance
    if _instance is None:
        _instance = SomeClass()
    return _instance

⚠️ 线程安全问题： 上述方法在多线程环境下可能创建多个实例。解决方案：

• 加锁（threading.Lock）
• 使用 functools.lru_cache 或 once 库

💡 加分句：

'在实际项目中，我更倾向用模块级单例或依赖注入框架（如 Flask 的 app.context），因为显式的单例类容易隐藏依赖关系，不利于测试。'

🎯 7. python3 和 python2 的对比

关键词：print 函数、Unicode、除法、range/xrange、语法糖

✅ 标准回答：

Python 3 是重大升级，主要改进如下：

💡 加分句：

'Python 2 已于 2020 年停止维护，现在所有新项目都必须用 Python 3。迁移时最大痛点是编码问题——Py3 默认 UTF-8，Py2 默认 ASCII，需特别注意字符串处理。'

🎯 8. python 的可变/不可变对象介绍下

关键词：内存地址、id()、hashability、副作用

✅ 标准回答：

Python 对象分为可变和不可变两类，直接影响程序行为和性能。

🔸 不可变对象：

• 值一旦创建就不能修改。
• 包括：int, float, str, tuple, frozenset, bool
• 特点：
  • 可哈希（可用作 dict 键）
  • 多线程安全
  • 修改实际是创建新对象

🔸 可变对象：

• 值可以在原地修改。
• 包括：list, dict, set, bytearray
• 特点：
  • 不可哈希（不能作 dict 键）
  • 多线程需注意同步
  • 修改不改变内存地址

🔹 验证示例：

a = [1, 2]
b = a
a.append(3)
print(b) # [1, 2, 3] ← b 也变了！

c = "hello"
d = c
d += " world"
print(d) # "hello" ← d 不变，c 指向新对象

💡 加分句：

'我曾在一个函数中传入列表并修改它，导致调用方意外被影响。后来养成习惯：如果不想修改原对象，先拷贝一份再操作。'

🎯 9. 说一说 Python 的内存管理

关键词：私有堆、引用计数、垃圾回收、内存池、小整数缓存

✅ 标准回答：

Python 内存由解释器自动管理，开发者无需手动分配/释放。

🔸 核心机制：

1. 私有堆空间：所有对象和数据结构存储在私有堆中，由 Pymalloc 管理。
2. 引用计数：每个对象维护一个计数器，归零时立即释放。
3. 垃圾回收器：处理循环引用（引用计数无法解决）。
4. 内存池：对小对象（<512 字节）进行池化管理，减少 malloc/free 开销。
5. 小整数缓存：[-5, 256] 范围内的整数预先创建，复用对象。

🔹 查看引用计数：

import sys
a = []
print(sys.getrefcount(a)) # 注意：getrefcount 本身会增加一次引用

💡 加分句：

'虽然 Python 自动管理内存，但我们仍需注意循环引用和大对象泄漏。比如用 weakref 避免强引用环，或用 tracemalloc 分析内存增长。'

🎯 10. 说一说 Python 的垃圾回收机制

关键词：引用计数、标记 - 清除、分代回收、gc 模块

✅ 标准回答：

Python 垃圾回收是混合机制，结合三种策略：

🔸 1. 引用计数（Reference Counting）

• 主流机制：每个对象维护 ob_refcnt，归零即释放。
• 优点：实时、高效。
• 缺点：无法处理循环引用（如 A 引用 B，B 引用 A）。

🔸 2. 标记 - 清除（Mark-and-Sweep）

• 解决循环引用问题。
• 定期遍历所有对象，标记可达对象，清除未标记对象。
• 触发条件：分配/释放对象达到阈值。

🔸 3. 分代回收（Generational Collection）

• 基于'对象越年轻，越容易死亡'的假设。
• 将对象分为三代（0, 1, 2），新生代频繁回收，老代低频回收。
• 通过 gc.collect() 手动触发。

🔹 相关模块：

import gc
gc.enable() # 启用 GC
gc.disable() # 禁用 GC（慎用）
gc.collect() # 强制回收
gc.get_objects() # 获取所有 tracked 对象

💡 加分句：

'我在长运行服务中曾遇到内存缓慢增长的问题，通过 tracemalloc 定位到是循环引用导致的。后来用 weakref 打破引用环，并调整 gc.set_threshold() 优化回收频率。'

🧠 总结：面试答题技巧