Python老手也会犯的20个新手级错误

约定不等于承诺〃 2023-09-29 17:37 8阅读 0赞

> *Python编码时应避免的常见错误*

![fd5a9b4dd5294d57b6ae162212e56ce9.png][]

*编程（不仅Python，也包括其它编程语言）最好的一点是，有多种方法来实现同一解决方案。*

![使用不同的方法来达到相同的结果（图像由作者绘制）][458b7f3aa26b42338f6ac813baacc1fd.png]

*使用不同的方法来达到相同的结果（图像由作者绘制）*

由于下述原因，有些方法会比其他方法更好：

1.  消耗更少的内存
2.  运行效率
3.  较少的代码
4.  更容易理解
5.  逻辑简单

在这篇文章中，我将向你介绍20种场景，这些场景都会让开发者不知不觉的陷入臃肿，丑陋，复杂的Python编码陷阱中，从而限制发挥Python的潜力。

除此之外，我还会针对每个错误提供一个替代方案进行解决。

[点击这里查看本文的代码][Link 1]

开始吧！

### **1 多次使用打印语句** ###

**新手写法**

如果你想打印多个变量，简单的方式是为每个变量都使用 print 语句。

a, b, c = 10, 5, 3  
    
    print(a)  
    
    print(b)  
    
    print(c)

**优雅的写法**

根据经验，使用多个 print 语句通常是编程人员（特别是新手）在 Python 中编码时最常犯的错误，因为他们不知道使用 print 语句，可以在一行代码中打印多个变量，代码如下：

a, b, c = 10, 5, 3  
    
    print(a, b, c, sep = "\n")

上述 **sep** 参数用于指定 **print** 语句输出各个变量值（a，b，c）之间的分隔符。

注意：**end** 参数用于设置 **print** 语句输出内容的结尾字符。

a, b, c = 10, 5, 3  
    
    
    
    print(a, end = "\n---\n")  
    
    print(b, end = "\n---\n")  
    
    print(c)

上述代码中，参数 **end=”\\n---\\n”** 用于当输出一行后，输出 **---**，然后在输出新一行字符。

### **2 使用FOR 循环打印相同的变量** ###

**新手写法**

如题所示，你的目标是多次打印相同的变量，所以你会创建一个 FOR 循环并迭代预期打印次数，对吗？我的意思是，这有什么问题吗？

repeat = 10  
    
    a = "ABC"  
    
    for _ in range(repeat):  
    
    print(a, end = "")

**优雅的写法**

虽然编写一个FOR循环没有坏处，并且一切正常，但是没有必要编写一个 FOR 循环来多次打印同一变量。

repeat = 10  
    
    a = "ABC"  
    
    print(a*repeat)

### **3-4 创建独立变量来跟踪循环中的索引** ###

**新手的写法1**

为实现这一目标，一般需要定义一个新变量（**idx**）跟踪索引值，并在迭代时对它递增，代码如下：

idx = 0  
    
    char_list = ["a", "b", "c", "d", "e", "f"]  
    
    for i in char_list:  
    
    print("index =", idx, "value =", i, sep = " ")  
    
    idx += 1

**新手的写法2**

如果不使用上述方法，人们还会创建一个 **range** 迭代器来跟踪索引，代码如下：

char_list = ["a", "b", "c", "d", "e", "f"]  
    
    for idx in range(len(char_list)):  
    
    print("index =", idx, "value =", char_list[idx], sep = " ")  
    
    idx += 1

**优雅的写法**

感谢设计了 **enumerate()** 函数的开发人员，使用这种方法可以按照下述方式跟踪索引（idx）和值（i）。

char_list = ["a", "b", "c", "d", "e", "f"]  
    
    for idx, i in enumerate(char_list):  
    
    print("index =", idx, "value =", i, sep = " ")

### **5 使用FOR循环将列表转换为字符串** ###

![bc2ea86390ff4f47b6755f0295835c71.png][]

*字符串的列表(图像由作者绘制)*

**新手写法**

如下所示，使用 FOR 循环每次收集一个元素

char_list = ["A", "B", "C", "D", "E"]  
    
    final_str = ""  
    
    for i in char_list:  
    
    final_str += i  
    
    print(final_str)

**优雅的写法**

将列表转换为字符串的优雅方法是使用 **join()** 方法，如下所示:

char_list = ["A", "B", "C", "D", "E"]  
    
    final_str = "".join(char_list)  
    
    
    
    print(final_str)

上述代码不仅可以避免编写一些不必要的长代码，而且与 FOR 循环方法一样直观。

### **6 使用 FOR 循环从列表中删除重复项** ###

