云南网站建设,企业信息化软件定制开发

专业提供昆明网站建设, 昆明软件开发, 云南网站建设,企业信息化软件定制开发服务免费咨询QQ932256355
博客园 首页 新随笔 联系 订阅 管理
  144 随笔 :: 4 文章 :: 1 评论 :: 649 阅读
揭秘！100 个 Python 常用易错知识点的避坑指南

揭秘！100 个 Python 常用易错知识点的避坑指南

目录

简介

Python 作为一门广受欢迎且功能强大的编程语言，在实际使用过程中却常常让开发者们遭遇各种意想不到的 “陷阱”。本系列文章精心总结了 100 个 Python 中常见的易错知识点，内容覆盖从基础语法到高级特性，从变量数据类型到并发编程等多个方面。无论是初入编程世界的新手，还是经验丰富的开发者，都能从这些深入剖析与详细讲解中，清晰分辨易错点，掌握正确的编程方法，从而避开常见错误，提升 Python 编程技能与代码质量。

一下是Python 中100个常用易错知识点的总结：

1. 类方法命名中的下划线

  • 单下划线开头 (_name)

    ：

    • 按照约定，以单下划线开头的属性或方法是 “protected”（受保护的）。这意味着它们不应该在类外部直接访问，虽然 Python 并没有真正的访问限制。例如：
class MyClass:
    def __init__(self):
        self._protected_var = 42
 
    def _protected_method(self):
        return "This is a protected method"
 
 
obj = MyClass()
# 虽然可以访问，但不建议这么做
print(obj._protected_var)
print(obj._protected_method())

  • 双下划线开头 (__name)

    ：

    • 以双下划线开头的属性或方法会触发名称改写（name mangling）机制。Python 会在这些属性或方法名前加上 _类名，以避免在子类中命名冲突。例如：
class MyClass:
    def __init__(self):
        self.__private_var = 42
 
    def __private_method(self):
        return "This is a private method"
 
 
obj = MyClass()
# 直接访问会报错
# print(obj.__private_var)
# 实际可以通过改写后的名称访问，但强烈不推荐
print(obj._MyClass__private_var)
print(obj._MyClass__private_method())

2. 函数形参中的 * 和 **

  • 仅限关键字参数 星号 ( *, arg )

​ 在函数定义中， 把形参标记为 仅限关键字，表明必须以关键字参数形式传递该形参，应在参数列表中第一个 仅限关键字 形参前添加 ***** 。例如：

# 这里arg必须是关键字参数
def kwd_only_arg(*, arg):
    print(arg)

特定形参可以标记为 仅限位置。仅限位置 时，形参的顺序很重要，且这些形参不能用关键字传递。仅限位置形参应放在 / （正斜杠）前。/ 用于在逻辑上分割仅限位置形参与其它形参。如果函数定义中没有 /，则表示没有仅限位置形参。

/ 后可以是 位置或关键字 或 仅限关键字 形参。

更多信息参考： 4. 更多控制流工具 — Python 3.12.9 文档

  • 单星号 (*args)

    ：

    • 在函数定义中，*args 用于收集所有位置参数（positional arguments）到一个元组（tuple）中。例如：
def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total
 
 
result = sum_numbers(1, 2, 3, 4)
print(result)  # 输出: 10

  • 双星号 (**kwargs)

    ：

    • 在函数定义中，**kwargs 用于收集所有关键字参数（keyword arguments）到一个字典（dictionary）中。例如：
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
 
 
print_info(name="Alice", age=30, city="New York")

3. 函数实参中的 *

  • 在函数调用时使用单星号 (*)

    ：

    • 可以将一个可迭代对象（如列表、元组等）解包为位置参数。例如：
def multiply(a, b):
    return a * b
 
 
nums = [3, 4]
result = multiply(*nums)
print(result)  # 输出: 12

4. 变量作用域

  • 局部变量和全局变量

    ：

    • 在函数内部定义的变量默认是局部变量，作用域仅限于函数内部。如果要在函数内部修改全局变量，需要使用 global 关键字声明。例如：
global_var = 10
 
 
def modify_global():
    global global_var
    global_var = 20
 
 
modify_global()
print(global_var)  # 输出: 20

5. 浅拷贝和深拷贝

  • 浅拷贝 (copy.copy())

    ：

    • 创建一个新对象，该对象的内容是原对象元素的引用。如果原对象包含可变对象（如列表、字典），修改原对象中的可变对象会影响浅拷贝对象。例如：
import copy
 
original_list = [[1, 2], [3, 4]]
shallow_copy = copy.copy(original_list)
original_list[0][0] = 99
print(shallow_copy)  # 输出: [[99, 2], [3, 4]]

  • 深拷贝 (copy.deepcopy())

    ：

    • 创建一个新对象，递归地复制原对象及其所有子对象。修改原对象不会影响深拷贝对象。例如：
import copy
 
original_list = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(original_list)
original_list[0][0] = 99
print(deep_copy)  # 输出: [[1, 2], [3, 4]]

6. 默认参数的陷阱

  • 默认参数在函数定义时被求值，而不是在函数调用时。如果默认参数是可变对象（如列表、字典），可能会导致意外行为。例如：
def append_to_list(value, my_list=[]):
    my_list.append(value)
    return my_list
 
 
result1 = append_to_list(1)
result2 = append_to_list(2)
print(result1)  # 输出: [1, 2]
print(result2)  # 输出: [1, 2]
  • 正确的做法是将默认参数设为 None，并在函数内部检查并初始化可变对象：
