Python面试常考这100题,第27题90%的人会答错……

print(isinstance(10, object))  # Trueprint(isinstance("hello", object))  # Trueprint(isinstance(print, object))  # True

a = [1, 2]b = [1, 2]print(a == b)  # True，值相等print(a is b)  # False，内存地址不同

# 不可变对象a = "hello"a += " world"# 创建了新字符串，原来的被回收print(id(a))  # id 改变了# 可变对象lst = [1, 2, 3]lst.append(4)  # 原地修改print(id(lst))  # id 不变

defadd_item(item, items=[]):# 危险！    items.append(item)return itemsprint(add_item(1))  # [1]print(add_item(2))  # [1, 2]，而非 [2]

d = {(1, 2): "ok"}  # 合法d = {[1, 2]: "error"}  # TypeError

result = None# 推荐写法if result isNone:    print("没有结果")# 不推荐（虽然功能相同）if result == None:    print("没有结果")

bool([])  # Falsebool([0])  # True（列表有元素）bool("")  # Falsebool("False")  # True（非空字符串）

print(0and"hello")  # 0print(1and"hello")  # helloprint(0or"hello")   # helloprint(1or"hello")   # 1

name = user_input or"Anonymous"

x = 10# intx = "hello"# 现在是 strx = [1, 2, 3] # 现在是 list

defgreet(name: str) -> str:returnf"Hello, {name}"

defadd(a: int, b: int) -> int:return a + badd("1", "2")  # 运行时不会报错！

s = "hello"print(s[::-1])  # olleh

print(''.join(reversed(s)))

result = ""for c in s:    result = c + result

# 不推荐：每次+都会创建新对象result = ""for s in strings:    result += s  # 效率低# 推荐：一次分配内存result = "".join(strings)  # 效率高

"a,b,c".split(",")  # ['a', 'b', 'c']"hello world".split()  # ['hello', 'world']，按空白字符分割

"  hello  ".strip()  # 'hello'"###hello###".strip('#')  # 'hello'

• 记忆技巧：strip 是"剥皮"，split 是"切开"。

题目 14：列表推导式是什么？

考点

• 列表推导式的语法
• 推导式 vs 普通循环
• 简洁与可读性的平衡

解析思路

• 列表推导式是一种简洁的创建列表的方式
• [表达式 for item in iterable if 条件]
• 适用于简单逻辑，复杂逻辑应保持可读性

答案

• 列表推导式是 Python 特有的语法，用于简洁地创建列表。

# 普通方式squares = []for x in range(5):    squares.append(x ** 2)# 列表推导式squares = [x ** 2for x in range(5)]print(squares)  # [0, 1, 4, 9, 16]

• 格式：[表达式 for item in 可迭代对象]
• 优点：代码简洁、执行效率高
• 注意：不要为了简洁而牺牲可读性，复杂逻辑建议用普通循环。

题目 15：列表推导式中如何加条件？

考点

• 带 if 条件的列表推导式
• if...else 表达式
• 条件筛选 vs 条件表达式

解析思路

• 条件筛选：if condition 放在 for 后面
• 条件表达式：if result_a else result_b 放在表达式位置

答案

• 条件筛选（if 在 for 后）：只保留满足条件的元素

# 筛选偶数nums = [1, 2, 3, 4, 5, 6]evens = [x for x in nums if x % 2 == 0]print(evens)  # [2, 4, 6]

• 条件表达式（if...else 在表达式位置）：根据条件选择不同的值

# 奇数变 0，偶数保留result = [x if x % 2 == 0else0for x in nums]print(result)  # [0, 2, 0, 4, 0, 6]

题目 16：append() 和 extend() 有什么区别？

考点

• 列表的追加方法
• append() 追加单个元素
• extend() 追加可迭代对象的每个元素

解析思路

• append() 将整个对象作为一个元素添加
• extend() 将可迭代对象的每个元素逐一添加
• 容易混淆的场景：追加列表

答案

• append()：将单个对象添加到列表末尾
• extend()：将可迭代对象的每个元素逐一添加到列表末尾

lst = [1, 2, 3]lst.append([4, 5])print(lst)  # [1, 2, 3, [4, 5]]，列表作为整体添加lst = [1, 2, 3]lst.extend([4, 5])print(lst)  # [1, 2, 3, 4, 5]，元素逐一添加

• + 运算符与 extend() 效果相同：[1,2] + [3,4] → [1,2,3,4]

题目 17：list.sort() 和 sorted() 有什么区别？

考点

• 原地排序 vs 返回新列表
• sort() 是列表方法，sorted() 是内置函数
• 参数含义（key、reverse）

解析思路

• sort() 原地修改列表，返回 None
• sorted() 返回新的排序列表，原列表不变
• 适用场景不同

答案

• list.sort()：原地排序，直接修改原列表，返回 None
• sorted(iterable)：返回新列表，原对象不变

lst = [3, 1, 4, 1, 5]lst.sort()print(lst)  # [1, 1, 3, 4, 5]print(lst.sort())  # Nonelst = [3, 1, 4, 1, 5]new_lst = sorted(lst)print(new_lst)  # [1, 1, 3, 4, 5]print(lst)      # [3, 1, 4, 1, 5]，原列表不变

• 两者都支持 key 和 reverse 参数：

sorted(strings, key=len, reverse=True)  # 按长度降序

题目 18：元组一定不可变吗？

考点

• 元组的不可变性
• 可变对象在元组内的情况
• 元组与列表的区别

解析思路

• 元组本身不可变，但可以包含可变对象
• 不可变指的是元组占位的固定性，不是内容的固定性
• 区分"不可变"和"不可变引用"

