Python

PEP 8 - Écrire un code Python beau et lisible

Quête 49 sur 66

Prérequis

Aucun

Objectifs pédagogiques

À la fin de cette leçon, vous serez capable de comprendre :

L'indentation
La longueur des lignes
Les sauts de ligne et les opérateurs
Les espaces blancs

Chaque personne qui code a ses propres styles et habitudes. Mais, si vous travaillez en équipe ou devez partager votre code avec d'autres développeurs, il doit être lisible. C'est une bonne habitude à prendre même lorsqu'on code pour soi-même.

PEP8 (aussi connu sous le nom de PEP-8 ou PEP 8) signifie Python Enhancement Proposals. Les créateurs du langage Python, Guido van Rossum, Barry Warsaw et Nick Coghlan, l'ont conçu comme un guide de style documenté pour aider les développeurs Python à écrire du code lisible. Dans cette leçon, nous allons passer en revue quelques bonnes pratiques majeures.

Les noms de fonctions doivent être en minuscules, avec les mots séparés par des tirets bas si nécessaire pour améliorer la lisibilité. C'est ce qu'on appelle la convention snake_case.

Les noms de variables suivent la même convention que les noms de fonctions. Les noms de classes doivent normalement utiliser la convention CapWords (première lettre de chaque mot en majuscule).

Dans tous les cas, n'utilisez pas de mots protégés — des mots utilisés par le langage lui-même comme list, dict, ou str.

Évitez de nommer vos variables avec des lettres uniques ou des chiffres.

Certaines lettres peuvent prêter à confusion : le "O" peut être confondu avec 0, le "I" majuscule et le "l" minuscule se ressemblent, et les deux peuvent être confondus avec "1". Évitez ces caractères lorsque la différence pourrait ne pas être parfaitement claire pour un autre développeur.

Pour en savoir plus : Prescriptive Naming Conventions

En Python, une indentation incorrecte d'un bloc d'instructions (comme une fonction, une condition ou une boucle) entraînera une erreur. Cependant, au-delà de la simple indentation correcte, il existe plusieurs directives à suivre pour s'assurer que le code indenté est facile à lire, particulièrement pour les fonctions avec plusieurs arguments.

La règle d'or est d'utiliser 4 espaces par niveau d'indentation.

Les lignes de continuation doivent aligner les éléments enveloppés soit verticalement — en utilisant la jointure de ligne implicite de Python à l'intérieur des parenthèses, crochets et accolades — soit en utilisant une indentation suspendue.

L'indentation suspendue est un style de mise en page où toutes les lignes d'un paragraphe sont indentées sauf la première. En Python, ce terme décrit un style où la parenthèse ouvrante d'une instruction est le dernier caractère non-espace de la ligne, avec les lignes suivantes indentées jusqu'à la parenthèse fermante.

Lors de l'utilisation d'une indentation suspendue, gardez ces points à l'esprit : il ne devrait pas y avoir d'arguments sur la première ligne, et l'indentation supplémentaire devrait clairement distinguer les lignes de continuation :

python

# Correct:

# Aligned with opening delimiter
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

# Add 4 spaces (an extra level of indentation) to distinguish arguments from the rest
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

# Hanging indents should add a level
foo = long_function_name(
    var_one, var_two,
    var_three, var_four)

python

# Wrong:

# Arguments on first line forbidden when not using vertical alignment
foo = long_function_name(var_one, var_two,
    var_three, var_four)

# Further indentation required as indentation is not distinguishable
def long_function_name(
    var_one, var_two, var_three,
    var_four):
    print(var_one)

Pour en savoir plus : Indentation

Le retour à la ligne automatique dans la plupart des outils perturbe la structure visuelle du code, le rendant plus difficile à comprendre. Les limites sont choisies pour éviter les retours à la ligne dans les éditeurs dont la largeur de fenêtre est fixée à 80, même si l'outil place un glyphe marqueur dans la dernière colonne lors du retour à la ligne. Certains outils web peuvent ne pas offrir de retour à la ligne dynamique du tout.

C'est pourquoi la limite maximale recommandée est de 79 caractères.

Pour en savoir plus : Maximum Line Length