def append_to_list(value, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(value)
    return my_list
 
 
result1 = append_to_list(1)
result2 = append_to_list(2)
print(result1)  # 输出: [1]
print(result2)  # 输出: [2]

7. 迭代器和生成器相关

迭代器使用后耗尽

迭代器只能遍历一次，遍历完后再次使用会没有结果。例如：

numbers = [1, 2, 3]
iterator = iter(numbers)
 
# 第一次遍历
for num in iterator:
    print(num)
 
# 第二次遍历，没有输出
for num in iterator:
    print(num)

生成器表达式和列表推导式混淆

生成器表达式使用圆括号 ()，列表推导式使用方括号 []。生成器表达式是惰性求值的，而列表推导式会立即创建一个完整的列表。例如：

# 生成器表达式
gen_expr = (i for i in range(3))
print(type(gen_expr))  # <class 'generator'>
 
# 列表推导式
list_comp = [i for i in range(3)]
print(type(list_comp))  # <class 'list'>

8. 异常处理相关

捕获异常范围过大

如果使用 except 语句不指定具体的异常类型，会捕获所有异常，这可能会掩盖代码中的错误。例如：

try:
    result = 1 / 0
except:
    print("An error occurred")

更好的做法是指定具体的异常类型：

try:
    result = 1 / 0
except ZeroDivisionError:
    print("Division by zero!")

异常处理中的 finally 子句

finally 子句中的代码无论是否发生异常都会执行，即使在 try 或 except 子句中有 return 语句。例如：

def test():
    try:
        return 1
    finally:
        print("This will be printed before returning")
 
 
result = test()
print(result)

9. 多线程和多进程相关

全局解释器锁（GIL）

在 CPython 中，全局解释器锁（GIL）使得同一时刻只有一个线程可以执行 Python 字节码。因此，对于 CPU 密集型任务，使用多线程并不能提高性能，反而可能因为线程切换带来额外开销。对于 CPU 密集型任务，建议使用多进程。例如：

import threading
import time
 
# CPU 密集型任务
def cpu_intensive_task():
    num = 0
    for i in range(10**7):
        num += i
 
 
# 使用多线程
threads = []
for _ in range(2):
    t = threading.Thread(target=cpu_intensive_task)
    threads.append(t)
    t.start()
 
for t in threads:
    t.join()

误解多线程性能提升

Python 的全局解释器锁（GIL）使得同一时刻只有一个线程可以执行 Python 字节码。对于 CPU 密集型任务，使用多线程并不能提高性能，反而可能因为线程切换带来额外开销。只有对于 I/O 密集型任务，多线程才能发挥作用。

import threading
 
# CPU 密集型任务
def cpu_intensive():
    result = 0
    for i in range(10**7):
        result += i
 
threads = []
for _ in range(2):
    t = threading.Thread(target=cpu_intensive)
    threads.append(t)
    t.start()
 
for t in threads:
    t.join()
 
# 此多线程执行 CPU 密集型任务不会提升性能

多进程中的资源共享问题

在多进程中，每个进程都有自己独立的内存空间，不能像多线程那样直接共享全局变量。如果需要在进程间共享数据，需要使用 multiprocessing 模块提供的共享内存对象。例如：

import multiprocessing
 
def increment(counter):
    for _ in range(1000):
        with counter.get_lock():
            counter.value += 1
 
 
if __name__ == '__main__':
    counter = multiprocessing.Value('i', 0)
    processes = []
    for _ in range(2):
        p = multiprocessing.Process(target=increment, args=(counter,))
        processes.append(p)
        p.start()
 
    for p in processes:
        p.join()
 
    print(counter.value)

10. 字符串编码问题

编码和解码错误

在 Python 中，字符串有不同的编码方式（如 UTF - 8、GBK 等）。如果在编码和解码过程中使用了不匹配的编码方式，会导致 UnicodeEncodeError 或 UnicodeDecodeError。例如：

text = "你好"
# 错误的编码方式
try:
    encoded = text.encode('ascii')
except UnicodeEncodeError as e:
    print(f"Encoding error: {e}")

正确的做法是使用合适的编码方式， 建议统一使用 utf-8编码：

text = "你好"
encoded = text.encode('utf-8')
decoded = encoded.decode('utf-8')
print(decoded)

11. 模块导入相关

循环导入问题

当两个或多个模块相互导入时，会出现循环导入问题，可能导致 AttributeError 等错误。例如：

  • module_a.py：
from module_b import func_b
 
def func_a():
    print("Function A")
    func_b()
  • module_b.py：
from module_a import func_a
 
def func_b():
    print("Function B")
    func_a()

可以通过重构代码，将导入语句移到函数内部或者重新组织模块结构来解决循环导入问题。

12. 装饰器相关

装饰器丢失元数据

使用装饰器时，如果不使用 functools.wraps 来保留原函数的元数据（如函数名、文档字符串等），会导致元数据丢失。例如：

def my_decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper
 
@my_decorator
def my_function():
    """This is a docstring."""
    pass
 
print(my_function.__name__)  # 输出: wrapper

使用 functools.wraps 可以解决这个问题：

import functools
 
def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper
 
@my_decorator
def my_function():
    """This is a docstring."""
    pass
 
print(my_function.__name__)  # 输出: my_function

丢失原函数元数据

当使用装饰器包装函数时，如果不使用 functools.wraps，原函数的元数据（如函数名、文档字符串等）会丢失，这会影响代码的可读性和调试。

import functools
 
# 错误示例：未使用 wraps
def simple_decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper
 
@simple_decorator
def original_function():
    """这是原函数的文档字符串"""
    pass
 
print(original_function.__name__)  # 输出 'wrapper'，而不是 'original_function'
 
# 正确示例：使用 wraps
def better_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper
 
@better_decorator
def another_function():
    """这是另一个原函数的文档字符串"""
    pass
 
print(another_function.__name__)  # 输出 'another_function'

13. 列表操作相关

切片赋值的理解误区

在进行列表切片赋值时，如果赋值的对象和切片长度不匹配，会有不同的效果。例如：

my_list = [1, 2, 3, 4, 5]
# 切片长度和赋值对象长度相同
my_list[1:3] = [6, 7]
print(my_list)  # 输出: [1, 6, 7, 4, 5]
 
# 切片长度和赋值对象长度不同
my_list[1:3] = [8, 9, 10]
print(my_list)  # 输出: [1, 8, 9, 10, 4, 5]

列表的 sort() 方法和 sorted() 函数混淆

sort() 方法是列表对象的方法，它会直接修改原列表，返回值为 None；而 sorted() 函数会返回一个新的已排序列表，原列表保持不变。例如：

my_list = [3, 1, 2]
# 使用 sort() 方法
result = my_list.sort()
print(result)  # 输出: None
print(my_list)  # 输出: [1, 2, 3]
 
my_list = [3, 1, 2]
# 使用 sorted() 函数
new_list = sorted(my_list)
print(new_list)  # 输出: [1, 2, 3]
print(my_list)  # 输出: [3, 1, 2]

14. 字典操作相关

字典键的不可变性

字典的键必须是不可变对象（如整数、字符串、元组等），如果使用可变对象（如列表）作为键，会引发 TypeError。例如：

try:
    my_dict = {[1, 2]: 'value'}
except TypeError as e:
    print(f"Error: {e}")

字典的 get() 方法和直接访问键的区别

直接访问字典中不存在的键会引发 KeyError，而使用 get() 方法可以指定默认值，避免这种错误。例如：

my_dict = {'a': 1}
# 直接访问不存在的键
try:
    value = my_dict['b']
except KeyError as e:
    print(f"KeyError: {e}")
 
# 使用 get() 方法
value = my_dict.get('b', 0)
print(value)  # 输出: 0

15. 时间处理相关

时区问题

在处理时间时，如果不考虑时区，可能会导致时间计算错误。Python 的 datetime 模块默认创建的是无时区对象，使用 pytz 等第三方库可以处理时区问题。例如：

import datetime
import pytz
 
# 创建无时区时间
naive_time = datetime.datetime.now()
print(naive_time)
 
# 创建有时区时间
utc = pytz.UTC
aware_time = utc.localize(naive_time)
print(aware_time)

时间格式化错误

在使用 strftime() 方法进行时间格式化时，如果格式字符串使用错误，会导致输出不符合预期。例如：

import datetime
 
now = datetime.datetime.now()
# 错误的格式字符串
try:
    formatted = now.strftime('%Y-%m-%d %H:%M:%S %Z')  # %Z 在某些情况下可能无法正确显示时区名称
    print(formatted)
except ValueError as e:
    print(f"Formatting error: {e}")

16. 类和继承相关

多重继承的菱形问题

在多重继承中，如果出现菱形继承结构（一个子类继承自两个父类，而这两个父类又继承自同一个祖父类），可能会导致方法调用顺序混乱。Python 使用方法解析顺序（MRO）来解决这个问题，但理解起来可能比较复杂。例如：

class A:
    def method(self):
        print("A's method")
 
class B(A):
    def method(self):
        print("B's method")
 
class C(A):
    def method(self):
        print("C's method")
 
class D(B, C):
    pass
 
d = D()
d.method()  # 输出: B's method，根据 MRO 顺序调用

类属性和实例属性混淆

类属性是类的所有实例共享的属性，而实例属性是每个实例独有的属性。如果不小心修改了类属性，可能会影响所有实例。例如：

class MyClass:
    class_attr = 0
 
    def __init__(self):
        self.instance_attr = 0
 
obj1 = MyClass()
obj2 = MyClass()
 
# 修改类属性
MyClass.class_attr = 1
print(obj1.class_attr)  # 输出: 1
print(obj2.class_attr)  # 输出: 1

17. 布尔运算相关

布尔运算的短路特性

在 Python 中，and 和 or 运算符具有短路特性。and 运算符在第一个操作数为 False 时不会计算第二个操作数；or 运算符在第一个操作数为 True 时不会计算第二个操作数。例如：

def func1():
    print("Function 1 called")
    return False
 
def func2():
    print("Function 2 called")
    return True
 
# and 运算的短路特性
result = func1() and func2()  # 只会调用 func1()
print(result)
 
# or 运算的短路特性
result = func2() or func1()  # 只会调用 func2()
print(result)

18. 递归函数相关

递归深度限制

Python 对递归调用的深度有一定的限制，默认情况下最大递归深度约为 1000 层。如果递归函数没有正确的终止条件，可能会导致 RecursionError。例如：

def recursive_function():
    return recursive_function()
 
try:
    recursive_function()
except RecursionError as e:
    print(f"Recursion error: {e}")

可以使用 sys.setrecursionlimit() 来修改递归深度限制，但不建议过度修改，因为可能会导致栈溢出。

19. 闭包相关

闭包中变量的延迟绑定

在闭包中，内部函数引用的外部函数变量是在调用内部函数时才进行绑定的，而不是在定义内部函数时。这可能导致结果与预期不符。

def create_multipliers():
    return [lambda x: i * x for i in range(5)]
 
for multiplier in create_multipliers():
    print(multiplier(2))

预期输出可能是 0, 2, 4, 6, 8，但实际输出是 8, 8, 8, 8, 8。这是因为当调用内部函数时，i 的值已经变成了 4。可以通过将变量作为默认参数传递来解决这个问题：

def create_multipliers():
    return [lambda x, i=i: i * x for i in range(5)]
 
for multiplier in create_multipliers():
    print(multiplier(2))

20. 集合操作相关

集合的可变性和哈希问题

集合（set）是可变对象，不能作为另一个集合的元素或字典的键，因为集合需要其元素是可哈希的（不可变）。而冻结集合（frozenset）是不可变的，可以作为集合的元素或字典的键。

try:
    my_set = {1, 2, {3, 4}}
except TypeError as e:
    print(f"Error: {e}")
 
frozen_set = frozenset({3, 4})
my_set = {1, 2, frozen_set}
print(my_set)

集合运算的边界情况

在进行集合的交集、并集、差集等运算时，要注意空集和特殊元素的情况。例如，空集与任何集合的交集都是空集。

set_a = set()
set_b = {1, 2, 3}
intersection = set_a & set_b
print(intersection)  # 输出: set()

21. 文件操作相关

文件未正确关闭

在使用 open() 函数打开文件后，如果不手动关闭文件或使用 with 语句，可能会导致资源泄漏。特别是在处理大量文件或长时间运行的程序中，这可能会成为严重问题。

# 错误示例，未关闭文件
file = open('test.txt', 'r')
content = file.read()
# 忘记调用 file.close()
 
# 正确示例，使用 with 语句
with open('test.txt', 'r') as file:
    content = file.read()
# 文件会在 with 语句块结束时自动关闭

文件编码问题

在读取或写入文件时，如果不指定正确的编码方式，可能会导致乱码或 UnicodeDecodeError、UnicodeEncodeError 等错误。

# 错误示例，未指定编码
try:
    with open('test.txt', 'r') as file:
        content = file.read()
except UnicodeDecodeError as e:
    print(f"Encoding error: {e}")
 
# 正确示例，指定编码
with open('test.txt', 'r', encoding='utf-8') as file:
    content = file.read()

22. 元组操作相关

单元素元组的定义

定义单元素元组时，必须在元素后面加上逗号，否则会被解释为普通的括号表达式。

# 错误示例，不是元组
single_value = (1)
print(type(single_value))  # 输出: <class 'int'>
 
# 正确示例，单元素元组
single_tuple = (1,)
print(type(single_tuple))  # 输出: <class 'tuple'>

23. 数据类型转换相关

浮点数和整数转换的精度问题

在将浮点数转换为整数时，Python 会直接截断小数部分，而不是四舍五入。如果需要四舍五入，可以使用 round() 函数。

num = 3.9
int_num = int(num)
print(int_num)  # 输出: 3
 
rounded_num = round(num)
print(rounded_num)  # 输出: 4

字符串和数字转换的错误处理

在将字符串转换为数字时，如果字符串不是有效的数字格式，会引发 ValueError。在进行转换时，最好进行错误处理。

try:
    num = int('abc')
except ValueError as e:
    print(f"Conversion error: {e}")

24. 异步编程相关

异步函数和普通函数调用混淆

在 Python 的异步编程中，异步函数（使用 async def 定义）需要使用 await 关键字调用，不能像普通函数一样直接调用。如果直接调用异步函数，它只会返回一个协程对象，而不会执行函数体。

import asyncio
 
async def async_function():
    print("Async function running")
 
# 错误示例，直接调用异步函数
coroutine = async_function()
print(coroutine)  # 输出: <coroutine object async_function at 0x...>
 
# 正确示例，使用 await 调用
async def main():
    await async_function()
 
asyncio.run(main())

异步任务管理和并发控制

在处理多个异步任务时，需要正确管理任务的创建、启动和等待。如果处理不当，可能会导致任务无法正常执行或资源耗尽。例如，使用 asyncio.gather() 可以并发运行多个协程，但要注意任务数量和资源限制。

import asyncio
 
async def task(i):
    await asyncio.sleep(1)
    print(f"Task {i} completed")
 
async def main():
    tasks = [task(i) for i in range(10)]
    await asyncio.gather(*tasks)
 
asyncio.run(main())

25. 装饰器带参数问题

多层嵌套理解困难

当装饰器需要接受参数时，需要使用多层嵌套函数，这可能会让初学者感到困惑。例如，一个带参数的装饰器：

def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator
 
@repeat(3)
def say_hello():
    print("Hello!")
 
say_hello()

这里的 repeat 函数接受参数，返回一个装饰器函数 decorator，decorator 再返回实际的包装函数 wrapper。理解和实现这种多层嵌套的逻辑需要一定的练习。

26. 数据比较相关

is 和 == 的区别

is 用于比较两个对象是否是同一个对象（即是否具有相同的内存地址），而 == 用于比较两个对象的值是否相等。初学者容易混淆这两个运算符。

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # 输出: True，值相等
print(a is b)  # 输出: False，不是同一个对象
 
c = a
print(a is c)  # 输出: True，是同一个对象

27. 装饰器与类方法结合使用

类方法装饰器参数传递问题

当装饰器应用于类方法时，需要特别注意装饰器如何处理类方法的参数。类方法的第一个参数通常是 cls，如果装饰器没有正确处理这个参数，就会导致调用出错。

def my_decorator(func):
    def wrapper(*args, **kwargs):
        # 这里如果没有正确处理类方法参数可能会出错
        print("Before method call")
        result = func(*args, **kwargs)
        print("After method call")
        return result
    return wrapper
 
class MyClass:
    @my_decorator
    def my_method(cls):
        print("Inside class method")
 
# 错误调用方式（如果装饰器未正确处理参数）
# obj = MyClass()
# obj.my_method() 
 
# 正确使用类方法的调用方式
MyClass.my_method()

装饰器修改类方法行为的意外后果

使用装饰器修改类方法的行为时，可能会影响到类的继承和多态特性。比如，装饰器改变了方法的返回值类型，可能会导致子类在调用该方法时出现兼容性问题。

28. 上下文管理器相关

__enter__ 和 __exit__ 方法实现错误

自定义上下文管理器时，需要正确实现 __enter__ 和 __exit__ 方法。__enter__ 方法负责进入上下文时的初始化操作，__exit__ 方法负责离开上下文时的清理操作。如果 __exit__ 方法返回值处理不当，可能会影响异常的传播。

class MyContextManager:
    def __enter__(self):
        print("Entering context")
        return self
 
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Exiting context")
        # 如果返回 True，异常将被抑制；返回 False，异常将继续传播
        return False  
 
with MyContextManager():
    raise ValueError("An error occurred")

嵌套上下文管理器的使用

在使用多个嵌套的上下文管理器时，需要注意它们的执行顺序和资源管理。如果嵌套逻辑复杂，可能会导致资源释放不及时或重复释放的问题。

with open('file1.txt', 'r') as f1, open('file2.txt', 'w') as f2:
    # 操作文件
    pass

29. 动态属性和方法相关

使用 __getattr__ 和 __setattr__ 时的无限递归

在自定义类中重写 __getattr__ 和 __setattr__ 方法时，如果处理不当，很容易引发无限递归错误。__getattr__ 在访问不存在的属性时被调用，__setattr__ 在设置属性时被调用。

class MyClass:
    def __getattr__(self, name):
        # 错误示例，会导致无限递归
        # return self.name  
        return f"Attribute {name} not found"
 
    def __setattr__(self, name, value):
        # 错误示例，会导致无限递归
        # self.name = value
        super().__setattr__(name, value)
 
obj = MyClass()
print(obj.some_attr)
obj.new_attr = 10

动态添加方法的绑定问题

在运行时动态地为类或实例添加方法时，需要注意方法的绑定问题。如果直接将一个函数赋值给实例属性，该函数不会自动绑定到实例上。

def my_function(self):
    print("This is a dynamically added method")
 
class MyClass:
    pass
 
obj = MyClass()
# 错误方式，函数未正确绑定
# obj.my_method = my_function
# obj.my_method() 
 
# 正确方式，使用 types.MethodType 绑定
import types
obj.my_method = types.MethodType(my_function, obj)
obj.my_method()

30. 元类相关

元类的复杂行为理解困难

元类是创建类的类，Python 中默认的元类是 type。使用元类可以在类创建时动态修改类的行为，但元类的概念比较抽象，其实现和使用容易出错。

class MyMeta(type):
    def __new__(cls, name, bases, attrs):
        # 在类创建时修改属性
        attrs['new_attribute'] = 'Added by metaclass'
        return super().__new__(cls, name, bases, attrs)
 
class MyClass(metaclass=MyMeta):
    pass
 
obj = MyClass()
print(obj.new_attribute)

更多元类信息参考 Python 元类：编程魔法的深度揭秘与实战应用-CSDN博客

元类与类继承的交互问题

当使用元类的类参与继承时，可能会出现一些意想不到的行为。例如，子类继承使用元类的父类时，需要确保元类的行为在继承体系中正确传递和处理。

31. 正则表达式相关

正则表达式的贪婪匹配与非贪婪匹配

正则表达式默认是贪婪匹配，即尽可能多地匹配字符。如果需要非贪婪匹配，需要使用 ? 修饰符。初学者容易忽略这一点，导致匹配结果不符合预期。

import re
 
text = '<html><body><h1>Hello</h1></body></html>'
# 贪婪匹配
greedy_match = re.search(r'<.*>', text)
print(greedy_match.group())  # 输出整个字符串
 
# 非贪婪匹配
non_greedy_match = re.search(r'<.*?>', text)
print(non_greedy_match.group())  # 输出 '<html>'

正则表达式中的转义字符问题

在正则表达式中，某些字符具有特殊含义，如 .、*、+ 等。如果需要匹配这些字符本身，需要使用反斜杠进行转义。同时，Python 字符串本身也使用反斜杠进行转义，这可能会导致混淆。

import re
 
# 匹配点号字符
text = 'abc.def'
# 错误示例，没有正确转义
# match = re.search(r'.', text)  
# 正确示例
match = re.search(r'\.', text)
print(match.group())

32. 内存管理相关

循环引用导致的内存泄漏

当对象之间存在循环引用时，Python 的垃圾回收机制可能无法及时回收这些对象，从而导致内存泄漏。例如，两个对象相互引用对方。

class A:
    def __init__(self):
        self.b = None
 
class B:
    def __init__(self):
        self.a = None
 
a = A()
b = B()
a.b = b
b.a = a
# 此时 a 和 b 形成循环引用，即使不再使用，也可能不会被及时回收

大对象占用内存问题

处理大文件、大列表或大字典等大对象时，如果不注意内存使用情况，可能会导致内存耗尽。例如，一次性将大文件内容全部读入内存。

# 错误示例，可能会耗尽内存
# with open('large_file.txt', 'r') as f:
#     content = f.read()
 
# 正确示例，逐行处理
with open('large_file.txt', 'r') as f:
    for line in f:
        # 处理每一行
        pass

33. 命名空间和作用域相关

局部命名空间和全局命名空间的混淆

在函数内部，如果没有正确区分局部变量和全局变量，可能会导致意外的结果。在函数内部尝试修改全局变量时，如果不使用 global 关键字声明，Python 会默认创建一个局部变量。

x = 10
 
def modify_x():
    x = 20  # 这里创建了一个局部变量 x，而不是修改全局的 x
    print(x)
 
modify_x()
print(x)  # 输出 10，全局变量 x 未被修改
 
def modify_global_x():
    global x
    x = 20  # 使用 global 关键字，修改全局变量 x
    print(x)
 
modify_global_x()
print(x)  # 输出 20，全局变量 x 已被修改

嵌套函数的作用域问题

在嵌套函数中，内部函数可以访问外部函数的变量，但如果要修改外部函数的变量，需要使用 nonlocal 关键字。否则，Python 会认为你在创建一个新的局部变量。

def outer():
    x = 10
    def inner():
        nonlocal x
        x = 20  # 使用 nonlocal 关键字，修改外部函数的变量 x
        print(x)
    inner()
    print(x)  # 输出 20，外部函数的变量 x 已被修改
 
outer()

34. 函数参数解包和可变参数组合使用的问题

当函数参数解包和可变参数（*args 和 **kwargs）组合使用时，可能会出现参数传递混乱的情况。

def func(a, b, *args, **kwargs):
    print(a, b)
    print(args)
    print(kwargs)
 
my_list = [1, 2, 3, 4]
my_dict = {'x': 5, 'y': 6}
 
# 错误调用方式可能导致参数传递错误
# func(*my_list, **my_dict) 
 
# 正确调用方式，确保参数匹配
func(*my_list[:2], *my_list[2:], **my_dict)

35. 多态和鸭子类型相关

鸭子类型的理解偏差

Python 是基于鸭子类型的，即 “如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子”。在使用鸭子类型时，如果没有对对象的方法和属性进行充分的检查，可能会导致运行时错误。

class Duck:
    def quack(self):
        print("Quack!")
 
class Person:
    def talk(self):
        print("Hello!")
 
def make_sound(obj):
    # 假设 obj 有 quack 方法，但 Person 类没有
    obj.quack()  
 
duck = Duck()
person = Person()
make_sound(duck)  # 正常调用
# make_sound(person)  # 会引发 AttributeError
 
# 更好的做法是进行属性检查
def make_sound_safe(obj):
    if hasattr(obj, 'quack') and callable(obj.quack):
        obj.quack()
    else:
        print("Object doesn't have a quack method.")
 
make_sound_safe(person)

36. 线程安全和同步问题

共享资源的并发访问

在多线程编程中，如果多个线程同时访问和修改共享资源，可能会导致数据不一致的问题，也就是线程安全问题。例如，多个线程同时对一个全局变量进行递增操作。

import threading
 
counter = 0
 
def increment():
    global counter
    for _ in range(100000):
        counter += 1
 
threads = []
for _ in range(2):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()
 
for t in threads:
    t.join()
 
print(counter)  # 输出结果可能小于 200000，因为存在线程安全问题

可以使用线程同步机制，如锁（threading.Lock）来解决这个问题：

import threading
 
counter = 0
lock = threading.Lock()
 
def increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1
 
threads = []
for _ in range(2):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()
 
for t in threads:
    t.join()
 
print(counter)  # 输出 200000

37. 版本兼容性问题

Python 2 和 Python 3 的差异

虽然 Python 2 已经不再维护，但在处理旧代码或与遗留系统交互时，仍可能遇到 Python 2 和 Python 3 的兼容性问题。例如，print 在 Python 2 中是语句，在 Python 3 中是函数；raw_input() 在 Python 2 中用于获取用户输入，在 Python 3 中变为 input()。

第三方库的版本兼容性

不同版本的第三方库可能存在 API 差异，使用不兼容的版本可能会导致代码出错。在使用第三方库时，需要注意其文档中关于版本兼容性的说明，并根据需要选择合适的版本。

38. 序列化和反序列化相关

不同序列化模块的差异

Python 有多个序列化模块，如 pickle 和 json。pickle 可以序列化几乎所有的 Python 对象，但它是 Python 特定的，并且存在安全风险（如果反序列化不可信的数据）；json 只能序列化基本数据类型，但其数据格式是跨语言的。如果混淆了它们的使用场景，可能会导致问题。

import pickle
import json
 
data = {'name': 'John', 'age': 30}
 
# 使用 pickle 序列化
pickled_data = pickle.dumps(data)
unpickled_data = pickle.loads(pickled_data)
 
# 使用 json 序列化
try:
    json_data = json.dumps(data)
    loaded_data = json.loads(json_data)
except TypeError as e:
    print(f"JSON serialization error: {e}")

序列化对象的版本兼容性

当使用 pickle 序列化对象时，如果类的定义在序列化和反序列化之间发生了变化，可能会导致反序列化失败。需要注意类的版本管理和序列化数据的兼容性。

39. 错误处理和日志记录相关

忽略异常导致问题难以排查

在代码中使用 try-except 语句时，如果只是简单地忽略异常而不进行任何处理或记录，可能会导致问题难以排查。例如：

try:
    result = 1 / 0
except ZeroDivisionError:
    pass  # 忽略异常，没有任何提示

更好的做法是记录异常信息，方便后续排查问题：

import logging
 
logging.basicConfig(level=logging.ERROR)
 
try:
    result = 1 / 0
except ZeroDivisionError as e:
    logging.error(f"An error occurred: {e}")

日志级别设置不合理

在使用日志记录时，如果日志级别设置不合理，可能会导致重要的信息没有被记录，或者记录了过多无用的信息。需要根据实际情况选择合适的日志级别，如 DEBUG、INFO、WARNING、ERROR、CRITICAL。

40. 生成器使用中的资源释放问题

生成器未正确关闭

生成器在使用完后，如果其中包含一些需要手动释放的资源（如文件句柄、网络连接等），而没有正确关闭生成器，可能会造成资源泄漏。例如，在生成器函数中打开文件，却没有合适的方式确保文件被关闭。

def file_reader(file_path):
    file = open(file_path, 'r')
    try:
        for line in file:
            yield line
    finally:
        file.close()
 
 
gen = file_reader('example.txt')
for line in gen:
    print(line)
# 若提前中断迭代，文件可能未正常关闭，更好的做法是用 with 语句

使用with读取文件示例：

with open('workfile', encoding="utf-8") as f:
    read_data = f.read()
 
# 我们可以检测文件是否已被自动关闭。
f.closed
True

文件读写更多信息参考 7. 输入与输出 — Python 3.12.9 文档

生成器状态管理混乱

生成器有自己的状态，如是否已经启动、是否已经结束等。如果在生成器运行过程中，错误地尝试操作其状态，可能会引发 RuntimeError。例如，在生成器已经耗尽后再次尝试迭代它。

gen = (i for i in range(3))
for num in gen:
    print(num)
# 此时生成器已耗尽
try:
    next(gen)
except StopIteration:
    print("Generator is exhausted.")

41. 描述符相关

描述符协议实现错误

描述符是实现了 __get__、__set__ 或 __delete__ 方法的对象。在自定义描述符时，如果这些方法实现错误，会导致属性访问和赋值出现问题。比如，__get__ 方法返回值不符合预期。

class MyDescriptor:
    def __get__(self, instance, owner):
        if instance is None:
            return self
        # 错误返回可能导致问题
        return "Wrong value"
 
class MyClass:
    attr = MyDescriptor()
 
obj = MyClass()
print(obj.attr)  # 可能得到不符合预期的结果

描述符在类和实例中的行为差异

描述符在类和实例层面的行为有所不同。在类上访问描述符和在实例上访问描述符时，__get__ 方法的参数会有不同，需要正确处理这些差异，否则可能导致错误。

42. 函数注解和类型提示相关

类型提示只是提示而非强制约束

Python 的类型提示（函数注解）主要用于提高代码的可读性和可维护性，但它并不对函数参数和返回值进行实际的类型检查。如果开发者错误地认为类型提示会强制执行类型约束，可能会在运行时遇到类型不匹配的错误。

def add_numbers(a: int, b: int) -> int:
    return a + b
 
# 可以传入非整数类型，不会在语法层面报错
result = add_numbers("1", "2")

复杂类型提示使用不当

对于复杂的类型，如嵌套的列表、字典，或者自定义类型的组合，类型提示的书写可能会比较复杂。如果使用不当，可能无法准确表达代码的意图，甚至让代码更难理解。

from typing import List, Dict
 
# 复杂类型提示示例
def process_data(data: List[Dict[str, int]]) -> None:
    pass
 
# 可能会错误地传入不符合结构的数据

43. 协程中的异常传播问题

协程内异常未正确处理

在异步编程的协程中，如果协程内部发生异常但没有在协程内部或调用处进行正确处理，可能会导致整个异步任务崩溃。例如，在使用 asyncio.gather 运行多个协程时，一个协程抛出异常可能影响其他协程。

import asyncio
 
async def faulty_coroutine():
    raise ValueError("An error occurred")
 
async def main():
    try:
        await asyncio.gather(faulty_coroutine())
    except ValueError as e:
        print(f"Caught exception: {e}")
 
asyncio.run(main())

异常在不同事件循环中的传播

当涉及多个事件循环或者在不同的异步环境中运行协程时，异常的传播和捕获会变得更加复杂。如果没有正确处理，可能会导致异常丢失或者程序出现难以调试的错误。

44. 模块导入路径和搜索顺序问题

自定义模块和标准库模块命名冲突

如果自定义模块的名称与 Python 标准库模块的名称相同，会导致导入时出现混淆。Python 在导入模块时，会优先搜索当前工作目录，可能会错误地导入自定义模块而不是标准库模块。

# 假设当前目录下有一个名为 math.py 的自定义模块
import math  # 可能导入的是自定义的 math.py 而非标准库的 math 模块

模块导入路径配置错误

在大型项目中，模块的导入路径可能会比较复杂。如果 sys.path 配置错误，或者使用相对导入时路径设置不当，会导致 ModuleNotFoundError。例如，在包内部使用相对导入时，需要确保文件结构和 __init__.py 文件的正确使用。

45. 内置函数和方法的默认参数陷阱

内置排序函数的 key 参数使用错误

在使用 sorted() 或列表的 sort() 方法时，key 参数用于指定排序的规则。如果 key 函数实现错误，可能会导致排序结果不符合预期。

data = [(1, 3), (2, 1), (3, 2)]
# 错误示例，排序规则不符合预期
sorted_data = sorted(data, key=lambda x: x[1] > 2)
print(sorted_data)
 
# 正确示例，按元组第二个元素排序
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)

