Python编程陷阱(四)

K_n_i_g_h_t_1990

已于 2023-11-16 18:19:17 修改

阅读量98

点赞数

分类专栏： Python编程的陷阱文章标签： python 开发语言

于 2023-11-16 15:59:03 首次发布

本文链接：https://blog.csdn.net/fasdfasfwerwqf/article/details/134443868

版权

Python编程的陷阱专栏收录该内容

12 篇文章 0 订阅

订阅专栏

本文讲述了在Python编程中五个常见的陷阱：避免使用del语句删除列表元素以防止索引混乱，正确创建二维列表避免引用共享，谨慎使用frommoduleimport*以提高代码可读性，避免str函数处理字节串导致乱码，以及理解列表相等运算符的真正含义。

摘要由CSDN通过智能技术生成

陷阱11：不要使用`del`语句来删除列表中的元素

列表是Python中最常用的数据结构之一，它可以存储任意类型的元素，并且可以动态地增加或删除元素。
有时候，我们需要删除列表中的某些元素，比如根据索引或条件来删除。
但是，如果我们使用del语句来删除列表中的元素，就可能导致一些意想不到的结果，甚至引发错误。

错误的代码

# 定义一个函数，用于删除列表中的奇数元素
def delete_odd(lst):
    for i in range(len(lst)): # 遍历列表的索引
        if lst[i] % 2 != 0: # 如果元素是奇数
            del lst[i] # 使用del语句来删除元素
    return lst # 返回修改后的列表

# 调用函数，期望得到 [2, 4, 6]
print(delete_odd([1, 2, 3, 4, 5, 6])) # [2, 4, 6]

# 调用函数，期望得到 [4, 8]
print(delete_odd([3, 4, 5, 7, 8])) # [4, 7, 8]

为什么会出错呢？

因为使用del语句来删除列表中的元素，会改变列表的长度和索引，但是我们的循环并没有跟着改变，这就会导致一些元素被跳过或重复访问。
例如，当我们删除了3这个元素后，列表变成了 [4, 5, 7, 8]，但是我们的循环还是指向第二个位置，也就是5，所以它就跳过了4这个元素，导致没有被删除。

正确的代码

# 定义一个函数，用于删除列表中的奇数元素
def delete_odd(lst):
    new_lst = [] # 定义一个新的列表
    for x in lst: # 遍历列表的元素
        if x % 2 == 0: # 如果元素是偶数
            new_lst.append(x) # 将元素添加到新的列表中
    return new_lst # 返回新的列表

# 调用函数，期望得到 [2, 4, 6]
print(delete_odd([1, 2, 3, 4, 5, 6])) # [2, 4, 6]

# 调用函数，期望得到 [4, 8]
print(delete_odd([3, 4, 5, 7, 8])) # [4, 8]

陷阱12：不要使用`*`运算符来创建二维列表

列表是Python中最常用的数据结构之一，它可以存储任意类型的元素，并且可以动态地增加或删除元素。
有时候，我们需要创建一个二维列表，也就是一个列表的列表，比如用来表示一个矩阵或一个棋盘。
但是，如果我们使用*运算符来创建二维列表，就可能导致一些意想不到的结果，甚至引发错误。

错误的代码

# 定义一个函数，用于创建一个n*n的二维列表，初始值都为0
def create_matrix(n):
    return [[0] * n] * n # 使用*运算符来创建二维列表

# 调用函数，期望得到 [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
matrix = create_matrix(3)
print(matrix) # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

# 尝试修改矩阵中的一个元素，期望得到 [[0, 0, 0], [0, 1, 0], [0, 0, 0]]
matrix[1][1] = 1
print(matrix) # [[0, 1, 0], [0, 1, 0], [0, 1, 0]]

为什么会出错呢？

因为使用*运算符来创建二维列表，会导致列表中的每一行都是同一个列表对象的引用，而不是独立的列表对象，这就意味着，如果我们修改了列表中的任何一个元素，都会影响到其他的行，因为它们都指向同一个列表对象。
这就导致了我们无法正确地操作二维列表，比如修改、增加或删除元素，而是会得到一些错误的结果。

正确的代码

# 定义一个函数，用于创建一个n*n的二维列表，初始值都为0
def create_matrix(n):
    return [[0] * n for _ in range(n)] # 使用列表推导式来创建二维列表

# 调用函数，期望得到 [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
matrix = create_matrix(3)
print(matrix) # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

# 尝试修改矩阵中的一个元素，期望得到 [[0, 0, 0], [0, 1, 0], [0, 0, 0]]
matrix[1][1] = 1
print(matrix) # [[0, 0, 0], [0, 1, 0], [0, 0, 0]]

陷阱13：不要使用`from module import *`语句来导入模块

模块是Python中的一种组织代码的方式，它可以让我们将一些相关的函数、变量、类等封装在一个文件中，方便重复使用和管理。
有时候，我们需要使用其他模块中的一些功能，比如使用math模块中的一些数学函数，就需要使用import语句来导入模块，然后使用模块名.函数名的方式来调用函数。
但是，如果我们使用from module import *语句来导入模块，就可能导致一些可读性和可维护性的问题，甚至引发错误。

错误的代码

# 使用from module import *语句来导入math模块
from math import *

# 定义一个函数，用于计算一个数的平方
def square(x):
    return x * x

# 调用函数，期望得到 4
print(square(2)) # 4

# 调用函数，期望得到 9
print(square(3)) # 9

# 调用函数，期望得到 16
print(square(4)) # 16

# 调用函数，期望得到 25
print(square(5)) # 25

# 调用函数，期望得到 36
print(square(6)) # 36

# 调用函数，期望得到 49
print(square(7)) # 49

