Quatre erreurs courantes à éviter lors de l'apprentissage de Python-Tutoriel Python-php.cn

作为初学者应避免的四个常见 Python 错误

Python est un excellent langage pour les débutants, mais cela ne veut pas dire que vous ne pouvez pas faire d'erreurs. Surtout au début de l’apprentissage de la programmation, il est facile d’écrire du code techniquement correct mais stylistiquement médiocre.

Si vous voulez apprendre à coder, il est crucial de bien l'apprendre. Que ce soit dans le milieu universitaire ou industriel, la qualité du code est importante. Cela n’affecte pas seulement vous, mais tous ceux qui continueront à lire et à utiliser votre code. Peut-être de manière plus égoïste, cela peut également avoir un impact sur vos perspectives de recrutement.

Dans cet article, je discuterai de quatre erreurs courantes commises par les programmeurs d'introduction à Python. Apprendre ces pièges m'a été très utile à mes débuts avec Python, et j'espère que cela vous sera également utile.

Commençons.

Instructions conditionnelles booléennes

C'est une erreur courante que commettent les programmeurs débutants. C'est également une erreur commise par les programmeurs moins novices qui n'ont pas de formation formelle en programmation car ils utilisent simplement le code comme un outil. Je vous regarde, data scientists.

Les instructions conditionnelles en Python sont utiles, mais pas toujours nécessaires. Cela est particulièrement vrai lorsque la condition que vous vérifiez contient déjà une valeur booléenne (vrai ou faux).

Permettez-moi d'illustrer avec un exemple simple. Supposons que nous souhaitions écrire du code pour déterminer si un ensemble de données a été nettoyé. Heureusement pour nous, la base de code inclut une variable pratique appelée is_data_clean qui en assure le suivi. Tout ce que nous avons à faire est de le vérifier et de renvoyer la valeur correcte.

Pour un premier essai, nous pourrions écrire quelque chose comme ceci :

def a_function():
if is_data_clean == True:
return True
else:
return False

Copier après la connexion

Cela fonctionne déjà, mais il n'est pas nécessaire que ce soit si compliqué. Voyez-vous le problème ? Regardez attentivement.

La variable is_data_clean est déjà un booléen ; elle contient donc déjà la valeur que vous devez renvoyer ! Le code vérifie s'il est vrai et renvoie vrai, s'il n'est pas vrai (c'est-à-dire que c'est faux), alors le code renvoie faux. C'est juste un tas de contrôles inutiles.

Nous pouvons simplifier le code de la fonction en une seule ligne :

def a_function():
return is_data_clean

Copier après la connexion

Beaucoup mieux.

Sommes manuelles, moyennes ou autres opérations intégrées

Python a plus de fonctionnalités intégrées que la plupart des gens ne le pensent. Trop de gens utilisent encore des boucles pour calculer manuellement des sommes.

Si nous avons une liste de nombres en Python, nous ne devrions certainement pas calculer la somme comme ceci :

total = 0
for num in numbers_list:
total += num

Copier après la connexion

Veuillez utiliser la fonction de somme intégrée à la place :

total

Copier après la connexion

Besoin d'un minimum ou d'un maximum ? Il n'y a aucune interdiction dans l'univers d'écrire du code comme celui-ci :

import math
minimum = math.inf # 从最高可能值开始
for number in numbers_list:
if number < minimum:
minimum = number

Copier après la connexion

Ce n'est pas un cours d'introduction aux principes de l'informatique, c'est le monde réel. Arrêtez de réinventer la roue et utilisez les fonctions min et max intégrées :

minimum = min(numbers_list)
maximum

Copier après la connexion

Pour une liste complète des fonctions intégrées, consultez la documentation Python

Bonus : fonctions intégrées qui ne sont pas techniquement intégrées.

Certaines fonctionnalités sont difficiles à trouver, mais cela ne veut pas dire que vous ne devriez pas les trouver.

Par exemple, si nous avions besoin de la moyenne d'une colonne de nombres (vous pourriez penser que c'est un thème récurrent), nous pourrions utiliser le premier extrait de code ci-dessous, mais nous devrions utiliser le second :

# 片段 1：不要这样做！
total = 0
for num in numbers_list:
total += num
avg = total / len(numbers_list)

# 片段 2：这样做！
import numpy as np
avg = np.mean(numbers_list)