map()、filter() 等函数的结果处理

map() 和 filter() 函数返回的是迭代器，而不是列表。如果错误地认为它们返回的是列表并直接进行列表操作，可能会导致错误。

numbers = [1, 2, 3]
result = map(lambda x: x * 2, numbers)
# 错误示例，不能直接按列表索引访问
# print(result[0]) 
 
# 正确示例，转换为列表
result_list = list(result)
print(result_list[0])

46. 数据结构操作的边界条件

列表索引越界

在使用列表时，如果索引超出了列表的有效范围，会引发 IndexError。在进行列表操作时，需要确保索引的合法性。

my_list = [1, 2, 3]
try:
    print(my_list[3])  # 索引越界
except IndexError as e:
    print(f"Index error: {e}")

如果是获取列表的最后一个元素，可以使用 -1 作为索引， 如 my_list[-1] 结果为 3

字典键不存在

在访问字典的键时，如果键不存在，会引发 KeyError。可以使用 get() 方法来避免这种错误。

my_dict = {'a': 1}
try:
    print(my_dict['b'])  # 键不存在
except KeyError as e:
    print(f"Key error: {e}")
 
# 使用 get() 方法
print(my_dict.get('b', 0))

ps: 使用get方法来获取字典的值，还可以设置默认值

字典的get方法定义参考：