答案

• 不完全是。元组的"不可变"指的是元素引用不可变，而非元素内容不可变。

t = (1, [2, 3], 4)t[0] = 10# TypeError，不能修改元素引用t[1].append(5)  # 合法！修改列表内容print(t)  # (1, [2, 3, 5], 4)

• 如果元组只包含不可变对象（int、str、tuple），则是完全不可变的。
• 列表可以放进元组，但元组不能放进列表后被替换。

题目 19：字典如何安全获取不存在的 key？

考点

• dict.get() 方法
• defaultdict
• KeyError 处理

解析思路

• get() 返回默认值（默认为 None），不抛异常
• d[key] 直接访问会抛 KeyError
• defaultdict 提供默认值逻辑

答案

• 方法一：使用 get()

d = {"a": 1}print(d.get("b"))      # Noneprint(d.get("b", 0))    # 0，提供默认值

• 方法二：使用 setdefault()

d = {"a": 1}d.setdefault("b", 0)   # 返回 0，并设置 d["b"] = 0

• 方法三：使用 defaultdict

from collections import defaultdictd = defaultdict(int)  # 不存在的 key 返回 0print(d["b"])  # 0

题目 20：字典如何遍历 key 和 value？

考点

• dict.keys()、dict.values()、dict.items()
• 多种遍历方式
• 性能考虑

解析思路

• keys() 返回键的视图
• values() 返回值的视图
• items() 返回键值对的视图
• 可以用多种方式遍历字典

答案

• 遍历 keys

d = {"a": 1, "b": 2}for key in d:    print(key)for key in d.keys():    print(key)

• 遍历 values

for value in d.values():    print(value)

• 遍历 key-value 对

for key, value in d.items():    print(f"{key}: {value}")

• dict.keys()、dict.values()、dict.items() 在 Python 3 中返回视图对象，支持迭代但不是列表。

题目 21：字典推导式是什么？

考点

• 字典推导式的语法
• 推导式 vs 普通循环
• 多种生成方式

解析思路

• 字典推导式：{key: value for item in iterable}
• 可以加条件筛选
• 适用于快速构建字典

答案

• 字典推导式是 Python 特有的简洁语法，用于快速创建字典。

# 普通方式squares = {}for x in range(5):    squares[x] = x ** 2# 字典推导式squares = {x: x ** 2for x in range(5)}print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}# 带条件：筛选evens = {x: x**2for x in range(5) if x % 2 == 0}print(evens)  # {0: 0, 2: 4, 4: 16}# 键值对互换d = {"a": 1, "b": 2}reversed_d = {v: k for k, v in d.items()}print(reversed_d)  # {1: 'a', 2: 'b'}

题目 22：集合有什么特点？

考点

• 集合的特性（无序、不重复、可变）
• 集合的底层实现（哈希表）
• 集合 vs 列表

解析思路

• 集合三大特点：无序、不重复、可变
• 利用哈希表实现 O(1) 查找
• 集合元素必须是可哈希的

答案

• 无序：集合内元素没有固定顺序（Python 3.7+ 字典有序，但集合仍无序）
• 不重复：自动去重，不允许重复元素
• 可变：可以添加/删除元素
• 要求元素可哈希：集合元素必须是不可变对象

s = {1, 2, 3, 3, 3}print(s)  # {1, 2, 3}，自动去重s.add(4)      # 添加元素s.remove(2)   # 删除元素（不存在会报错）s.discard(5)  # 删除元素（不存在不报错）

• 适合场景：去重、成员测试、集合运算。

题目 23：集合常见运算有哪些？

考点

• 集合的数学运算
• union、intersection、difference
• 对称差集

解析思路

• 并集：union() 或 |
• 交集：intersection() 或 &
• 差集：difference() 或 -
• 对称差集：symmetric_difference() 或 ^

答案

a = {1, 2, 3, 4}b = {3, 4, 5, 6}# 并集：合并所有元素print(a | b)           # {1, 2, 3, 4, 5, 6}print(a.union(b))# 交集：共同元素print(a & b)           # {3, 4}print(a.intersection(b))# 差集：A 有 B 没有print(a - b)           # {1, 2}print(a.difference(b))# 对称差集：互不包含的元素print(a ^ b)           # {1, 2, 5, 6}print(a.symmetric_difference(b))# 子集/超集判断print({1, 2}.issubset({1, 2, 3}))  # Trueprint({1, 2, 3}.issuperset({1, 2}))  # True

题目 24：如何统计列表中元素出现次数？

考点

• collections.Counter
• count() 方法
• 字典手动统计

解析思路

• list.count() 统计单个元素
• Counter 统计所有元素
• 适用不同场景

答案

• 方法一：单个元素用 count()

lst = [1, 2, 2, 3, 3, 3]print(lst.count(2))  # 2

• 方法二：统计所有元素用 Counter

from collections import Counterlst = [1, 2, 2, 3, 3, 3]counter = Counter(lst)print(counter)  # Counter({3: 3, 2: 2, 1: 1})print(counter[2])  # 2print(counter.most_common(2))  # [(3, 3), (2, 2)]

题目 25：如何取列表中出现最多的元素？

考点

• Counter.most_common()
• 自定义实现
• 边界情况处理

解析思路

• Counter.most_common(n) 返回前 n 个最常见元素
• 考虑多个元素出现次数相同的情况
• 可以自定义 key 进行排序

答案

from collections import Counterlst = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]# 最常见的元素counter = Counter(lst)most_common = counter.most_common(1)print(most_common[0][0])  # 4# 前 3 个最常见的print(counter.most_common(3))  # [(4, 4), (3, 3), (2, 2)]# 手写实现defmost_frequent(lst):ifnot lst:returnNone    counts = {}for item in lst:        counts[item] = counts.get(item, 0) + 1return max(counts, key=counts.get)