Copier après la connexion

Habituellement, Python fournit des fonctions utiles dans les modules. Localiser les modules dont nous avons besoin et importer les fonctions peut nécessiter un travail supplémentaire, mais cela en vaut la peine.

N'oubliez pas : Python est avant tout une question de simplicité et de lisibilité. Les fonctions intégrées sont vos amies. Contrairement à vos amis humains, ils ne déçoivent jamais.

不做无意义的事情

在我教授的一门 Python 入门课程中，学生的第一个项目是编写一个简单的决策算法。这主要是一个条件练习，要求学生定义一个问题和相关的评分系统，以确定某人有资格回答这个问题的可能性。

例如，有人可能会问，“我应该成为一名数据科学家吗？” 然后，该算法可能包含以下问题，所有这些问题都会根据答案从最终输出分数中增加或减少：

我是否有兴趣使用数据来深入了解世界？
我愿意学习 Python 吗？
我喜欢与多学科团队合作吗？

等等。

在编写算法的过程中，许多学生意识到在某些情况下，他们根本不想对总分做任何事情。例如，他们可能会决定，如果有人愿意学习 Python，那么他们的总分会增加 10 分，但如果他们不愿意，则分数保持不变。

大多数学生使用以下代码实现它：

# willing_to_lean 是一些基于用户输入的预定义变量
if willing_to_learn:
score += 10
else:
score += 0

Copier après la connexion

这是什么都不做的经典案例。让我们分解一下 Python 在看到代码行 score += 0 时必须执行的所有操作：

它需要查找变量 score 的值。
它需要将 0 添加到该值。这需要调用加法函数，传入两个参数（当前值和 0），并计算输出。
将 score 变量重新分配给新值（显然是相同的）。

所有这些代码什么都不做。

当然，这对计算机来说不是很大的工作量，也不会对代码的效率产生任何有意义的影响。也就是说，它毫无意义，而且有些不干净，这是优秀 Python 代码所不具备的特征。

更好的解决方案是使用 Python 的 pass 关键字，它实际上告诉 Python 什么都不做，继续前进。它填充了一行不需要的代码，但如果完全留空就会出错。我们甚至可以添加一点评论以提供进一步的清晰度：

if willing_to_learn:
score += 10
else:
pass # 保持分数不变

Copier après la connexion

更干净、更清晰、更 Pythonic。

单一的条件变得疯狂

条件语句可以说是标准编程中最强大和一致的结构之一。第一次学习它时，很容易忽略一个重要的微妙之处。

当我们要检查两个或多个条件时，就会出现这种情况。例如，假设我们正在审查一项调查，以获取以下三种形式之一的回答：“Yes”、“No”或“Maybe”。

早期的 Python 程序员通常使用以下两种方式之一对此进行编码：

# 可能 1
if response == "Yes":
# do something
if response == "No":
# do something
if response == "Maybe":
# do something

# 可能 2
if response == "Yes":
# do something
elif response == "No":
# do something
else:
# do something

Copier après la connexion

在这种情况下，这两个代码片段实际上是相同的。它们的行为方式相同，理解起来并不特别混乱，并且它们实现了预期的目标。当人们错误地认为上面的两个结构总是等价时，问题就出现了。

这是错误的。上面的第二个代码片段是由多个部分组成的单个条件表达式，而第一个代码片段由三个独立的条件表达式组成，尽管它们看起来是相互关联的。

为什么这很重要？因为每当 Python 看到一个全新的 if 关键字（即一个新的条件表达式开始）时，它就会检查关联的条件。另一方面，如果当前条件表达式中的先前条件不满足，Python 只会输入 elif 或 else 条件。

让我们看一个例子，看看为什么这很重要。假设我们需要编写代码，根据学生在某项作业中的分数给他们打分。我们在Python 文件中写入以下代码：

score = 76

print("SNIPPET 1")
print()

if score < 100:
print('A')
elif score < 90:
print('B')
elif score < 80:
print('C')
elif score < 70:
print('D')
else:
print('F')

print()
print("SNIPPET 2")
print()

if score < 100:
print('A')
if score < 90:
print('B')
if score < 80:
print('C')
if score < 70:
print('D')
if score < 60:
print('F')

Copier après la connexion

运行此代码输出以下内容：