@overload # type: ignore[override]

def get(self, key: _KT, /) -> _VT | None: ...

@overload

def get(self, key: _KT, default: _VT, /) -> _VT: ...

@overload

def get(self, key: _KT, default: _T, /) -> _VT | _T: ...

47. 魔术方法使用误区

__eq__ 方法与哈希的一致性问题

当你自定义类并重载 __eq__ 方法来定义对象的相等性时，需要同时确保 __hash__ 方法的实现与 __eq__ 保持一致。因为在 Python 中，可哈希对象要求如果两个对象相等，那么它们的哈希值也必须相等。若不一致，在将对象用作字典键或集合元素时会出现意外行为。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
 
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
 
    # 错误示例：未重写 __hash__ 导致不一致
    # 如果两个相等的 Point 对象哈希值不同，在集合或字典中会被视为不同元素
 
    # 正确示例：重写 __hash__ 以保持一致性
    def __hash__(self):
        return hash((self.x, self.y))
 
 
p1 = Point(1, 2)
p2 = Point(1, 2)
my_set = {p1}
print(p2 in my_set)  # 若 __hash__ 未正确实现，可能输出 False

__del__ 方法的不确定性

__del__ 方法是在对象被垃圾回收时调用的。但由于 Python 的垃圾回收机制是不确定的，不能保证 __del__ 方法会在对象不再被使用时立即调用。此外，如果 __del__ 方法中存在异常，异常不会被抛出，而是会被记录为警告，这可能导致资源无法正确释放。

class Resource:
    def __init__(self):
        print("Resource created")
 
    def __del__(self):
        try:
            # 释放资源的操作
            print("Resource released")
        except Exception as e:
            # 异常不会抛出，仅记录警告
            pass
 
 
res = Resource()
res = None  # 对象可能不会立即被回收，__del__ 调用时间不确定

48. 多进程中的共享内存使用