三、函数与参数

题目 26：Python 函数参数有哪些类型？

考点

• 位置参数
• 关键字参数
• 默认参数
• 可变参数（*args, **kwargs）

解析思路

• 按参数形式分类讲解
• 混合使用时的规则

答案

• 位置参数：按顺序传递

defgreet(name, age):    print(f"{name} is {age}")greet("Alice", 25)

• 关键字参数：按名称传递

greet(age=25, name="Alice")

• 默认参数：提供默认值

defgreet(name, greeting="Hello"):    print(f"{greeting}, {name}")

• 可变参数：
• *args：接收任意数量的位置参数，组成元组
• **kwargs：接收任意数量的关键字参数，组成字典

deffunc(*args, **kwargs):    print(args, kwargs)func(1, 2, 3, a=4, b=5)  # (1, 2, 3) {'a': 4, 'b': 5}

题目 27：默认参数有什么坑？

考点

• 默认参数的可变性问题
• 默认参数只计算一次的原理
• 正确写法

解析思路

• 默认参数在函数定义时求值，不是在调用时
• 可变默认参数会累积状态
• 解决方案：用 None 作为默认值

答案

• 陷阱：可变默认参数会被所有调用共享！

# 错误示例defadd_item(item, items=[]):    items.append(item)return itemsprint(add_item(1))  # [1]print(add_item(2))  # [1, 2]，而非 [2]！

• 原因：默认参数在函数定义时创建，只会初始化一次。
• 正确写法：

# 正确方式defadd_item(item, items=None):if items isNone:        items = []    items.append(item)return itemsprint(add_item(1))  # [1]print(add_item(2))  # [2]

• 原则：永远不要使用可变对象（如 list、dict）作为默认参数。

题目 28：*args 是什么？

考点

• 可变位置参数
• 参数解包
• args 是元组

解析思路

• *args 收集所有位置参数成元组
• 可以在函数定义中使用，也可以在调用时解包
• 常见用法

答案

• *args 允许函数接受任意数量的位置参数，收集成元组。

defsum_all(*args):    total = 0for num in args:        total += numreturn totalprint(sum_all(1, 2, 3, 4, 5))  # 15# 解包：调用时将列表展开nums = [1, 2, 3, 4, 5]print(sum_all(*nums))  # 15

• * 可以用在函数定义的参数前（收集），也可以用在实参前（解包）。

题目 29：**kwargs 是什么？

考点

• 可变关键字参数
• kwargs 是字典
• 常见用法

解析思路

• **kwargs 收集所有关键字参数成字典
• 可以与 *args 配合使用
• 调用时解包

答案

• **kwargs 允许函数接受任意数量的关键字参数，收集成字典。

defprint_info(**kwargs):for key, value in kwargs.items():        print(f"{key}: {value}")print_info(name="Alice", age=25, city="Beijing")# name: Alice# age: 25# city: Beijing# 解包：调用时将字典展开info = {"name": "Bob", "age": 30}print_info(**info)

• 参数顺序规则：def func(*args, **kwargs) 或 def func(a, b, *args, **kwargs)

题目 30：Python 函数是对象吗？

考点

• Python 一切皆对象
• 函数作为对象
• 函数可以赋值、传递、嵌套

解析思路

• Python 中函数是一等公民
• 可以赋值给变量
• 可以作为参数传递
• 可以作为返回值

答案

• 是的，Python 中函数是对象，可以像任何其他对象一样使用。

defgreet(name):returnf"Hello, {name}"# 函数可以赋值给变量say_hello = greetprint(say_hello("Alice"))  # Hello, Alice# 函数可以作为参数defcall_twice(func, arg):return func(func(arg))# 函数可以作为返回值defmultiplier(n):returnlambda x: x * ndouble = multiplier(2)print(double(5))  # 10

• 这使得 Python 支持高阶函数、装饰器等高级特性。

题目 31：什么是高阶函数？

考点

• 高阶函数的定义
• 常见高阶函数
• 函数式编程

解析思路

• 高阶函数：接收函数作为参数或返回函数的函数
• Python 内置高阶函数：map、filter、sorted
• 与普通函数的区别

答案

• 高阶函数：至少满足以下条件之一的函数：
1. 接收一个或多个函数作为参数
2. 返回一个函数

# 接收函数作为参数defapply_twice(func, x):return func(func(x))result = apply_twice(lambda x: x * 2, 5)print(result)  # 20# 返回函数defmake_power(exponent):defpower(base):return base ** exponentreturn powersquare = make_power(2)print(square(5))  # 25

• Python 内置高阶函数：map()、filter()、sorted() 的 key 参数

题目 32：lambda 表达式是什么？

考点

• lambda 匿名函数
• 语法限制
• 适用场景

解析思路

• lambda 是单表达式函数
• 限制：只能包含一个表达式，不能有语句
• 适合简短函数

答案

• lambda 是创建匿名函数的表达式，返回一个函数对象。

# 普通函数defadd(a, b):return a + b# lambda 表达式add = lambda a, b: a + bprint(add(1, 2))  # 3

• 语法：lambda 参数: 表达式
• 限制：
• 只能包含一个表达式
• 不能包含语句（如 if...else 可以用三元表达式）
• 不能有 return
• 适用场景：一次性简单函数、回调函数、高阶函数的参数

numbers = [3, 1, 4, 1, 5, 9]numbers.sort(key=lambda x: -x)  # 降序排列

题目 33：map() 怎么用？