Pendant des décennies, le style recommandé était de faire un saut de ligne après les opérateurs binaires. Cependant, cela peut nuire à la lisibilité de deux façons : les opérateurs ont tendance à être dispersés sur différentes colonnes à l'écran, et chaque opérateur s'éloigne de son opérande en passant à la ligne précédente. Cela force l'œil à travailler plus dur pour distinguer quels éléments sont ajoutés et lesquels sont soustraits :

python

# Not recommended:
# Operators are separated from their operands
income = (gross_wages +
          taxable_interest +
          (dividends - qualified_dividends) -
          ira_deduction -
          student_loan_interest)

Pour résoudre ce problème de lisibilité, les mathématiciens et leurs éditeurs adoptent la convention opposée. Suivre cette tradition mathématique conduit généralement à un code plus lisible :

python

# Recommended:
# Easy to match operators with operands
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)

Pour en savoir plus : Should a Line Break Before or After a Binary Operator?

Les espaces jouent un rôle crucial pour rendre votre code plus lisible et organisé. Cependant, une utilisation incorrecte des espaces peut rendre votre code encombré et difficile à comprendre. Voici les meilleures pratiques à suivre lors de l'utilisation des espaces en Python :

Évitez les espaces superflus dans les situations suivantes :

Immédiatement à l'intérieur des parenthèses, crochets ou accolades :

Recommandé :

python

result = my_function(arg1, [value1, value2])
data = {'name': 'Alice', 'age': 30}

Non Recommandé :

python

result = my_function( arg1, [ value1, value2 ] )
data = { 'name': 'Alice', 'age': 30 }

Entre une virgule finale et une parenthèse fermante :
- Recommandé :
  python
```
my_list = [1, 2, 3,]
```
- Non Recommandé :
  python
```
my_list = [1, 2, 3, ]
```
Immédiatement avant une virgule, un point-virgule ou un deux-points :
- Recommandé :
  python
```
if x == 5:
    print(x, y)
```
- Non Recommandé :
  python
```
if x == 5 :
    print(x , y)
```

Lors de l'utilisation des tranches, assurez-vous d'avoir un espacement cohérent autour des deux-points :

Recommandé :

python

values = my_list[1:5]
sublist = my_list[1:5:2]
result = data[start : end]

Non Recommandé :

python

values = my_list[1 : 5]
sublist = my_list[1 :5 : 2]
result = data[start: end]

Immédiatement avant la parenthèse ouvrante qui commence la liste d'arguments d'un appel de fonction :
- Recommandé :
  python
```
result = my_function(1, 2)
```
- Non Recommandé :
  python
```
result = my_function (1, 2)
```
Immédiatement avant la parenthèse ouvrante qui commence l'indexation ou le découpage :
- Recommandé :
  python
```
value = my_list[2]
sublist = my_list[1:3]
```
- Non Recommandé :
  python
```
value = my_list [2]
sublist = my_list [1:3]
```
Évitez d'utiliser plusieurs espaces autour d'un opérateur d'affectation pour aligner le code :
- Recommandé :
  python
```
x = 10
y = 20
total = x + y
```
- Non Recommandé :
  python
```
x     = 10
y     = 20
total = x + y
```

Excellent travail ! Dans cette leçon, vous avez appris à connaître PEP 8, le guide de style Python qui fournit de meilleures pratiques pour écrire un code Python propre, lisible et cohérent.

Vous savez maintenant que PEP 8 est un ensemble de recommandations pour le style de code Python, y compris des directives pour l'indentation, la longueur maximale des lignes, les espaces blancs et les conventions d'affectation des noms. Vous avez exploré comment utiliser correctement l'indentation (4 espaces par niveau), limiter la longueur des lignes à 79 caractères et organiser le code avec des lignes vides pour une meilleure lisibilité.

De plus, vous avez également découvert les meilleures pratiques pour nommer les variables, les fonctions et les classes, comme l'utilisation de lowercase_with_underscores pour les fonctions et les variables.

Vous avez également exploré les directives de PEP 8 sur l'utilisation des espaces blancs autour des opérateurs, des parenthèses et dans les appels de fonction.

Continuez le bon travail !