共享内存对象的同步问题

在多进程编程中，使用 multiprocessing.Value 或 multiprocessing.Array 等共享内存对象时，如果多个进程同时对其进行读写操作，可能会导致数据不一致。虽然这些对象提供了锁机制，但如果没有正确使用锁来同步访问，就会出现问题。

import multiprocessing
 
 
def increment(counter):
    for _ in range(1000):
        # 错误示例：未使用锁保护共享变量
        # counter.value += 1
        # 正确示例：使用锁
        with counter.get_lock():
            counter.value += 1
 
 
if __name__ == '__main__':
    counter = multiprocessing.Value('i', 0)
    processes = []
    for _ in range(2):
        p = multiprocessing.Process(target=increment, args=(counter,))
        processes.append(p)
        p.start()
 
    for p in processes:
        p.join()
 
    print(counter.value)  # 若未同步，结果可能小于预期

共享内存对象的类型和大小限制

multiprocessing.Value 和 multiprocessing.Array 对存储的数据类型和大小有一定限制。例如，multiprocessing.Value 只能存储基本数据类型，multiprocessing.Array 需要指定数组元素的类型。如果使用不当，可能会引发异常。

import multiprocessing
 
# 错误示例：尝试存储复杂对象
# shared_obj = multiprocessing.Value('object', {'key': 'value'})
 
# 正确示例：存储基本数据类型
shared_int = multiprocessing.Value('i', 10)

49. 装饰器的嵌套与顺序问题

装饰器嵌套的执行顺序

当多个装饰器嵌套使用时，装饰器的执行顺序是从下往上的，也就是最靠近函数定义的装饰器会最先应用。如果对这个顺序理解错误，可能会导致装饰器的行为不符合预期。

def decorator1(func):
    def wrapper(*args, **kwargs):
        print("Decorator 1 before")
        result = func(*args, **kwargs)
        print("Decorator 1 after")
        return result
 
    return wrapper
 
 
def decorator2(func):
    def wrapper(*args, **kwargs):
        print("Decorator 2 before")
        result = func(*args, **kwargs)
        print("Decorator 2 after")
        return result
 
    return wrapper
 
 
@decorator1
@decorator2
def my_function():
    print("Inside function")
 
 
my_function()
# 执行顺序是 decorator2 先应用，然后 decorator1 应用

装饰器嵌套时的参数传递

在装饰器嵌套的情况下，要确保每个装饰器都能正确处理传递给函数的参数。如果某个装饰器对参数进行了不恰当的修改或拦截，可能会导致后续装饰器或原函数无法正常工作。

50. 上下文管理器中的异常抑制问题

__exit__ 方法返回值对异常的影响

在自定义上下文管理器时，__exit__ 方法的返回值决定了上下文管理器内部发生的异常是否会继续传播。如果 __exit__ 返回 True，异常将被抑制；返回 False 或不返回值（相当于返回 None），异常将继续传播。如果对这个返回值的作用理解错误，可能会导致异常处理不符合预期。

class MyContext:
    def __enter__(self):
        return self
 
    def __exit__(self, exc_type, exc_val, exc_tb):
        # 错误示例：抑制所有异常，可能掩盖问题
        # return True
        # 正确示例：让异常继续传播
        return False
 
 
with MyContext():
    raise ValueError("An error occurred")

51. 动态导入模块的安全风险

从不可信源进行动态导入

Python 提供了 importlib.import_module 等函数来动态导入模块。如果从不可信的源获取模块名并进行动态导入，可能会导致代码注入攻击。攻击者可以通过构造恶意的模块名来执行任意代码。

import importlib
 
# 错误示例：从用户输入获取模块名进行导入
# module_name = input("Enter module name: ")
# module = importlib.import_module(module_name)
 
# 正确示例：对模块名进行严格验证和白名单过滤
allowed_modules = ['math', 'os']
module_name = 'math'
if module_name in allowed_modules:
    module = importlib.import_module(module_name)

52. 切片赋值的长度匹配问题

切片赋值时长度不匹配的影响

在对列表进行切片赋值时，如果赋值的序列长度与切片的长度不相等，列表的长度会相应改变。这可能会导致意外的结果，尤其是在需要保持列表长度不变的场景中。

my_list = [1, 2, 3, 4, 5]
# 切片长度和赋值序列长度不同，列表长度会改变
my_list[1:3] = [6, 7, 8]
print(my_list)  # 输出: [1, 6, 7, 8, 4, 5]

切片详解参考： Python 切片全解析：从基础到负步长的实用秘籍-CSDN博客

53. 字典的 update 方法的行为

update 方法覆盖键值对

字典的 update 方法用于将一个字典的键值对更新到另一个字典中。如果两个字典存在相同的键，原字典中的键值对会被覆盖。如果没有意识到这一点，可能会丢失原有的数据。

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}，'b' 的值被覆盖

54. 循环语句中的变量作用域

循环变量在循环外的可见性

在 Python 中，循环变量在循环结束后依然存在于其所在的作用域内，这与其他一些编程语言不同，可能会导致意外的结果。

for i in range(3):
    pass
print(i)  # 输出 2，循环结束后 i 保留了最后一次迭代的值

嵌套循环中内层循环变量对外部的影响

在嵌套循环中，如果内层循环变量名与外层循环变量名冲突，可能会导致逻辑混乱。

for i in range(3):
    for i in range(2):
        print(i, end=" ")
    print()
# 这里内层循环的 i 覆盖了外层循环的 i，输出不符合预期逻辑

55. 列表推导式中的副作用

列表推导式内函数调用的副作用

在列表推导式中调用有副作用的函数（即函数除了返回值外还会对外部环境产生影响）可能会导致意外的结果，而且代码的可读性也会降低。

results = []
 
def side_effect_function(x):
    results.append(x * 2)
    return x
 
my_list = [1, 2, 3]
new_list = [side_effect_function(i) for i in my_list]
print(new_list)  # 输出 [1, 2, 3]
print(results)  # 输出 [2, 4, 6]，可能不是预期的额外操作方式

56. 函数参数的默认值类型选择

使用可变对象作为默认参数

前面提到过使用可变对象（如列表、字典）作为函数的默认参数会有问题，因为默认参数在函数定义时就被创建，后续调用函数时会共用同一个对象。

def add_to_list(item, my_list=[]):
    my_list.append(item)
    return my_list
 
print(add_to_list(1))  # 输出 [1]
print(add_to_list(2))  # 输出 [1, 2]，不是预期的只包含 2 的列表

57. 正则表达式中的量词使用

量词的贪婪与非贪婪模式混淆

正则表达式中的量词（如 \*、+、?）默认是贪婪模式，即尽可能多地匹配字符。使用非贪婪模式（在量词后加 ?）时，如果没有理解清楚，可能会得到不符合预期的匹配结果。

import re
 
text = "<html><body><h1>Hello</h1></body></html>"
greedy_match = re.search(r'<.*>', text)
print(greedy_match.group())  # 输出整个字符串
 
non_greedy_match = re.search(r'<.*?>', text)
print(non_greedy_match.group())  # 输出 '<html>'

量词与边界的组合问题

在使用量词时，与边界条件（如 ^ 表示字符串开头，$ 表示字符串结尾）结合使用可能会出现匹配不准确的情况。

import re
 
text = "abc\n123"
pattern = r'^.*$'
matches = re.findall(pattern, text, re.M)  # 使用多行模式
print(matches)  # 输出 ['abc', '123']，若不理解多行模式和边界组合可能出错

58. 元组和列表的性能差异使用误区

不考虑场景随意选择元组或列表

元组是不可变对象，列表是可变对象，它们在性能上有所差异。元组的创建和访问速度通常比列表快，因为其不可变的特性使得内存分配和管理更高效。如果在不需要可变特性的场景下使用列表，可能会造成性能浪费；反之，在需要修改元素的场景下使用元组则会导致代码无法正常工作。

# 适合使用元组的场景：存储常量数据
coordinates = (10, 20)
 
# 适合使用列表的场景：需要动态添加或删除元素
numbers = [1, 2, 3]
numbers.append(4)

59. 异步编程中的任务调度问题

任务阻塞导致异步失效

在异步编程中，如果在协程中执行了阻塞操作（如使用传统的同步 I/O 操作），会导致整个事件循环阻塞，使得异步编程的优势无法体现。

import asyncio
import time
 
async def blocking_task():
    time.sleep(1)  # 阻塞操作，会阻塞事件循环
    print("Blocking task completed")
 
async def main():
    task = asyncio.create_task(blocking_task())
    await task
 
asyncio.run(main())
# 应该使用异步 I/O 操作（如 aiohttp 进行网络请求）来避免阻塞

任务的并发数量控制不当

在使用 asyncio.gather 等方法并发执行多个任务时，如果不控制并发数量，可能会导致系统资源耗尽。例如，同时发起大量的网络请求可能会使服务器拒绝服务或本地资源耗尽。

import asyncio
 
async def task():
    await asyncio.sleep(1)
    print("Task completed")
 
async def main():
    tasks = [task() for _ in range(1000)]
    # 可以使用 Semaphore 来控制并发数量
    semaphore = asyncio.Semaphore(10)
    async def limited_task():
        async with semaphore:
            return await task()
    limited_tasks = [limited_task() for _ in range(1000)]
    await asyncio.gather(*limited_tasks)
 
asyncio.run(main())

60. 自定义异常类的使用

异常类继承和捕获问题

在自定义异常类时，如果继承关系处理不当，可能会导致异常捕获不准确。例如，捕获基类异常可能会掩盖更具体的异常信息。

class MyBaseError(Exception):
    pass
 
class MySpecificError(MyBaseError):
    pass
 
try:
    raise MySpecificError("Specific error occurred")
except MyBaseError as e:
    print(f"Caught base error: {e}")  # 可能无法准确区分具体异常类型

61. 数据类型转换中的精度丢失

浮点数转换为整数的精度丢失

将浮点数转换为整数时，Python 会直接截断小数部分，而不是进行四舍五入，这可能会导致精度丢失，特别是在需要精确计算的场景中。

num = 3.9
int_num = int(num)
print(int_num)  # 输出 3，丢失了小数部分

高精度数据类型转换问题

在处理高精度数据（如 decimal 模块中的 Decimal 类型）时，转换为其他数据类型（如 float）可能会导致精度丢失。

from decimal import Decimal
 