考点

• map() 函数
• 函数式编程
• 返回迭代器

解析思路

• map 接收函数和可迭代对象
• 对每个元素应用函数
• 返回迭代器（Python 3）

答案

• map(func, iterable) 对可迭代对象的每个元素应用函数，返回迭代器。

# 平方每个元素numbers = [1, 2, 3, 4, 5]squares = map(lambda x: x ** 2, numbers)print(list(squares))  # [1, 4, 9, 16, 25]# 字符串转整数strings = ["1", "2", "3"]ints = list(map(int, strings))  # [1, 2, 3]

• 注意：Python 3 中 map 返回迭代器，需要 list() 转换或遍历。

题目 34：filter() 怎么用？

考点

• filter() 函数
• 函数式编程
• 返回迭代器

解析思路

• filter 接收函数和可迭代对象
• 函数返回 True/False 决定保留
• 返回过滤后的元素

答案

• filter(func, iterable) 过滤可迭代对象，返回满足条件的元素。

# 筛选偶数numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]evens = filter(lambda x: x % 2 == 0, numbers)print(list(evens))  # [2, 4, 6, 8, 10]# 筛选非空字符串strings = ["hello", "", "world", None, "python"]non_empty = filter(None, strings)  # None 表示用元素本身布尔值判断print(list(non_empty))  # ['hello', 'world', 'python']

• 注意：过滤函数返回 True 的元素会被保留。

题目 35：zip() 怎么用？

考点

• zip() 函数
• 并行遍历多个可迭代对象
• 返回元组迭代器

解析思路

• zip 将多个可迭代对象配对
• 长度不一致时取最短
• 可用于构建字典、并行遍历

答案

• zip(*iterables) 将多个可迭代对象对应位置的元素配对成元组。

# 并行遍历names = ["Alice", "Bob", "Charlie"]ages = [25, 30, 35]for name, age in zip(names, ages):    print(f"{name}: {age}")# 构建字典keys = ["name", "age", "city"]values = ["Alice", 25, "Beijing"]d = dict(zip(keys, values))print(d)  # {'name': 'Alice', 'age': 25, 'city': 'Beijing'}# 解压zipped = zip(names, ages)unzipped = zip(*zipped)print(list(unzipped))  # [('Alice', 'Bob', 'Charlie'), (25, 30, 35)]

• 长度不一致：取最短的，忽略多余元素
• 注意：Python 3 返回迭代器。

四、作用域、闭包、装饰器

题目 36：Python 作用域查找规则是什么？

考点

• LEGB 规则
• 作用域链
• 变量查找顺序

解析思路

• Python 按照 LEGB 顺序查找变量
• Local → Enclosing → Global → Built-in
• 示例帮助理解

答案

• Python 变量查找遵循 LEGB 规则：
1. **L (Local)**：当前函数内部
2. **E (Enclosing)**：外层函数（闭包）
3. **G (Global)**：模块（文件）级别
4. **B (Built-in)**：Python 内置

x = "global"defouter():    x = "enclosing"definner():        x = "local"        print(x)  # 找到 local    inner()outer()  # 输出：local

• 如果在当前作用域找不到变量，会向外层逐级查找。

题目 37：global 有什么作用？

考点

• global 关键字
• 在函数内修改全局变量
• 作用域问题

解析思路

• global 声明变量为全局变量
• 不声明直接修改会创建局部变量
• 正确使用方式

解析思路

• global 关键字用于在函数内部声明/修改全局变量。

count = 0defincrement():global count      # 声明使用全局变量    count += 1increment()increment()print(count)  # 2

• 注意：如果函数内有赋值语句但没有 global，Python 会创建同名的局部变量，不会影响全局变量。

题目 38：nonlocal 有什么作用？

考点

• nonlocal 关键字
• 闭包中的变量修改
• 与 global 的区别

解析思路

• nonlocal 用于在内层函数中修改外层函数的变量
• global 用于修改模块级别的变量
• 两者作用范围不同

答案

• nonlocal 用于在内层函数中修改外层函数（非全局）的变量。

defouter():    x = 10definner():nonlocal x  # 声明修改外层函数的 x        x = 20    inner()    print(x)  # 20outer()

• 对比：
• global：声明/修改模块级别的变量
• nonlocal：声明/修改外层函数的变量（闭包内）

defcounter():    count = 0defincrement():nonlocal count        count += 1return countreturn incrementc = counter()print(c())  # 1print(c())  # 2

题目 39：什么是闭包？

考点

• 闭包的定义
• 闭包的三个条件
• 闭包的应用

解析思路

• 闭包是"记住"外层作用域的函数
• 三个条件：嵌套函数、引用外层变量、返回内部函数
• 闭包实现数据私有化

答案

• 闭包：一个内层函数引用了外层函数的变量，并被返回给外部，这些变量不会被回收。

defmake_multiplier(factor):defmultiplier(number):return number * factor  # 引用外层变量return multipliertimes_3 = make_multiplier(3)times_5 = make_multiplier(5)print(times_3(10))  # 30print(times_5(10))  # 50

• 闭包三要素：
1. 内层函数定义在外层函数内部
2. 内层函数引用了外层函数的变量
3. 外层函数返回内层函数
• 应用：数据私有化、工厂函数、延迟计算

题目 40：什么是装饰器？

考点

• 装饰器的定义
• 装饰器的工作原理
• 函数替换

解析思路

• 装饰器是接收函数并返回新函数的函数
• 本质是函数替换
• 用 @ 语法糖简化调用

答案

• 装饰器：在不修改原函数的前提下，给函数添加新功能。

