Comment résoudre les erreurs de mauvaise lisibilité du code dans le code Python ?

Le langage Python est généralement considéré comme un outil facile à apprendre et à coder. Bien que le langage Python soit concis et clair, de mauvaises habitudes de codage peuvent entraîner une réduction de la lisibilité du code. De mauvaises habitudes de codage peuvent également affecter la maintenabilité et l’évolutivité de votre code. Dans cet article, nous partagerons quelques astuces pour améliorer la lisibilité du code Python et éviter les mauvaises habitudes dans le code.

1. Convention de dénomination

Les règles de dénomination sont la base de la lisibilité du code Python. Qu'il s'agisse d'une variable, d'une fonction ou d'une classe, le nom doit être descriptif et doit rester simple. Évitez d'utiliser des abréviations inutiles ou des noms avec des abréviations peu claires. Les noms de variables doivent commencer par une lettre minuscule, tandis que les noms de classes doivent commencer par une lettre majuscule. Par exemple, quelques exemples sont répertoriés ci-dessous :

Bon exemple :

class UserProfile:
    def __init__(self, username, email):
        self.username = username
        self.email = email

email = "user@gmail.com"
user_profile = UserProfile("user", email)

Mauvaise démo :

class up:
    def __init__(self, un, e):
        self.username = un
        self.eml = e

e = "user@gmail.com"
up = up("user", e)

Bien que cette dernière fonctionne bien, la lisibilité et la maintenabilité du code est très mauvaise.

2. Commentaires

Les commentaires sont un autre élément clé de la lisibilité. Les commentaires peuvent augmenter la lisibilité du code, en particulier lorsqu'ils expliquent une partie spécifique du code ou expliquent une idée. Cependant, une utilisation excessive des commentaires peut rendre votre code complexe et difficile à lire. Par conséquent, les commentaires inutiles doivent être évités et les parties clés doivent être commentées à la place.

Lors de la mise en place des commentaires, il est préférable d'adopter un format et un style standard. Par exemple, les développeurs Python utilisent souvent des guillemets triples pour créer des docstrings qui font partie des modules, classes et méthodes de la bibliothèque standard. Voici un exemple :

class Rectangle:
    """一个代表矩形的类。

        参数:
        width (int): 矩形的宽度。
        length (int): 矩形的长度。
    """
    def __init__(self, width, length):
        self.width = width
        self.length = length

    def area(self):
        """"计算矩形的面积。"""
        return self.width * self.length

À ce stade, en utilisant la fonction help(), nous pouvons accéder rapidement à la documentation de la classe rectangle :

>>> r = Rectangle(3,4)
>>> help(Rectangle)

Output : #🎜🎜 #

Help on class Rectangle in module __main__:

class Rectangle(builtins.object)
 |  Rectangle(width, length)
 |  
 |  一个代表矩形的类。
 |  
 |  参数:
 |  width (int):矩形的宽度。
 |  length (int):矩形的长度。
 |  
 |  Methods defined here:
 |  
 |  __init__(self, width, length)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  area(self)
 |  计算矩形的面积。
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

# 🎜🎜#

Longueur de la fonction

Les fonctions doivent être courtes. S’il y a trop de lignes de code, la fonction peut devenir difficile à lire et à comprendre. Dans le même temps, les fonctions plus courtes et ciblées sont plus faciles à maintenir et à tester. Du point de vue de la lisibilité, il ne devrait y avoir qu’un seul écran de code. Si le code de fonction dépasse cinquante lignes, vous devriez envisager de le diviser en plusieurs fonctions.

Division des modules

Lors du développement de grands projets, la base de code comprend généralement plusieurs fichiers, il est donc nécessaire de diviser la logique du code en éléments gérables Modules maintenables et extensibles.

Les modules doivent être aussi brefs et ciblés que possible et conçus pour accomplir une tâche spécifique. De plus, ils doivent avoir des interfaces simples pour une meilleure utilisation. Enfin, le nom du module doit correspondre à sa fonctionnalité.

Espaces cités

Dans le code Python, Python nécessite l'ajout de caractères d'espace convenus entre les différentes parties du code pour améliorer la lisibilité. Par exemple, ajoutez un espace après la virgule (,) et les deux points (:) pour faciliter la lecture du code. Dans le même temps, vous devez éviter d’ajouter trop d’espaces dans le code pour éviter un formatage excessif et affecter la lisibilité.

organiser le code

Il est important d'organiser beaucoup votre code pour préserver une bonne structure de code à l'avenir. Dans les applications Python, vous pouvez utiliser des modules et des packages pour organiser le code. Il est nécessaire d’utiliser l’encapsulation de classes et de fonctions.

Les packages peuvent être utilisés pour regrouper des modules et sous-packages associés. Par exemple, dans un package appelé messages, vous pouvez inclure un module appelé sms.py, qui peut contenir des fonctions d'envoi et de réception de messages texte. les messages peuvent également contenir un sous-package appelé email, qui contient d'autres modules associés pour la gestion du courrier électronique.

messages/
    __init__.py
    sms.py
    email/
        __init__.py
        receiving.py
        sending.py

Summary

En Python, la lisibilité du code est très importante. De mauvaises habitudes de programmation peuvent rendre le code difficile à lire et à maintenir. En adoptant de bonnes pratiques de codage, en évitant les commentaires excessifs et les techniques de longueur de code, de division des modules, d'espaces et d'organisation du code, nous pouvons écrire du code Python facilement. Utilisez ces techniques pour créer un code lisible, extensible et maintenable qui jette les bases du développement futur de projets.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!