decimal_num = Decimal('3.14159265358979323846')
float_num = float(decimal_num)
print(float_num)  # 输出 3.141592653589793，精度丢失

62. 自定义迭代器实现问题

迭代器协议实现错误

要创建自定义迭代器，类需要实现 __iter__ 和 __next__ 方法。若 __iter__ 方法没有返回迭代器对象本身（即 self），或者 __next__ 方法在迭代结束时没有正确抛出 StopIteration 异常，会导致迭代行为异常。

class MyIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0
 
    # 错误示例：__iter__ 未返回 self
    # def __iter__(self):
    #     return MyIterator(self.limit)
 
    def __iter__(self):
        return self
 
    def __next__(self):
        if self.current < self.limit:
            value = self.current
            self.current += 1
            return value
        # 若忘记抛出 StopIteration 会导致无限循环
        raise StopIteration
 
 
my_iter = MyIterator(3)
for num in my_iter:
    print(num)

63. 元组解包与数量不匹配

解包元素数量不一致

在进行元组解包时，如果左侧变量数量与右侧元组元素数量不匹配，会引发 ValueError。

t = (1, 2, 3)
# 错误示例：变量数量与元组元素数量不匹配
# a, b = t
 
# 正确示例
a, b, c = t
print(a, b, c)

64. 多线程中的锁竞争与死锁

锁竞争导致性能下降

在多线程编程中，过度使用锁会导致线程频繁竞争锁资源，从而降低程序性能。比如，若在锁保护的代码块中执行耗时操作，会使其他线程长时间等待。

import threading
 
lock = threading.Lock()
shared_variable = 0
 
 
def increment():
    global shared_variable
    for _ in range(100000):
        with lock:
            # 错误示例：锁内执行耗时操作
            # time.sleep(0.0001)
            shared_variable += 1
 
 
threads = []
for _ in range(2):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()
 
for t in threads:
    t.join()
 
print(shared_variable)

死锁问题

当多个线程相互等待对方释放锁时，会发生死锁。例如，线程 A 持有锁 L1 并等待锁 L2，而线程 B 持有锁 L2 并等待锁 L1，就会陷入死锁状态。

import threading
 
lock1 = threading.Lock()
lock2 = threading.Lock()
 
 
def thread_a():
    lock1.acquire()
    try:
        # 模拟操作
        lock2.acquire()
        try:
            pass
        finally:
            lock2.release()
    finally:
        lock1.release()
 
 
def thread_b():
    lock2.acquire()
    try:
        # 模拟操作
        lock1.acquire()
        try:
            pass
        finally:
            lock1.release()
    finally:
        lock2.release()
 
 
t1 = threading.Thread(target=thread_a)
t2 = threading.Thread(target=thread_b)
t1.start()
t2.start()
t1.join()
t2.join()

65. 集合操作中的类型兼容性

不同类型集合元素的操作问题

集合要求其元素是可哈希的，若尝试将不可哈希的元素添加到集合中，会引发 TypeError。另外，在进行集合的并集、交集等操作时，要确保集合元素类型的兼容性。

my_set = {1, 2, 3}
# 错误示例：尝试添加不可哈希的列表
# my_set.add([4, 5])
 
# 正确示例：添加可哈希的元素
my_set.add(4)
print(my_set)

66. 函数返回值的多样性

未明确返回值类型

如果函数可能返回不同类型的值（如返回 None 或一个具体对象），调用者在使用返回值时若未进行类型检查，可能会引发 AttributeError 等异常。

def get_data(condition):
    if condition:
        return {'key': 'value'}
    return None
 
 
result = get_data(False)
# 错误示例：未检查返回值是否为 None 就访问属性
# print(result['key'])
 
# 正确示例：进行类型检查
if result is not None:
    print(result['key'])

67. 异步编程中的资源泄漏

异步上下文管理器未正确使用

在异步编程中，使用异步上下文管理器（如 async with）管理资源时，如果没有正确实现 __aenter__ 和 __aexit__ 方法，可能会导致资源泄漏。

import asyncio
 
 
class AsyncResource:
    def __init__(self):
        self.opened = False
 
    async def __aenter__(self):
        # 模拟资源打开
        self.opened = True
        return self
 
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        # 模拟资源关闭
        self.opened = False
 
 
async def main():
    async with AsyncResource() as resource:
        # 使用资源
        pass
 
 
asyncio.run(main())

68. 字典的 popitem 方法

字典 popitem 方法顺序误解

popitem 方法用于随机移除并返回字典中的一个键值对（Python 3.7 及以后版本按插入顺序移除）。如果误以为它总是移除特定的键值对（如第一个或最后一个插入的），可能会导致逻辑错误。

my_dict = {'a': 1, 'b': 2, 'c': 3}
key, value = my_dict.popitem()
print(key, value)  # 输出的键值对取决于 Python 版本和插入顺序

69. 模块的 __all__ 变量使用

__all__ 变量对 from module import * 的影响

在模块中定义 __all__ 变量可以控制使用 from module import * 语句时导入的内容。如果没有正确设置 __all__，可能会导致不必要的内容被导入，或者需要的内容未被导入。

# module.py
__all__ = ['func1']
 
 
def func1():
    pass
 
 
def func2():
    pass
 
 
# main.py
from module import *
# 此时只能使用 func1，func2 未被导入

70. 字符串格式化相关问题

旧式 % 格式化与新式 f - 字符串混用误区

Python 中有旧式的 % 格式化和新式的 f - 字符串、str.format() 等格式化方式。混用不同的格式化方式不仅会让代码风格混乱，还可能导致错误。例如，在需要 f - 字符串的地方使用了 % 格式化语法。

name = "Alice"
age = 25
# 错误示例：混用格式
# print("My name is %s and I'm {age} years old." % name)
 
# 正确使用 f - 字符串
print(f"My name is {name} and I'm {age} years old.")
 
# 正确使用 % 格式化
print("My name is %s and I'm %d years old." % (name, age))

f - 字符串中的表达式错误

f - 字符串中可以嵌入表达式，但如果表达式语法错误，会导致运行时错误。而且在表达式中引用未定义的变量也会出错。

x = 5
# 错误示例：表达式语法错误
# print(f"The square of {x is 2} is {x**2}")
 
# 正确示例
print(f"The square of {x} is {x**2}")

71. 递归函数的性能与栈溢出风险

未优化的递归导致性能问题

递归函数简洁但可能存在性能问题，尤其是在递归深度较大时。每次递归调用都会在栈上分配新的栈帧，如果递归没有适当的终止条件或者没有进行尾递归优化（Python 本身不支持尾递归优化），会消耗大量的栈空间和时间。

# 未优化的斐波那契数列递归实现
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
 
# 调用深度较大时性能极差
# result = fibonacci(35)
 
# 可以使用迭代方式优化
def fibonacci_iterative(n):
    if n <= 1:
        return n
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

栈溢出错误

如果递归深度超过 Python 解释器的最大递归深度限制（默认约 1000 层），会引发 RecursionError。例如，一个没有正确终止条件的递归函数会不断调用自身，最终导致栈溢出。

def infinite_recursion():
    return infinite_recursion()
 
try:
    infinite_recursion()
except RecursionError as e:
    print(f"Recursion error: {e}")

72. 枚举类型使用中的值比较问题

枚举成员值比较的误解

在 Python 的 enum 模块中，枚举成员是单例对象，比较成员时应该使用 is 而不是 == 来比较身份，虽然 == 通常也能正常工作，但使用 is 更符合语义。另外，枚举成员的值比较也需要注意类型和含义。

import enum
 
 
class Color(enum.Enum):
    RED = 1
    GREEN = 2
    BLUE = 3
 
 
red1 = Color.RED
red2 = Color.RED
 
# 推荐使用 is 比较成员身份
print(red1 is red2)  # 输出 True
 
# 注意值比较的语义
print(red1.value == 1)  # 输出 True

73. 装饰器中的异步与同步混淆

在异步函数上使用同步装饰器

如果在异步函数上使用同步装饰器，可能会阻塞异步事件循环，破坏异步编程的优势。因为同步装饰器中的代码是按顺序执行的，不会让出控制权给其他协程。

import asyncio
 
 
def sync_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
 
    return wrapper
 
 
@sync_decorator
async def async_function():
    await asyncio.sleep(1)
    print("Async function executed")
 
 
# 这种调用会阻塞事件循环
asyncio.run(async_function())
 
# 应该使用异步装饰器
def async_decorator(func):
    async def wrapper(*args, **kwargs):
        print("Before async function call")
        result = await func(*args, **kwargs)
        print("After async function call")
        return result
 
    return wrapper

74. 命名元组的属性访问与修改问题

命名元组属性的不可变性

命名元组（collections.namedtuple）是不可变的，类似于普通元组。如果尝试直接修改命名元组的属性，会引发 AttributeError。若需要修改，可以使用 _replace() 方法创建一个新的命名元组。

from collections import namedtuple
 
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
 
# 错误示例：尝试直接修改属性
# p.x = 3
 
# 正确做法：使用 _replace() 方法
new_p = p._replace(x=3)
print(new_p)

75. 自定义序列类型的方法实现问题

自定义序列方法实现不完整

当自定义一个序列类型（如列表的子类或实现序列协议的类）时，需要实现 __len__、__getitem__ 等必要的方法。如果方法实现不完整，可能会导致序列的基本操作（如长度计算、索引访问）无法正常工作。

class MySequence:
    def __init__(self, data):
        self.data = data
 
    # 错误示例：缺少 __len__ 方法
    # def __getitem__(self, index):
    #     return self.data[index]
 
    def __len__(self):
        return len(self.data)
 
    def __getitem__(self, index):
        return self.data[index]
 
 
my_seq = MySequence([1, 2, 3])
print(len(my_seq))  # 正常输出长度
print(my_seq[1])  # 正常索引访问

76. 异步队列的满与空处理问题

异步队列满或空时的阻塞问题

在使用 asyncio.Queue 等异步队列时，如果队列已满或为空，调用 put() 或 get() 方法可能会阻塞。需要使用异步的 put_nowait() 和 get_nowait() 方法结合异常处理来避免阻塞，或者使用 await 配合 put() 和 get() 并处理可能的超时情况。

import asyncio
 
 
async def producer(queue):
    for i in range(5):
        await queue.put(i)
        print(f"Produced {i}")
 
 