deflog_calls(func):defwrapper(*args, **kwargs):        print(f"Calling {func.__name__}")        result = func(*args, **kwargs)        print(f"Finished {func.__name__}")return resultreturn wrapper@log_callsdefgreet(name):    print(f"Hello, {name}")greet("Alice")# 输出：# Calling greet# Hello, Alice# Finished greet

• @log_calls 等价于 greet = log_calls(greet)
• 装饰器在函数定义后立即生效。

题目 41：装饰器如何保留原函数信息？

考点

• functools.wraps
• 函数元信息丢失问题
• 正确实现装饰器

解析思路

• 直接返回 wrapper 函数会丢失原函数信息
• 使用 functools.wraps 复制元信息
• 必须使用

答案

• 使用 functools.wraps 保留原函数的元信息。

import functoolsdeflog_calls(func):    @functools.wraps(func)  # 保留原函数信息defwrapper(*args, **kwargs):        print(f"Calling {func.__name__}")return func(*args, **kwargs)return wrapper@log_callsdefgreet(name):"""打招呼函数"""    print(f"Hello, {name}")print(greet.__name__)  # greet（而非 wrapper）print(greet.__doc__)   # 打招呼函数

• 不保留的后果：greet.__name__ 会变成 "wrapper"，影响调试、文档、装饰器栈等。

题目 42：带参数的装饰器怎么写？

考点

• 参数化装饰器
• 三层函数嵌套
• 常见用法

解析思路

• 装饰器工厂：返回装饰器的函数
• 三层：外层接收参数，中间层返回装饰器，最内层是 wrapper

答案

import functoolsdefrepeat(times):defdecorator(func):        @functools.wraps(func)defwrapper(*args, **kwargs):for _ in range(times):                result = func(*args, **kwargs)return resultreturn wrapperreturn decorator@repeat(times=3)defgreet(name):    print(f"Hello, {name}")greet("Alice")# 输出：Hello, Alice 三次

• 调用链：@repeat(times=3) → 返回 decorator → 装饰 greet
• 常见参数化装饰器：@lru_cache(maxsize=128)、@click.option()

五、异常处理

题目 43：Python 如何捕获异常？

考点

• try...except 结构
• 多个 except 子句
• 异常捕获顺序

解析思路

• 基本语法结构
• 捕获特定异常 vs 捕获所有异常
• 异常继承关系影响捕获顺序

答案

try:    result = 10 / 0except ZeroDivisionError:    print("不能除以零")# 多个异常try:    int("abc")except ValueError:    print("值错误")except TypeError:    print("类型错误")# 捕获所有异常try:    risky_operation()except Exception as e:    print(f"发生错误: {e}")

• 捕获顺序：先捕获子类，后捕获父类

except ZeroDivisionError:  # 先匹配这个passexcept ArithmeticError:    # 父类放后面pass

题目 44：try...except...else...finally 执行顺序是什么？

考点

• 异常处理的完整结构
• 各子句执行时机
• 常见用法

解析思路

• else：没有异常时执行
• finally：无论是否异常都执行
• return vs finally 的执行顺序

答案

try:    print("try")# 可能抛出异常的代码    x = 10 / 2except ZeroDivisionError:    print("except: 捕获到异常")else:    print("else: 没有异常时执行")  # x = 10 / 2 成功执行后才执行finally:    print("finally: 无论是否异常都执行")

• 执行顺序：
1. try 内的代码执行
2. 如果有异常，匹配 except
3. 如果没有异常，执行 else
4. 无论是否有异常，finally 总是执行

# finally 与 returndeftest():try:return1finally:        print("finally")  # 仍然会执行test()  # 输出: finally, 返回 1

题目 45：如何主动抛出异常？

考点

• raise 语句
• 异常类型
• 自定义异常

解析思路

• 使用 raise 关键字
• 可以 raise 异常类或异常实例
• 在什么场景下抛出异常

答案

• 使用 raise 关键字抛出异常。

# 抛出异常类raise ValueError("值不合法")# 抛出异常实例raise ValueError("值不合法")# 重新抛出当前异常try:    something()except:raise# 保持原始异常信息

• 何时抛出：
• 检测到程序错误且无法处理时
• 验证输入失败时
• 业务规则不满足时

defwithdraw(amount):if amount <= 0:raise ValueError("取款金额必须为正数")

题目 46：如何自定义异常？

考点

• 异常类继承
• 自定义异常类
• 常见模式

解析思路

• 继承自 Exception
• 可以添加额外属性
• 命名习惯

答案

# 基本自定义异常classValidationError(Exception):pass# 带额外信息的异常classValidationError(Exception):def__init__(self, field, message):        self.field = field        self.message = message        super().__init__(f"{field}: {message}")raise ValidationError("email", "格式不正确")# 捕获自定义异常try:    ...except ValidationError as e:    print(f"字段 {e.field}: {e.message}")

• 命名习惯：以 Error 结尾
• 最佳实践：保持简单，继承最合适的内置异常

题目 47：为什么不要直接 except Exception: pass？

考点

• 异常处理的最佳实践
• 裸 except 的危害
• 正确的异常处理方式

解析思路

• 裸 except 捕获所有异常，包括 KeyboardInterrupt
• 掩盖真实错误
• 应该捕获具体异常并适当处理

答案

• 危害：
1. 捕获所有异常，包括 KeyboardInterrupt、SystemExit
2. 掩盖真正的 bug，使调试困难
3. 不处理异常，只是隐藏错误

# 错误做法try:    dangerous_operation()except:  # 捕获所有，包括退出信号pass# 正确做法try:    dangerous_operation()except SpecificError as e:    handle_error(e)  # 适当处理raise# 必要时重新抛出

