Indentation, espacement et longueur des lignes

PEP 8 : le guide de style officiel pour Python

PEP 8 (Python Enhancement Proposal 8) est le guide de style officiel pour le code Python. Il définit des conventions et des recommandations pour l'indentation, l'espacement, la longueur des lignes, les noms de variables, les commentaires, et d'autres aspects de la mise en forme du code.

Suivre les recommandations de PEP 8 permet d'écrire du code Python :

• Clair et lisible : Un code bien formaté est plus facile à lire et à comprendre.
• Cohérent : Le respect des conventions rend le code plus cohérent, ce qui facilite la collaboration et la maintenance.
• Conforme aux standards de la communauté : La plupart des développeurs Python suivent PEP 8, donc votre code sera plus facilement compréhensible par les autres.

Bien que PEP 8 soit un guide de style et non une règle stricte, il est fortement recommandé de le suivre autant que possible.

Indentation : 4 espaces, pas de tabulations

L'indentation est *essentielle* en Python. Elle définit la structure des blocs de code (contrairement à d'autres langages qui utilisent des accolades `{}`).

PEP 8 recommande d'utiliser **4 espaces** pour chaque niveau d'indentation. N'utilisez *pas* de tabulations.

Exemple (correct) :

def ma_fonction(x):
    if x > 0:
        print("x est positif")
    else:
        print("x est négatif ou nul")

Exemple (incorrect, avec des tabulations) :

def ma_fonction(x):
	if x > 0:  # Tabulation
		print("x est positif")  # Tabulation
	else:
		print("x est négatif ou nul")

La plupart des éditeurs de code et des IDE Python modernes peuvent être configurés pour utiliser automatiquement 4 espaces lorsque vous appuyez sur la touche Tab.

Une indentation incorrecte (mélange d'espaces et de tabulations, nombre d'espaces incorrect) provoquera une `IndentationError` ou, pire, une erreur logique difficile à détecter.

Espacement : autour des opérateurs, après les virgules, etc.

PEP 8 recommande d'utiliser des espaces pour améliorer la lisibilité du code :

• Autour des opérateurs : Mettez un espace avant et après la plupart des opérateurs binaires (comme `+`, `-`, `*`, `/`, `=`, `==`, `!=`, `<`, `>`, etc.). Ne mettez pas d'espace autour des opérateurs unaires (comme `-` dans `-5`).
• Après les virgules : Mettez un espace après une virgule (`,`), mais pas avant.
• Après les deux-points : Mettez un espace après un deux-points (`:`) dans les tranches, les dictionnaires, etc., mais pas avant. Dans une signature de fonction avec des annotations, on ne met *pas* d'espace après le `:` des annotations.
• Autour des parenthèses, crochets, accolades : Ne mettez pas d'espace après une parenthèse/crochet/accolade ouvrante, ni avant une parenthèse/crochet/accolade fermante.
• Evitez les espaces superflus : Ne mettez pas d'espaces inutiles à la fin des lignes, ou plusieurs espaces consécutifs à l'intérieur d'une ligne (sauf pour l'indentation).

Exemples :

# Correct
x = 1 + 2
y = (3, 4)
z = {"a": 5}
ma_liste[1:4]

def fonction(a: int, b:float) -> bool:
  pass

# Incorrect
x=1+2
y = ( 3 , 4 )
z = { "a" :5 }
ma_liste[1: 4]
def fonction(a :int, b: float) ->bool :

Longueur des lignes : 79 caractères maximum (recommandé)

PEP 8 recommande de limiter la longueur des lignes de code à **79 caractères** maximum.

Cette limite a des raisons historiques (elle correspondait à la largeur des terminaux texte), mais elle reste une bonne pratique pour la lisibilité du code, en particulier sur des écrans de petite taille ou lorsque vous affichez plusieurs fenêtres côte à côte.

Si une ligne de code dépasse 79 caractères, vous devez la couper en plusieurs lignes. Il existe plusieurs façons de le faire :

• Utiliser des parenthèses, des crochets ou des accolades : Python permet de couper les lignes implicitement à l'intérieur des parenthèses, des crochets et des accolades.
• Utiliser un antislash (`\`) à la fin de la ligne : Cela indique à Python que la ligne continue sur la ligne suivante. Cependant, cette méthode est moins recommandée que la précédente.
• Pour les chaînes de caractères longues : Vous pouvez utiliser des chaînes de caractères multilignes (avec des triples guillemets), ou concaténer plusieurs chaînes plus courtes.

Exemple (avec parenthèses) :

ma_fonction(argument1, argument2,
            argument3, argument4)

Exemple (avec antislash, moins recommandé) :

ma_variable = une_expression_tres_longue + \  une_autre_expression_tres_longue

Exemple (chaînes de caractères) :

message = (
    "Ceci est un message très long "
    "qui est coupé sur plusieurs lignes "
    "en utilisant des parenthèses."
)

Lorsque vous coupez une ligne, essayez de le faire de manière logique et lisible, en indentant correctement les lignes suivantes.

Lignes vides : séparer les blocs de code

Utilisez des lignes vides pour séparer les blocs de code et améliorer la lisibilité :

• Laissez *deux* lignes vides entre les fonctions ou les classes de niveau supérieur (celles qui ne sont pas à l'intérieur d'une autre fonction ou classe).
• Laissez *une* ligne vide entre les méthodes à l'intérieur d'une classe.
• Vous pouvez utiliser des lignes vides à l'intérieur des fonctions pour séparer les blocs logiques, mais faites-le avec parcimonie.

Outils pour vérifier et formater le code selon PEP 8

Il existe des outils qui peuvent vérifier automatiquement si votre code respecte les conventions de PEP 8, et même reformater automatiquement votre code pour le rendre conforme.

Quelques outils populaires :

• `pycodestyle` (anciennement `pep8`) : Un outil simple pour vérifier la conformité à PEP 8.
• `flake8` : Un outil plus complet qui combine `pycodestyle`, `pyflakes` (pour détecter les erreurs de syntaxe et les variables non utilisées), et d'autres vérifications.
• `autopep8` : Un outil qui formate automatiquement votre code pour le rendre conforme à PEP 8.
• `black` : Un formateur de code intransigeant qui applique un style de codage strict (basé sur PEP 8, mais avec quelques différences). `black` est de plus en plus populaire car il simplifie le formatage du code et garantit une cohérence dans les projets.

Ces outils peuvent être intégrés à votre éditeur de code ou à votre IDE, ou utilisés en ligne de commande.

Exemple (utilisation de `pycodestyle`) :

pip install pycodestyle
pycodestyle mon_fichier.py

Exemple (utilisation de `autopep8` pour reformater automatiquement) :

pip install autopep8
autopep8 --in-place --aggressive --aggressive mon_fichier.py

L'utilisation de ces outils est fortement recommandée pour maintenir un code propre, lisible et conforme aux conventions Python.