async def consumer(queue):
    while True:
        try:
            item = await queue.get()
            print(f"Consumed {item}")
            queue.task_done()
        except asyncio.QueueEmpty:
            break
 
 
async def main():
    queue = asyncio.Queue(maxsize=2)
    producer_task = asyncio.create_task(producer(queue))
    consumer_task = asyncio.create_task(consumer(queue))
    await producer_task
    await queue.join()
    consumer_task.cancel()
 
 
asyncio.run(main())

77. 弱引用使用不当

弱引用对象提前消失

Python 的弱引用（weakref 模块）允许你引用一个对象而不增加其引用计数。这意味着当对象的其他强引用被移除后，对象可能会被垃圾回收，弱引用将变为无效。如果在使用弱引用时没有检查其有效性，可能会引发 ReferenceError。

import weakref
 
class MyClass:
    pass
 
obj = MyClass()
weak_ref = weakref.ref(obj)
 
# 删除强引用
del obj
 
# 错误示例：未检查弱引用是否有效
# print(weak_ref().some_attribute)
 
# 正确示例
if weak_ref() is not None:
    print(weak_ref().some_attribute)
else:
    print("The object has been garbage - collected.")

弱引用回调函数的副作用

可以为弱引用设置回调函数，当弱引用的对象被垃圾回收时会调用该回调函数。如果回调函数中有复杂的操作或副作用，可能会影响程序的稳定性，例如在回调函数中修改全局状态。

import weakref
 
def callback(ref):
    # 错误示例：在回调函数中进行复杂操作或修改全局状态
    # global some_global_variable
    # some_global_variable = None
    print("The object has been garbage - collected.")
 
class MyClass:
    pass
 
obj = MyClass()
weak_ref = weakref.ref(obj, callback)
del obj

78. 随机数生成的种子和分布问题

随机数种子设置错误

在使用 random 模块生成随机数时，设置种子可以使随机数序列可重复。如果种子设置不当或忘记设置种子，可能会导致测试结果不可复现，或者在需要可预测随机序列的场景中出现问题。

import random
 
# 错误示例：未设置种子，每次运行结果不同
# print(random.randint(1, 10))
 
# 正确示例：设置种子
random.seed(42)
print(random.randint(1, 10))  # 每次运行只要种子相同，结果相同

随机数分布理解错误

不同的随机数生成函数有不同的分布特性。例如，random.random() 生成的是 [0, 1) 之间均匀分布的随机浮点数。如果错误地认为它符合其他分布（如正态分布），在需要特定分布随机数的场景中会导致结果不准确。

import random
 
# 错误示例：将均匀分布随机数当作正态分布使用
# num = random.random()
# 正确示例：使用正态分布随机数生成函数
import math
mu = 0
sigma = 1
num = random.gauss(mu, sigma)

79. 函数参数的解包顺序和规则

解包多个可迭代对象时的顺序问题

在函数调用时，可以使用 * 对多个可迭代对象进行解包。如果解包顺序和函数参数的位置不匹配，会导致参数传递错误。

def my_function(a, b, c):
    print(a, b, c)
 
list1 = [1, 2]
list2 = [3]
 
# 错误示例：解包顺序错误
# my_function(*list2, *list1)
 
# 正确示例
my_function(*list1, *list2)

解包字典时的键值匹配问题

使用 ** 解包字典作为关键字参数传递给函数时，字典的键必须与函数参数名匹配。如果键不匹配，会引发 TypeError。

def my_function(name, age):
    print(name, age)
 
data = {'name': 'Alice', 'age': 25}
 
# 错误示例：字典键与函数参数不匹配
# wrong_data = {'full_name': 'Alice', 'years': 25}
# my_function(**wrong_data)
 
# 正确示例
my_function(**data)

80. 协程中的超时处理不当

未正确设置超时时间

在异步编程中，使用 asyncio.wait_for() 等方法设置协程的超时时间时，如果超时时间设置不合理，可能会导致协程过早被取消或长时间运行。

import asyncio
 
async def long_running_task():
    await asyncio.sleep(5)
    return "Task completed"
 
async def main():
    try:
        # 错误示例：超时时间设置过短
        # result = await asyncio.wait_for(long_running_task(), timeout = 1)
 
        # 正确示例：合理设置超时时间
        result = await asyncio.wait_for(long_running_task(), timeout = 6)
        print(result)
    except asyncio.TimeoutError:
        print("Task timed out")
 
asyncio.run(main())

超时异常处理不完整

当协程超时时会抛出 asyncio.TimeoutError 异常，如果没有对该异常进行适当处理，可能会导致程序崩溃或资源泄漏。

81. 类的 __slots__ 属性使用误区

__slots__ 限制实例属性添加的误解

__slots__ 属性可以限制类的实例动态添加属性，节省内存。但如果错误地认为可以在 __slots__ 之外添加属性，会引发 AttributeError。

class MyClass:
    __slots__ = ['x', 'y']
 
obj = MyClass()
obj.x = 1
obj.y = 2
 
# 错误示例：尝试添加 __slots__ 之外的属性
# obj.z = 3

__slots__ 与继承的问题

当使用 __slots__ 的类被继承时，子类如果没有正确处理 __slots__，可能会导致属性访问异常。子类的 __slots__ 会与父类的 __slots__ 合并。

class Parent:
    __slots__ = ['x']
 
class Child(Parent):
    __slots__ = ['y']
 
obj = Child()
obj.x = 1
obj.y = 2

82. 日志记录配置的重复与冲突

多次配置日志记录器

在一个 Python 程序中，如果多次对日志记录器进行配置，可能会导致日志重复输出或配置冲突。例如，多次调用 logging.basicConfig() 会覆盖之前的配置。

import logging
 
# 错误示例：多次配置日志记录器
# logging.basicConfig(level = logging.DEBUG)
# logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s')
 