• 如果必须捕获所有：至少用 except Exception:，不要裸 except:
• 原则：捕获你期望的异常，让未预期的异常向上传播。

六、文件、上下文管理器、迭代器、生成器

题目 48：为什么推荐使用 with open()？

考点

• 上下文管理器
• 资源自动释放
• with 语句的好处

解析思路

• 文件需要显式关闭
• with 自动调用 enter 和 exit
• 确保资源正确释放

答案

• with 语句确保文件在使用完毕后自动关闭，即使发生异常。

# 不推荐：需要手动关闭f = open("file.txt", "r")content = f.read()f.close()  # 如果中间出错，文件不会关闭# 推荐：自动关闭with open("file.txt", "r") as f:    content = f.read()# with 块结束后，文件自动关闭

• 原理：对象实现了 __enter__ 和 __exit__ 方法（上下文管理器协议）
• 好处：防止资源泄漏、代码更简洁

题目 49：什么是上下文管理器？

考点

• 上下文管理器协议
• enter 和 exit
• contextlib 模块

解析思路

• 实现了 enter 和 exit 的对象
• 自动获取和释放资源
• 可以用 @contextmanager 装饰器实现

答案

• 上下文管理器：实现 __enter__ 和 __exit__ 方法的对象，控制资源的获取和释放。

classFileManager:def__init__(self, filename, mode):        self.filename = filename        self.mode = mode        self.file = Nonedef__enter__(self):        self.file = open(self.filename, self.mode)return self.filedef__exit__(self, exc_type, exc_val, exc_tb):if self.file:            self.file.close()returnFalse# 不处理异常with FileManager("test.txt", "w") as f:    f.write("Hello")

• 装饰器方式：使用 @contextmanager

from contextlib import contextmanager@contextmanagerdeffile_manager(filename, mode):    f = open(filename, mode)yield f    f.close()

题目 50：什么是迭代器？

考点

• 迭代器协议
• iter 和 next
• 迭代器特点

解析思路

• 迭代器是实现了 iter 和 next 的对象
• 每次调用 next 返回下一个元素
• 迭代器是消耗性的

答案

• 迭代器：实现了 __iter__ 和 __next__ 方法的对象。

classCounter:def__init__(self, n):        self.n = n        self.current = 0def__iter__(self):return selfdef__next__(self):if self.current >= self.n:raise StopIteration        self.current += 1return self.currentfor i in Counter(3):    print(i)  # 1, 2, 3

• 特点：
• __iter__ 返回迭代器本身
• __next__ 返回下一个元素
• 迭代完成后抛出 StopIteration
• 消耗性：只能遍历一次

题目 51：什么是可迭代对象？

考点

• 可迭代协议
• 迭代器 vs 可迭代对象
• 常见可迭代对象

解析思路

• 可迭代对象实现了 iter
• 返回迭代器
• 列表、元组、字典等都是可迭代对象

答案

• 可迭代对象：实现了 __iter__ 方法（返回迭代器）的对象。

# 列表是可迭代对象lst = [1, 2, 3]iterator = lst.__iter__()  # 或 iter(lst)print(next(iterator))  # 1print(next(iterator))  # 2

• 区别：
• 可迭代对象：可以用 for 遍历，不一定有 __next__
• 迭代器：可以用 for 遍历，也有 __next__
• 常见可迭代对象：list、tuple、dict、set、str、生成器

题目 52：什么是生成器？

考点

• 生成器函数
• yield 语句
• 生成器表达式

解析思路

• 生成器函数使用 yield 返回值
• 调用时不执行，迭代时才执行
• 生成器是迭代器

答案

• 生成器：用 yield 语句返回值的函数，每次迭代生成一个值。

defcount_up_to(n):    i = 1while i <= n:yield i  # 暂停，返回值        i += 1gen = count_up_to(3)print(next(gen))  # 1print(next(gen))  # 2print(next(gen))  # 3

• 工作原理：
1. 调用函数创建生成器对象（不执行）
2. 每次 next() 执行到 yield 并暂停
3. StopIteration 后结束
• 生成器表达式：gen = (x**2 for x in range(5))

题目 53：生成器有什么优点？

考点

• 惰性计算
• 内存效率
• 适合大数据处理

解析思路

• 生成器是惰性的，按需生成
• 不需要一次性加载所有数据
• 适合处理大数据流

答案

• 惰性求值：按需计算，节省内存

# 普通列表：一次性加载所有数据numbers = [x**2for x in range(1000000)]  # 占用大量内存# 生成器：按需计算numbers = (x**2for x in range(1000000))  # 几乎不占内存

• 优点：
1. 内存高效：不需要存储所有元素
2. 惰性计算：按需计算，避免不必要的操作
3. 表示无限序列：可以表示无法穷举的数据流
4. 可组合：生成器链式调用

# 处理大文件with open("huge_file.txt") as f:    lines = (line.strip() for line in f)  # 不读取所有行for line in lines:        process(line)

题目 54：yield from 有什么作用？

考点

• yield from 语法
• 委托生成器
• 子生成器

解析思路

• yield from 用于委托给子生成器
• 简化嵌套生成器
• 自动处理 StopIteration

答案

• yield from 将控制权委托给子生成器，自动传递值。

# 不使用 yield fromdefflatten(nested):for item in nested:for element in item:yield element# 使用 yield fromdefflatten(nested):for item in nested:yieldfrom itemnested = [[1, 2], [3, 4], [5, 6]]print(list(flatten(nested)))  # [1, 2, 3, 4, 5, 6]

• 作用：
1. 简化嵌套循环
2. 在生成器链中传递值
3. 自动处理子生成器的 StopIteration