# 调用函数，期望得到 64
print(square(8)) # 64

# 调用函数，期望得到 81
print(square(9)) # 81

# 调用函数，期望得到 100
print(square(10)) # 100

为什么会出错呢？

因为使用from module import *语句来导入模块，会将模块中的所有变量和函数都导入到当前的命名空间中，这就可能导致一些问题，比如：
- 我们无法清楚地知道我们使用的变量或函数是来自哪个模块的，这就会降低代码的可读性和可理解性。
- 我们可能会不小心覆盖了一些已经存在的变量或函数，或者被其他模块覆盖了一些变量或函数，这就会影响代码的正确性和可靠性。
- 我们可能会导入了一些不需要的变量或函数，这就会浪费内存空间和加载时间，降低代码的效率和性能。
例如，上面的代码中，如果我们导入了math模块，就会覆盖了我们自己定义的square函数，因为math模块中也有一个同名的函数，它的功能是计算一个数的平方根，而不是平方，这就会导致我们的函数无法正常工作，返回错误的结果。

正确的代码

# 使用import语句来导入math模块，然后使用模块名.函数名的方式来调用函数
import math

# 定义一个函数，用于计算一个数的平方
def square(x):
    return x * x

# 调用函数，期望得到 4
print(square(2)) # 4

# 调用函数，期望得到 9
print(square(3)) # 9

# 调用函数，期望得到 16
print(square(4)) # 16

# 调用函数，期望得到 25
print(square(5)) # 25

# 调用函数，期望得到 36
print(square(6)) # 36

# 调用函数，期望得到 49
print(square(7)) # 49

# 调用函数，期望得到 64
print(square(8)) # 64

# 调用函数，期望得到 81
print(square(9)) # 81

# 调用函数，期望得到 100
print(square(10)) # 100

# 调用math模块中的square函数，期望得到 1.414213
print(math.square(2)) # 1.4142135623730951

陷阱14：不要使用`str`函数来转换字节串

字节串是Python中的一种数据类型，它可以表示二进制的数据，比如图片、音频、网络传输等，它的字面值用b前缀来表示，比如b"Hello"。
有时候，我们需要将字节串转换成字符串，比如用来显示或打印，就需要使用decode方法来解码字节串，指定一个编码方式，比如utf-8。
但是，如果我们使用str函数来转换字节串，就可能导致一些意想不到的结果，甚至引发错误。

错误的代码

# 定义一个字节串，表示一个中文的问候语
greeting = b"\xe4\xbd\xa0\xe5\xa5\xbd"

# 使用str函数来转换字节串，期望得到 "你好"
print(str(greeting)) # b'\xe4\xbd\xa0\xe5\xa5\xbd'

为什么会出错呢？

因为使用str函数来转换字节串，会返回一个字符串，但是这个字符串并不是字节串的内容，而是字节串的字面值，也就是用b前缀和转义字符来表示的二进制数据。
这就导致了我们无法正确地显示或打印字节串的内容，而是得到一些乱码或无意义的字符。

正确的代码

# 定义一个字节串，表示一个中文的问候语
greeting = b"\xe4\xbd\xa0\xe5\xa5\xbd"

# 使用decode方法来转换字节串，指定一个编码方式，期望得到 "你好"
print(greeting.decode("utf-8")) # 你好

陷阱15：不要使用`==`运算符来比较列表

列表是Python中最常用的数据结构之一，它可以存储任意类型的元素，并且可以动态地增加或删除元素。
有时候，我们需要比较两个列表是否相等，比如判断两个列表是否有相同的元素和顺序。
但是，如果我们使用==运算符来比较列表，就可能导致一些意想不到的结果，甚至引发错误。

错误的代码

# 定义两个列表，它们的元素都是1到10的数字
lst1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst2 = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# 使用==运算符来比较列表，期望得到 False
print(lst1 == lst2) # False

# 定义两个列表，它们的元素都是1到10的数字，但是顺序不同
lst3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst4 = [1, 3, 2, 4, 5, 7, 6, 8, 9, 10]

# 使用==运算符来比较列表，期望得到 False
print(lst3 == lst4) # False

# 定义两个列表，它们的元素都是1到10的数字，但是有重复
lst5 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst6 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10]

# 使用==运算符来比较列表，期望得到 False
print(lst5 == lst6) # False

为什么会出错呢？

因为使用==运算符来比较列表，会要求两个列表完全相等，也就是元素的个数、类型、值和顺序都相同，这在很多情况下是不合理的，比如：
- 如果我们只关心两个列表是否有相同的元素，而不关心它们的顺序，那么使用==运算符就会得到错误的结果，因为它会要求两个列表的元素顺序也相同。
- 如果我们只关心两个列表是否有相同的元素，而不关心它们的重复，那么使用==运算符就会得到错误的结果，因为它会要求两个列表的元素个数也相同。

正确的代码

# 定义两个列表，它们的元素都是1到10的数字
lst1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst2 = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# 使用set函数来将列表转换成集合，然后使用==运算符来比较集合，期望得到 True
print(set(lst1) == set(lst2)) # True

# 定义两个列表，它们的元素都是1到10的数字，但是顺序不同
lst3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst4 = [1, 3, 2, 4, 5, 7, 6, 8, 9, 10]

# 使用set函数来将列表转换成集合，然后使用==运算符来比较集合，期望得到 True
print(set(lst3) == set(lst4)) # True

# 定义两个列表，它们的元素都是1到10的数字，但是有重复
lst5 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst6 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10]

# 使用set函数来将列表转换成集合，然后使用==运算符来比较集合，期望得到 True
print(set(lst5) == set(lst6)) # True