# 正确示例：只配置一次
logging.basicConfig(level = logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
logging.debug('This is a debug message')

日志处理器的重复添加

如果在日志记录器中重复添加相同的处理器，会导致日志重复输出。

import logging
 
logger = logging.getLogger(__name__)
handler = logging.StreamHandler()
 
# 错误示例：重复添加处理器
# logger.addHandler(handler)
# logger.addHandler(handler)
 
# 正确示例：只添加一次
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
logger.debug('This is a debug message')

83. 生成器表达式和列表推导式的性能差异使用不当

在大数据量场景下使用列表推导式

列表推导式会一次性生成整个列表，占用大量内存。在处理大数据量时，如果使用列表推导式而不是生成器表达式，可能会导致内存溢出。

# 错误示例：大数据量使用列表推导式
# large_list = [i for i in range(100000000)]
 
# 正确示例：使用生成器表达式
large_generator = (i for i in range(100000000))
for num in large_generator:
    if num > 10:
        break

更多详情参考 深度解析 Python 列表推导式与生成器表达式：原理、用法与优劣比较-CSDN博客

84. 字节串和字符串的转换问题

混淆编码和解码操作

在 Python 中，字符串（str 类型）和字节串（bytes 类型）之间的转换需要使用编码（encode）和解码（decode）操作。如果混淆了这两个操作，或者使用了错误的编码格式，会导致 UnicodeEncodeError 或 UnicodeDecodeError。

text = "你好"
# 编码：字符串 -> 字节串
byte_data = text.encode('utf-8')
 
# 错误示例：错误使用，用解码操作处理字符串
# wrong_data = text.decode('utf-8')
 
# 解码：字节串 -> 字符串
decoded_text = byte_data.decode('utf-8')

不同编码格式的兼容性

不同的编码格式对字符的表示方式不同。在进行字节串和字符串转换时，如果编码格式不兼容，会出现乱码或转换失败。例如，尝试用 ascii 编码去处理包含非 ASCII 字符的字符串。

text = "你好"
try:
    # 错误示例：使用不兼容的编码格式
    byte_data = text.encode('ascii')
except UnicodeEncodeError as e:
    print(f"编码错误: {e}")

85. 条件判断中的布尔值陷阱

空容器的布尔值

在 Python 中，空列表、空元组、空字典、空集合等空容器在布尔上下文中被视为 False，非空容器被视为 True。如果在条件判断中没有正确理解这一点，可能会导致逻辑错误。

my_list = []
if my_list:
    print("列表非空")
else:
    print("列表为空")  # 输出此句

数值 0 和布尔值的混淆

数值 0 在布尔上下文中被视为 False，非零数值被视为 True。如果在条件判断中不小心将数值 0 用于错误的逻辑判断，可能会产生意外结果。

num = 0
if num:
    print("数值非零")
else:
    print("数值为零")  # 输出此句

86. 自定义类的 __hash__ 和 __eq__ 一致性问题（进阶）

哈希和相等性不一致的潜在风险

当自定义类同时重写 __hash__ 和 __eq__ 方法时，必须保证相等的对象具有相同的哈希值，否则在将对象用作字典键或集合元素时会出现意外行为。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
 
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
 
    # 错误示例：哈希和相等性不一致
    def __hash__(self):
        return hash(self.x)
 
p1 = Point(1, 2)
p2 = Point(1, 2)
my_set = {p1}
print(p2 in my_set)  # 可能输出 False，因为哈希值计算不合理
 
# 正确示例：保证哈希和相等性一致
class BetterPoint:
    def __init__(self, x, y):
        self.x = x
        self.y = y
 
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
 
    def __hash__(self):
        return hash((self.x, self.y))
 
bp1 = BetterPoint(1, 2)
bp2 = BetterPoint(1, 2)
my_better_set = {bp1}
print(bp2 in my_better_set)  # 输出 True

87. 异步编程中的 asyncio.run() 多次调用问题

运行时错误

在 Python 3.7 及以上版本中，asyncio.run() 用于运行顶级异步函数。同一个线程中不能多次调用 asyncio.run()，否则会引发 RuntimeError。

import asyncio
 
async def main():
    print("异步函数运行")
 
# 错误示例：多次调用 asyncio.run()
# asyncio.run(main())
# asyncio.run(main())
 
# 正确示例：在一个线程中只调用一次
asyncio.run(main())

88. 函数参数默认值的延迟绑定（闭包相关拓展）

循环中创建闭包的问题

在循环中创建闭包时，闭包会捕获循环变量的最终值，而不是创建闭包时的值。这可能导致循环内创建的多个闭包行为不符合预期。

functions = []
for i in range(3):
    def func():
        return i
    functions.append(func)
 
for f in functions:
    print(f())  # 输出 2, 2, 2，而不是 0, 1, 2
 
# 解决方法：使用默认参数绑定当前值
functions = []
for i in range(3):
    def func(j=i):
        return j
    functions.append(func)
 
for f in functions:
    print(f())  # 输出 0, 1, 2

89. 列表切片赋值的边界情况

切片赋值的长度和位置问题

在进行列表切片赋值时，切片的起始和结束位置以及赋值序列的长度可能会导致列表长度的意外变化。如果不注意这些边界情况，可能会得到不符合预期的结果。

my_list = [1, 2, 3, 4, 5]
# 切片赋值，赋值序列长度大于切片长度
my_list[1:3] = [6, 7, 8]
print(my_list)  # 输出 [1, 6, 7, 8, 4, 5]
 
# 切片赋值，赋值序列长度小于切片长度
my_list[1:4] = [9]
print(my_list)  # 输出 [1, 9, 4, 5]

90. 字典的 setdefault() 方法使用误区

误解 setdefault() 的返回值和副作用

setdefault() 方法用于在字典中查找键，如果键不存在，则设置默认值并返回该默认值；如果键存在，则返回键对应的值。如果错误理解该方法的返回值和副作用，可能会导致逻辑错误。

my_dict = {'a': 1}
# 获取键 'b' 的值，如果不存在则设置默认值 2
value = my_dict.setdefault('b', 2)
print(value)  # 输出 2
print(my_dict)  # 输出 {'a': 1, 'b': 2}
 
# 再次获取键 'b' 的值，此时键已存在
value = my_dict.setdefault('b', 3)
print(value)  # 输出 2，而不是 3

91. 动态加载模块时的安全性和路径问题

从不可信路径加载模块

使用 importlib.import_module 等函数动态加载模块时，如果加载路径来自不可信源，可能会导致代码注入攻击。攻击者可以构造恶意模块路径，从而执行任意代码。

import importlib
 
# 错误示例：使用用户输入作为模块路径，存在安全风险
# module_name = input("请输入要加载的模块名: ")
# module = importlib.import_module(module_name)
 
# 正确示例：使用白名单验证模块路径
allowed_modules = ['math', 'os']
module_name = 'math'
if module_name in allowed_modules:
    module = importlib.import_module(module_name)

模块路径搜索顺序混乱

Python 解释器按照特定的顺序搜索模块路径，包括标准库路径、环境变量 PYTHONPATH 指定的路径和当前工作目录等。如果自定义模块路径配置不当，可能会导致找不到模块或加载到错误的模块。

92. 异步编程中的任务取消与资源释放

任务取消时资源未正确释放

在异步编程中，当任务被取消时，如果没有正确处理资源释放，可能会导致资源泄漏。例如，在异步文件操作或网络连接中，任务取消时需要确保文件句柄关闭、网络连接断开。

import asyncio
 
async def async_file_operation():
    file = open('test.txt', 'w')
    try:
        while True:
            await asyncio.sleep(1)
            file.write('Some data\n')
    except asyncio.CancelledError:
        file.close()  # 确保在任务取消时关闭文件
        raise
 
async def main():
    task = asyncio.create_task(async_file_operation())
    await asyncio.sleep(3)
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print('任务已取消')
 
asyncio.run(main())

取消信号处理不当

在复杂的异步程序中，任务可能会依赖其他任务的执行结果。如果在任务取消时没有正确处理这些依赖关系，可能会导致程序状态不一致。

93. 正则表达式中的回溯失控

复杂正则表达式导致性能问题

当编写复杂的正则表达式时，特别是包含大量重复和嵌套结构的表达式，可能会出现回溯失控的情况。回溯是正则表达式引擎在匹配过程中尝试不同匹配路径的机制，但过多的回溯会导致性能急剧下降，甚至使程序长时间运行或崩溃。

import re
 
# 错误示例：复杂正则表达式可能导致回溯失控
pattern = r'(a+)+b'
text = 'a' * 10000 + 'b'
try:
    re.match(pattern, text)
except RecursionError:
    print('正则表达式匹配出现回溯失控问题')
 
# 正确示例：优化正则表达式以避免回溯失控

94. 上下文管理器嵌套的资源管理问题

嵌套上下文管理器资源释放顺序错误

当使用多个嵌套的上下文管理器时，如果资源释放顺序不正确，可能会导致资源泄漏或程序异常。例如，在嵌套的文件操作或数据库连接中，需要确保内部资源先释放，再释放外部资源。

class OuterResource:
    def __enter__(self):
        print('进入外部资源')
        return self
 
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('退出外部资源')
 
class InnerResource:
    def __enter__(self):
        print('进入内部资源')
        return self
 
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('退出内部资源')
 
# 正确的嵌套顺序
with OuterResource():
    with InnerResource():
        pass

95. 类属性和实例属性的继承与覆盖问题

类属性在继承中的意外覆盖

在类继承过程中，子类可能会意外覆盖父类的类属性。如果没有正确理解类属性和实例属性的区别，可能会导致程序行为不符合预期。

class Parent:
    class_attr = 'parent value'
 
class Child(Parent):
    class_attr = 'child value'
 
parent_obj = Parent()
child_obj = Child()
 
print(parent_obj.class_attr)  # 输出 'parent value'
print(child_obj.class_attr)  # 输出 'child value'

实例属性覆盖类属性的混淆

实例属性可以覆盖类属性，但在访问属性时需要明确区分是访问类属性还是实例属性。如果混淆了两者，可能会得到错误的结果。

96. 多进程中的数据序列化和反序列化问题

不可序列化对象传递错误

在多进程编程中，进程之间传递数据需要进行序列化和反序列化。如果传递的对象不可序列化（如包含自定义的函数、类实例等），会导致 PicklingError。

import multiprocessing
 
def my_function():
    pass
 
class MyClass:
    def __init__(self):
        self.func = my_function
 
# 错误示例：传递不可序列化的对象
# obj = MyClass()
# queue = multiprocessing.Queue()
# queue.put(obj)
 
# 正确示例：只传递可序列化的数据
data = {'key': 'value'}
queue = multiprocessing.Queue()
queue.put(data)

序列化格式不兼容

不同的序列化模块（如 pickle 和 json）有不同的序列化格式和适用范围。如果在多进程通信中使用不兼容的序列化格式，可能会导致数据丢失或解析错误。

97. 字符串拼接方式的性能差异

大量字符串拼接使用 + 操作符

在 Python 中，使用 + 操作符进行大量字符串拼接会导致性能问题，因为每次拼接都会创建一个新的字符串对象，效率较低。推荐使用 join() 方法进行字符串拼接。

# 错误示例：使用 + 操作符进行大量字符串拼接
strings = ['a', 'b', 'c', 'd']
result = ''
for s in strings:
    result = result + s
 
# 正确示例：使用 join() 方法
result = ''.join(strings)

98. 函数参数的默认值是可变对象时的循环引用问题

循环引用导致的内存泄漏风险

当函数参数的默认值是可变对象（如列表、字典），并且在函数内部对该对象进行修改时，可能会导致多个函数调用共享同一个可变对象，甚至出现循环引用，从而增加内存泄漏的风险。

def add_to_list(item, my_list=[]):
    my_list.append(item)
    return my_list
 
list1 = add_to_list(1)
list2 = add_to_list(2)
print(list1)  # 输出 [1, 2]，不是预期的 [1]
print(list2)  # 输出 [1, 2]
 
# 正确示例：使用 None 作为默认值
def better_add_to_list(item, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(item)
    return my_list

99. 异步编程中的事件循环嵌套问题

嵌套事件循环导致的冲突

在异步编程中，通常不建议嵌套使用事件循环。如果不小心嵌套了事件循环，可能会导致事件循环的调度混乱，出现任务无法正常执行或程序崩溃的问题。

import asyncio
 
# 错误示例：嵌套事件循环
# async def inner_loop():
#     loop = asyncio.get_event_loop()
#     async def inner_task():
#         print('Inner task')
#     loop.run_until_complete(inner_task())
 
# async def outer_loop():
#     loop = asyncio.get_event_loop()
#     async def outer_task():
#         await inner_loop()
#     loop.run_until_complete(outer_task())
 
# asyncio.run(outer_loop())
 
# 正确示例：避免嵌套事件循环，使用协程组合
async def inner_task():
    print('Inner task')
 
async def outer_task():
    await inner_task()
 
asyncio.run(outer_task())

100. 自定义异常类的继承和捕获层次问题

异常捕获层次混乱

在自定义异常类时，如果继承关系设计不合理，或者在捕获异常时没有按照正确的层次进行捕获，可能会导致异常处理逻辑混乱，无法准确捕获和处理不同类型的异常。

class MyBaseException(Exception):
    pass
 
class MySpecificException(MyBaseException):
    pass
 
try:
    raise MySpecificException('Specific error')
except MyBaseException as e:
    print(f'捕获到基类异常: {e}')  # 会捕获到具体异常，但可能丢失具体信息
except MySpecificException as e:
    print(f'捕获到具体异常: {e}')  # 应该先捕获具体异常
 
# 正确的捕获顺序
try:
    raise MySpecificException('Specific error')
except MySpecificException as e:
    print(f'捕获到具体异常: {e}')
except MyBaseException as e:
    print(f'捕获到基类异常: {e}')

总结：文章围绕 100 个 Python 常用易错知识点展开全面且细致的总结。从基础的变量与数据类型、函数与方法、类与继承，到较为复杂的控制流与循环、模块与包、异常处理，再到正则表达式、并发编程以及其他综合方面，都进行了深入探讨。每个知识点均给出具体的错误示例，搭配详细的错误分析和对应的正确代码，让读者能够直观地认识到错误所在，并学会如何正确处理。通过系统学习这些内容，读者可以全面提升对 Python 语言的理解和运用能力，有效减少编程过程中的错误，编写出更加稳定、高效、可维护的 Python 代码。

posted on   TekinTian  阅读(3)  评论(0)  编辑  收藏  举报
相关博文：
· Python 术语大揭秘：从基础到进阶的核心概念解析
· Python 术语大揭秘：从基础到进阶的核心概念解析
· python面试题总结
· Python基础问题
· the fourth week
阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 记一次.NET内存居高不下排查解决与启示
点击右上角即可分享
微信分享提示