题目 55：生成器表达式和列表推导式有什么区别？

考点

• 生成器表达式 vs 列表推导式
• 惰性求值 vs 即时求值
• 内存占用

解析思路

• 列表推导式用 []，生成器表达式用 ()
• 列表即时生成，生成器惰性生成
• 生成器只能遍历一次

答案

# 列表推导式squares_list = [x**2for x in range(1000)]print(type(squares_list))  # <class 'list'># 生成器表达式squares_gen = (x**2for x in range(1000))print(type(squares_gen))  # <class 'generator'>

• 选择原则：需要遍历多次用列表，只需要遍历一次或数据量大用生成器。

七、面向对象

题目 56：类和对象有什么区别？

考点

• 类与对象的概念
• 类是模板，对象是实例
• 关系与区别

解析思路

• 类是抽象的蓝图，对象是具体的实例
• 类定义属性和方法，对象具有具体的值
• 一个类可以创建多个对象

答案

• 类（Class）：抽象的模板，定义了一类对象的共同属性和方法。
• 对象（Object）：类的具体实例，具有实际的内存空间和数据。

classDog:# 类def__init__(self, name):        self.name = namedefbark(self):        print(f"{self.name} says Woof!")# 创建对象dog1 = Dog("Buddy")dog2 = Dog("Max")print(type(dog1))  # <class '__main__.Dog'>print(isinstance(dog1, Dog))  # True

• 类定义属性和方法，对象拥有具体的属性值。

题目 57：__init__ 是构造函数吗？

考点

• init vs new
• 构造函数 vs 初始化器
• Python 对象创建过程

解析思路

• new 是构造函数，创建对象
• init 是初始化器，初始化对象
• 两者配合使用

答案

• 不是。__init__ 是初始化器，__new__ 才是构造函数。
• __new__ 负责创建实例，__init__ 负责初始化实例。

classExample:def__new__(cls, *args, **kwargs):        print("__new__ called")return super().__new__(cls)  # 必须返回实例def__init__(self, value):        print("__init__ called")        self.value = valuee = Example(10)# 输出：# __new__ called# __init__ called

• **大多数情况下只需重写 __init__**，__new__ 用于特殊场景（如单例模式、不可变对象）。

题目 58：实例属性和类属性有什么区别？

考点

• 实例属性 vs 类属性
• 命名空间
• 访问优先级

解析思路

• 实例属性：属于单个对象
• 类属性：属于类本身，所有对象共享
• 访问时先找实例，再找类

答案

classDog:    species = "Canis familiaris"# 类属性，所有对象共享def__init__(self, name):        self.name = name  # 实例属性，每个对象独立dog1 = Dog("Buddy")dog2 = Dog("Max")print(dog1.name)      # Buddy（实例属性）print(dog1.species)   # Canis familiaris（类属性）# 修改实例属性不影响类属性dog1.species = "Cat"# 创建了实例属性，不影响 dog2print(dog2.species)  # Canis familiaris

• 区别：
• 实例属性：每个对象独立，通过 self.xxx 定义
• 类属性：所有对象共享，通过类名.xxx 或 self.xxx 定义

题目 59：类方法、静态方法、实例方法有什么区别？

考点

• 三种方法的定义和调用方式
• 参数接收
• 使用场景

解析思路

• 实例方法：第一个参数是 self
• 类方法：第一个参数是 cls，用 @classmethod
• 静态方法：没有 self/cls，用 @staticmethod

答案

classExample:    class_attr = "类属性"definstance_method(self):# self 是实例return"实例方法", self    @classmethoddefclass_method(cls):# cls 是类return"类方法", cls    @staticmethoddefstatic_method():# 没有隐式参数return"静态方法"obj = Example()# 调用方式obj.instance_method()     # 需要实例Example.class_method()    # 可以用类或实例调用Example.static_method()   # 可以用类或实例调用

题目 60：什么是继承？

考点

• 继承的概念
• 基类和子类
• 继承的好处

解析思路

• 继承实现代码复用
• 子类继承父类的属性和方法
• 可以添加或重写

答案

• 继承：子类继承父类的属性和方法，实现代码复用和层次化设计。

classAnimal:def__init__(self, name):        self.name = namedefspeak(self):raise NotImplementedErrorclassDog(Animal):# 继承 Animaldefspeak(self):returnf"{self.name} says Woof!"classCat(Animal):# 继承 Animaldefspeak(self):returnf"{self.name} says Meow!"dog = Dog("Buddy")print(dog.name)    # Buddy（继承自父类）print(dog.speak()) # Buddy says Woof!

• 好处：减少代码重复、建立"is-a"关系、支持多态

题目 61：什么是方法重写？

考点

• 方法重写（覆盖）
• super() 调用父类方法
• 多态

解析思路

• 子类定义与父类同名的方法
• 子类实现覆盖父类实现
• 用 super() 调用父类方法

答案

• 方法重写：子类定义与父类同名的方法，改变或扩展父类行为。

classParent:defgreet(self):return"Hello from Parent"classChild(Parent):defgreet(self):# 重写父类方法return"Hello from Child"defgreet_parent(self):# 调用父类方法return super().greet()child = Child()print(child.greet())          # Hello from Childprint(child.greet_parent())   # Hello from Parent

• 重写规则：
• 方法名必须相同
• 参数签名可以相同或修改
• 子类方法权限不能比父类更严格

题目 62：super() 有什么作用？

考点

• super() 函数
• MRO（方法解析顺序）
• 在 init 中的使用

解析思路

• super() 调用父类的方法
• 在子类初始化时先调用父类初始化
• Python 3 的 super() 用法