**新手写法**

![dbc3c47c7a394ba4ada1a142842bb212.png][]

*从列表中删除重复项**(图像由作者绘制)*

再次使用 FOR 循环，通过迭代列表并在新列表中存储唯一的元素来实现。

char_list = ["A", "B", "A", "D", "C", "B", "E"]  
    
    final_list = []  
    
    for i in char_list:  
    
        if i not in final_list:  
    
           final_list.append(i)  
    
    print(final_list)

**优雅的写法**

只需要一行 Python 代码就可以从列表中删除重复内容，如下所示：

char_list = ["A", "B", "A", "D", "C", "B", "E"]  
    
    set(list(char_list))

上面的代码返回一个集合，你可以将其转换为列表：

char_list = ["A", "B", "A", "D", "C", "B", "E"]  
    
    list(set(list(char_list)))

### **7 使用 FOR 循环在列表中检索元素** ###

**新手写法**

如果你想知道某个元素是否存在于列表（或集合）中，并返回一个布尔值(如果存在则为 True，否则为 False)，新手实现如下所示：

char_list = ["A", "B", "A", "D", "C", "B", "E"]  
    
    search_char = "D"  
    
    found = False  
    
    for i in char_list:  
    
        if i == search_char:  
    
            found = True  
    
            break  
    
    print(found)

代码有点多，是吧？

**优雅的写法**

通过关键字**in** 可以使用一行代码实现。

char_list = ["A", "B", "A", "D", "C", "B", "E"]  
    
    search_char = "D"  
    
    search_char in char_list

### **8 使用一个迭代变量在两个相同大小的迭代对象上进行迭代** ###

**新手写法**

该形式与第3-4节中所做相同，也就是为索引定义一个特定变量，这种实现比较简单，如下所示：

list1 = [1, 3, 6, 2, 5]  
    
    list2 = [0, 4, 1, 9, 7]  
    
    for idx in range(len(list1)):  
    
        print("value1 =", list1[idx], "value2 =", list2[idx], sep = " ")

**优雅的写法**

有经验的方法是使用 **zip()** 函数，该函数可以在两个可迭代对象将对应位置的值进行匹配。

list1 = [1, 3, 6, 2, 5]  
    
    list2 = [0, 4, 1, 9, 7]  
    
    for i, j in zip(list1, list2):  
    
        print("value1 =", i, "value2 =", j, sep = " ")

### **9使用 FOR 循环反转列表** ###

![e40d409f16844464ad48d9768d9a84bd.png][]

*逆向列表**(图像由作者绘制)*

**新手写法**

正如前文所示，我们可以在列表上进行反向迭代并将元素附加到新列表中，代码如下：

input_list  = [1, 2, 3, 4, 5]  
    
    output_list = []  
    
    
    for idx in range(len(input_list), 0, -1):  
    
        output_list.append(input_list[idx-1])  
    
    
    print(output_list)

**优雅的写法**

如果你了解 Python 中的切片，那优秀的解决方案只需要一行代码。

input_list  = [1, 2, 3, 4, 5]  
    
    output_list = input_list[::-1]  
    
    print(output_list)

不需要 FOR 循环！

### **10使用 FOR 循环检查回文结构** ###

**新手写法**

在扩展了上述情况（\#9--反转列表）的思路之后，我们可以检查回文列表结构。

input_list  = [1, 2, 3, 2, 1]  
    
    output_list = []  
    
    for idx in range(len(input_list), 0, -1):  
    
        output_list.append(input_list[idx-1])  
    
    print(output_list == input_list)

**优雅的写法**

正如前文讨论的那样，有经验的方式是使用切片，并将结果与原列表进行比较。

input_list  = [1, 2, 3, 2, 1]  
    
    
    output_list = input_list[::-1]  
    
    print(output_list == input_list)

### **11使用 FOR 循环计算迭代对象中元素的出现次数** ###

**新手写法**

查找元素频率的简单方法是使用 FOR 循环在列表迭代，然后统计元素出现的次数。

char_list = ["A", "B", "A", "D", "C", "B", "E"]  
    
    search_char = "B"  
    
    char_count = 0  
    
    for i in char_list:  
    
        if search_char == i:  
    
            char_count += 1  
    
    print(char_count)

**优雅的写法**

在这种情况下，避免编写 FOR 循环的有经验写法是使用 **count()** 方法。

char_list = ["A", "B", "A", "D", "C", "B", "E"]  
    
    char_list.count("A")

也可以对字符串变量使用 count() 方法。

string = "ABADCBE"  
    
    string.count("A")

