Lors de l'écriture de code Python, il est essentiel de le rendre propre et facile à lire. Un code propre signifie que votre code est bien organisé, simple à comprendre et facile à maintenir. Dans ce guide, nous partagerons les meilleurs conseils pour vous aider à écrire du code propre en Python, que vous soyez débutant ou développeur expérimenté.
Écrire du code propre est essentiel pour de nombreuses raisons :
L'un des moyens les plus simples d'améliorer la lisibilité du code consiste à utiliser des noms clairs et significatifs pour les variables et les fonctions. Évitez les noms à une seule lettre ou énigmatiques comme x, y ou foo.
Exemple :
# Bad example
def calc(x, y):
return x + y
# Good example
def calculate_total_price(item_price, tax):
return item_price + tax
Dans le deuxième exemple, il est facile de comprendre ce que fait la fonction simplement en regardant le nom de la fonction et les noms des variables.
PEP 8 est le guide de style officiel de Python, fournissant des conventions pour écrire du code propre et lisible. Certaines recommandations clés du PEP 8 incluent :
Exemple :
# PEP 8 Example
def calculate_discounted_price(price, discount):
"""Calculate the final price after applying the discount."""
discounted_amount = price * (discount / 100)
final_price = price - discounted_amount
return final_price
Divisez votre code en fonctions plus petites et gérables. Chaque fonction doit effectuer une tâche spécifique, ce qui facilite la lecture, le test et le débogage.
Exemple :
# Bad example
def process_order(customer, items):
total_price = 0
for item in items:
total_price += item['price']
if total_price > 100:
discount = total_price * 0.1
total_price -= discount
# Send email
print(f"Order confirmed for {customer['name']}")
return total_price
# Good example
def calculate_total_price(items):
return sum(item['price'] for item in items)
def apply_discount(total_price):
if total_price > 100:
return total_price * 0.9
return total_price
def send_confirmation_email(customer):
print(f"Order confirmed for {customer['name']}")
def process_order(customer, items):
total_price = calculate_total_price(items)
total_price = apply_discount(total_price)
send_confirmation_email(customer)
return total_price
Dans l'exemple amélioré, le code est divisé en fonctions plus petites, ce qui le rend plus facile à comprendre et à maintenir.
Les compréhensions de listes en Python fournissent un moyen concis de créer des listes. Leur utilisation peut rendre votre code plus propre et plus lisible.
Exemple :
# Without list comprehension
squares = []
for x in range(10):
squares.append(x ** 2)
# With list comprehension
squares = [x ** 2 for x in range(10)]
Le deuxième exemple est plus court et plus facile à lire.
Évitez de coder en dur les valeurs directement dans votre code. Utilisez plutôt des constantes ou des fichiers de configuration. Cela rend votre code plus flexible et plus facile à mettre à jour.
Exemple :
# Bad example
def calculate_discount(price):
return price * 0.1 # Discount is hardcoded
# Good example
DISCOUNT_RATE = 0.1
def calculate_discount(price):
return price * DISCOUNT_RATE
Dans le deuxième exemple, le taux de remise est stocké dans une constante, ce qui facilite sa modification si nécessaire.
Bien qu'un code propre doive être explicite, l'ajout de commentaires et de docstrings peut aider à expliquer le but de fonctions ou d'algorithmes complexes.
def find_largest_number(numbers):
"""
Find the largest number in a list.
Args:
numbers (list): A list of numbers.
Returns:
int: The largest number.
"""
return max(numbers)
La docstring aide les autres développeurs à comprendre comment utiliser la fonction sans avoir besoin de lire l'intégralité du code.
Évitez de dupliquer le code. Si vous remarquez des modèles répétitifs, essayez de refactoriser votre code pour réutiliser des fonctions ou des classes. Cela rendra votre code plus maintenable et réduira les risques d'erreurs.
Exemple :
# Bad example
def get_full_name1(first_name, last_name):
return first_name + " " + last_name
def get_full_name2(first_name, last_name):
return first_name + " " + last_name
# Good example
def get_full_name(first_name, last_name):
return first_name + " " + last_name
Gérez toujours les exceptions à l'aide des blocs try et except pour éviter que votre programme ne plante. Vous devez également fournir des messages d'erreur informatifs pour faciliter le débogage.
Exemple :
# Bad example
def divide_numbers(a, b):
return a / b
# Good example
def divide_numbers(a, b):
try:
return a / b
except ZeroDivisionError:
return "Error: Cannot divide by zero"
Le deuxième exemple évite un crash et fournit un message d'erreur utile.
Python 3.6 a introduit les f-strings, un moyen simple et lisible de formater des chaînes. Elles sont beaucoup plus propres que les anciennes méthodes de formatage de chaînes.
Exemple :
# Old way
name = "Alice"
greeting = "Hello, %s!" % name
# With f-strings
greeting = f"Hello, {name}!"
Les chaînes F rendent votre code plus facile à lire et à maintenir.
Only import the necessary modules and functions. Avoid wildcard imports like from module import * as they can clutter the namespace and make it harder to track dependencies.
Example:
# Bad example from math import * # Good example from math import sqrt, pi
Writing clean code in Python is a valuable skill that helps you create readable, maintainable, and bug-free software. By following the best practices outlined in this guide—using meaningful names, following PEP 8, keeping your code modular, and handling errors gracefully—you can significantly improve your coding style.
Focus on readability, simplicity, and consistency, and you'll be well on your way to writing clean, professional Python code.
위 내용은 Python에서 깔끔한 코드를 작성하는 방법 - 모범 사례 가이드의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