答案

• super() 返回一个代理对象，用于调用父类的方法。

classAnimal:def__init__(self, name, age):        self.name = name        self.age = ageclassDog(Animal):def__init__(self, name, age, breed):        super().__init__(name, age)  # 调用父类 __init__        self.breed = breed  # 添加新属性dog = Dog("Buddy", 3, "Golden Retriever")print(dog.name, dog.age, dog.breed)  # Buddy 3 Golden Retriever

• Python 3 写法：super().__init__(...)（不需要传类名和 self）
• 多继承中的 MRO：super() 按照 MRO 顺序调用下一个类的方法

题目 63：Python 支持多继承吗？

考点

• 多继承
• MRO（方法解析顺序）
• 多继承的复杂度

解析思路

• Python 支持多继承
• 可能有菱形继承问题
• MRO 决定了方法调用顺序

答案

• 支持。Python 支持多继承，即一个类可以继承多个父类。

classFlyer:deffly(self):        print("Flying")classSwimmer:defswim(self):        print("Swimming")classDuck(Flyer, Swimmer):# 多继承passduck = Duck()duck.fly()   # Flyingduck.swim()  # Swimming

• MRO（方法解析顺序）：Python 使用 C3 线性化算法确定方法调用顺序。

print(Duck.__mro__)  # 查看 MRO

• 注意：多继承可能导致菱形继承和命名冲突，应谨慎使用。

题目 64：什么是魔术方法？

考点

• 魔术方法（特殊方法/双下方法）
• 双下划线命名
• 常见魔术方法

解析思路

• 魔术方法以双下划线开头和结尾
• Python 内部调用或允许重写
• 用于实现运算符、容器等行为

解析思路

• 魔术方法（Magic Methods / Dunder Methods）：以 __ 包裹的方法，由 Python 内部调用或允许开发者重写。

classPoint:def__init__(self, x, y):        self.x = x        self.y = ydef__add__(self, other):# 重写 + 运算符return Point(self.x + other.x, self.y + other.y)def__repr__(self):returnf"Point({self.x}, {self.y})"p1 = Point(1, 2)p2 = Point(3, 4)print(p1 + p2)  # Point(4, 6)

• 常见魔术方法：
• __init__：初始化
• __str__ / __repr__：字符串表示
• __add__ / __eq__ / __lt__：运算符
• __len__ / __getitem__：容器行为

题目 65：__repr__ 和 str 有什么区别？

考点

• 字符串表示方法
• 不同场景的调用
• IDE 友好 vs 用户友好

解析思路

• repr 给开发者/调试用
• str 给用户看
• 优先调用规则

答案

• __repr__：开发者友好，用于调试和开发环境
• __str__：用户友好，用于最终用户显示

classPerson:def__init__(self, name):        self.name = namedef__repr__(self):returnf"Person(name='{self.name}')"# 精确、可以重建对象def__str__(self):returnf"Person: {self.name}"# 友好、可读p = Person("Alice")print(repr(p))  # Person(name='Alice')print(str(p))   # Person: Alice# print 优先用 __str__，没有则用 __repr__# 直接在解释器输入对象优先用 __repr__

• 最佳实践：实现 __repr__ 优先（IDE、调试用），__str__ 可选。

题目 66：@property 有什么作用？

考点

• 属性装饰器
• Getter/Setter
• Pythonic 的封装方式

解析思路

• 用方法模拟属性
• 避免直接暴露实例变量
• 可以在访问时添加逻辑

答案

• @property 将方法转换为属性访问，实现类似 getter 的功能。

classCircle:def__init__(self, radius):        self._radius = radius  # 私有属性（约定）    @propertydefradius(self):"""Getter"""return self._radius    @radius.setterdefradius(self, value):"""Setter，带验证"""if value < 0:raise ValueError("半径不能为负")        self._radius = value    @propertydefarea(self):"""只读属性"""return3.14 * self._radius ** 2c = Circle(5)print(c.radius)  # 5（像访问属性一样）c.radius = 10# 调用 setterprint(c.area)     # 314.0

• 好处：在保持 API 简洁的同时，可以添加验证、计算等逻辑。

题目 67：什么是 dataclass？

考点

• dataclass 装饰器
• 自动生成方法
• 简化数据类定义

解析思路

• Python 3.7+ 的特性
• 自动生成 init__、__repr__、__eq 等
• 适合存储数据的类

答案

• dataclass 是 Python 3.7+ 的装饰器，自动生成常用方法。

from dataclasses import dataclassfrom typing import Optional@dataclassclassPerson:    name: str    age: int    email: Optional[str] = Noneperson = Person("Alice", 25)print(person)  # Person(name='Alice', age=25, email=None)print(person.name)  # Alice

• 自动生成：__init__、__repr__、__eq__、__hash__（可选）
• 字段：使用类型注解定义字段
• 参数：
• frozen=True：不可变对象
• order=True：支持比较运算
• slots=True：使用 __slots__ 优化内存

题目 68：__slots__ 有什么作用？

考点

• slots 属性
• 限制属性
• 内存优化

解析思路

• 限制类只能有特定的属性
• 减少内存占用
• 不能动态添加属性

答案

• __slots__ 限制类只能拥有的属性，禁用 __dict__，节省内存。

classWithoutSlots:def__init__(self, name):        self.name = nameclassWithSlots:    __slots__ = ['name']def__init__(self, name):        self.name = name# __slots__ 类w1 = WithSlots("Alice")w1.name = "Bob"# OK# w1.age = 25           # AttributeError# 无 __slots__ 类w2 = WithoutSlots("Alice")w2.age = 25# OK，可以动态添加