### **12使用 FOR 循环获取字符串的子串** ###

**新手写法**

本次目标是从 start\_index 位置开始，返回一个长度为 **n\_chars** 的字符串子串。

新手解决这个问题的方法是使用 FOR 循环，如下所示：

input_str = "ABCDEFGHIJKL"  
    
    start_index = 4  
    
    n_chars = 5  
    
    
    output_str = ""  
    
    for i in range(n_chars):  
    
        output_str += input_str[i+start_index]  
    
    
    print(output_str)

**优雅的写法**

使用切片，可以避免 FOR 循环。

input_str = "ABCDEFGHIJKL"  
    
    start_index = 4  
    
    n_chars = 5  
    
    output_str = input_str[start_index:start_index+n_chars]  
    
    print(output_str)

### **13 定义长整数常量** ###

假设你想声明一个值为1021的整数变量。

**新手写法**

x = 1000000000000000000000

理想情况下，人们会连续写0，并在打字时进行计数，但如果有人想引用这个代码，他们数0难道不会很麻烦吗？

**优雅的写法**

为了提高可读性，可以用 \_（下划线）分隔一组0，如下所示：

x = 1_000_000_000_000_000_000_000

但这仍然是一个麻烦，为什么数 0？

如果数字可以表示为 **a^b** 形式，那应该使用 **pow()** 方法。

x = pow(10, 21)

### **14 用IF变换字符串大小写** ###

给定一个字符串，目标使大写字母变成小写，反之亦然。

**新手写法**

简单的方法是检查每个元素的大小写，然后对每个字符都进行转换。

input_str = "AbCDeFGhIjkl"  
    
    output_str = ""  
    
    for i in input_str:  
    
        if i.islower():  
    
            output_str += i.upper()  
    
        elif i.isupper():  
    
            output_str += i.lower()  
    
        else:  
    
            output_str += i  
    
    print(output_str)

输出没有问题，但为什么要这么做？

**优雅的写法**

使用  **swapcase ()**方法。

input_str = "AbCDeFGhIjkl"  
    
    output_str = input_str.swapcase()  
    
    
    print(output_str)

### **15获取两个集合的并集** ###

![44351cd9bb4148c3b608559eda4604e0.png][]

*合并两个集合**(图像由作者绘制)*

**新手写法**

遍历这两个集合，将元素添加到一个新的集合中。

set_a = {1, 2, 4, 8}  
    
    set_b = {3, 8, 7, 1, 9}  
    
    union_set = set()  
    
    for i in set_a:  
    
        union_set.add(i)  
    
    
    for i in set_b:  
    
        union_set.add(i)  
    
    print(union_set)

代码太多了，不是吗？让我们把它精简到一行。

**优雅的写法**

Python中的集合为两个集合的合并提供了一个**union()** 方法。

set_a = {1, 2, 4, 8}  
    
    set_b = {3, 8, 7, 1, 9}  
    
    union_set = set_a.union(set_b)  
    
    print(union_set)

更重要的是，你可以将其扩展到任意数量的输入集合。

set_a = {1, 2, 4, 8}  
    
    set_b = {3, 8, 7, 1, 9}  
    
    set_c = {5, 9, 10, 3, 2}  
    
    set_d = {7, 2, 13, 15, 0}  
    
    union_set = set_a.union(set_b, set_c, set_d)  
    
    print(union_set)

这很酷吧？ 想象一下，要合并4个集合，需要编写多少个 FOR 循环？

### **16获取两个集合的交集** ###

**新手写法**

与上面讨论的合并情况类似，我们可以寻找两个集合之间的共同元素，如下所示：

set_a = {1, 2, 4, 8}  
    
    set_b = {3, 8, 7, 1, 9}  
    
    intersection_set = set()  
    
    for i in set_a:  
    
        if i in set_b:  
    
            intersection_set.add(i)  
    
    print(intersection_set)

**优雅的写法**

你可以使用 **intersection****()** 方法实现同样的功能：

set_a = {1, 2, 4, 8}  
    
    set_b = {3, 8, 7, 1, 9}  
    
    intersection_set = set_a.intersection(set_b)  
    
    
    print(intersection_set)

### **17在 IF 语句中写多个条件** ###

为了详细说明这一点，假设你想实现如下逻辑。

![fcf97406887d4833b8271864f158aac3.png][]

*函数将输入映射到输出**(图像由作者绘制)*

**新手写法**

可以使用多个 OR 分隔条件实现上述逻辑。

a = 1  
    if a == 1 or a == 2 or a==3:  
        a += 1  
    elif a == 4 or a == 5 or a==6:  
        a += 5  
    else:  
        a *= 2  
    print(a)

**优雅的写法**

避免使用多个条件语句的方法是使用关键字 in，代码如下：

a = 1  
    if a in (1, 2, 3):  
        a += 1  
    elif a in (4, 5, 6):  
        a += 5  
    else:  
        a *= 2  
    print(a)

### **18更改列表中所有元素的数据类型** ###

给定一个表示整数的字符串列表，目标修改数据类型将其转换为整数列表。

**新手写法**

使用 FOR 循环和类型强制转换对单个元素进行变更。

input_list  = ["7", "2", "13", "15", "0"]  
    
    output_list = []  
    
    
    for idx, i in enumerate(input_list):  
    
        output_list.append(int(input_list[idx]))  
    
    print(output_list)

**优雅的写法**

聪明的做法是使用 map() 函数，如下所示：

input_list = ["7", "2", "13", "15", "0"]  
    
    output_list = list(map(int, input_list))  
    
    print(output_list)

**map()** 函数接收的第一个参数是 **function(int)**，第二个参数是可迭代对象（**input\_list**）。

### **19交换变量** ###

给定两个变量，目标是对变量值进行交换。

**新手写法**

大多数C/C++程序员在这里采取的方法是定义一个新的变量（**temp**），他们通常也会在Python中扩展这个方法。

a = "123"  
    b = "abc"  
    
    temp = a  
    a = b  
    b = temp  
    print(a, b)

**优雅的写法**

幸运的是，Python 允许在一个语句中进行多次赋值，从而避免了对临时变量的需求。

a = "123"  
    
    b = "abc"  
    
    a, b = b, a  
    
    print(a, b)

### **20 使用嵌套循环生成两个列表的所有组合** ###

给定两个列表（**a**的长度为**n**，**b** 的长度为 **m**），生成 （**n\*m**）个组合。

**新手写法**

编写两个嵌套的FOR循环，并将所有组合追加到列表中。

list1 = ["A", "B", "C"]  
    
    list2 = [1, 2]  
    
    combinations = []  
    
    for i in list1:  
    
        for j in list2:  
    
            combinations.append([i, j])  
    
    print(combinations)

**优雅的写法**

优雅的写法是使用 **itertools** 库中的 **product()**方法，如下所示：

from itertools import product  
    
    
    list1 = ["A", "B", "C"]  
    
    list2 = [1, 2]  
    
    
    combinations = list(product(list1, list2))  
    
    print(combinations)

### **结论** ###

在这篇文章中，我展示了20种不同场景，我相信大多数Python程序员都经历过这些情况，而且可能也采取了错误的编码解决方案，如果你注意到，在大多数情况下，优雅的写法主要侧重于避免使用 FOR 循环进行编码。

作为这篇文章的重点，你应该永远记住，在大多数情况下，你想出的第一个解决方案并不是最优方案，因此，使用谷歌搜索总是有帮助的：)，这也是为什么不完美主义的思维方式，对一名讲究的程序员非常重要的原因（不仅是Python，其它语言也一样）。

备注：我很快就会发布这篇文章的第二部分！感谢你的阅读。

[fd5a9b4dd5294d57b6ae162212e56ce9.png]: https://img-blog.csdnimg.cn/fd5a9b4dd5294d57b6ae162212e56ce9.png
[458b7f3aa26b42338f6ac813baacc1fd.png]: https://img-blog.csdnimg.cn/458b7f3aa26b42338f6ac813baacc1fd.png
[Link 1]: https://deepnote.com/workspace/avi-chawla-695b-aee6f4ef-2d50-4fb6-9ef2-20ee1022995a/project/Untitled-project-1408343f-c11a-4dbe-a79a-9eabc8db2097/%2Fnotebook.ipynb
[bc2ea86390ff4f47b6755f0295835c71.png]: https://img-blog.csdnimg.cn/bc2ea86390ff4f47b6755f0295835c71.png
[dbc3c47c7a394ba4ada1a142842bb212.png]: https://img-blog.csdnimg.cn/dbc3c47c7a394ba4ada1a142842bb212.png
[e40d409f16844464ad48d9768d9a84bd.png]: https://img-blog.csdnimg.cn/e40d409f16844464ad48d9768d9a84bd.png
[44351cd9bb4148c3b608559eda4604e0.png]: https://img-blog.csdnimg.cn/44351cd9bb4148c3b608559eda4604e0.png
[fcf97406887d4833b8271864f158aac3.png]: https://img-blog.csdnimg.cn/fcf97406887d4833b8271864f158aac3.png