Style de Code PEP 8 en Python

Introduction

Dans ce laboratoire, vous apprendrez à appliquer le guide de style PEP 8 à votre code Python. PEP 8 est le guide de style officiel pour Python, fournissant un ensemble de recommandations pour écrire un code lisible et cohérent. Le respect de ces directives rend votre code plus facile à lire pour vous et pour les autres.

Vous vous entraînerez à mettre en œuvre les règles clés de PEP 8 concernant l'indentation, la longueur des lignes, l'espacement et les conventions de nommage. Vous apprendrez également à utiliser l'outil autopep8 pour formater automatiquement votre code, ce qui vous fera gagner du temps et assurera la conformité avec les normes de la communauté.

Comprendre l'Indentation et la Longueur des Lignes PEP 8

Une indentation et une longueur de ligne appropriées sont fondamentales pour un code Python lisible. Dans cette étape, vous apprendrez et appliquerez les directives PEP 8 concernant ces deux aspects.

Indentation : PEP 8 recommande l'utilisation de 4 espaces par niveau d'indentation. C'est une convention forte au sein de la communauté Python.

Longueur des Lignes : PEP 8 suggère de limiter toutes les lignes à un maximum de 79 caractères. Pour les docstrings et les commentaires, la limite est de 72 caractères. Cela améliore la lisibilité, en particulier sur les petits écrans ou lors de la comparaison de code côte à côte.

Mettons cela en pratique. Dans l'explorateur de fichiers à gauche, trouvez et ouvrez le fichier indentation_example.py. Le code qu'il contient démontre l'indentation correcte pour les définitions de fonctions et les instructions sur plusieurs lignes.

## Correct indentation using 4 spaces.
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

## Define some variables for demonstration.
var_one = "first"
var_two = "second"
var_three = "third"
var_four = "fourth"

## Aligning with the opening delimiter.
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

## Using a hanging indent. The first line has no arguments,
## and subsequent lines are indented to distinguish them.
bar = long_function_name(
    var_one, var_two,
    var_three, var_four)

## A multi-line list.
my_list = [
    1, 2, 3,
    4, 5, 6,
]

## Calling the functions to produce output.
long_function_name("first call", "second", "third", "fourth")
foo = long_function_name("second call", "second", "third", "fourth")
bar = long_function_name("third call", "second", "third", "fourth")

Après avoir examiné le code, exécutez le script pour voir sa sortie. Ouvrez le terminal en bas du WebIDE et exécutez la commande suivante :

python ~/project/indentation_example.py

Le script s'exécutera et affichera le premier argument de chaque appel de fonction. La sortie sera :

first call
second call
third call

Cet exercice démontre à quel point une indentation cohérente rend les appels de fonctions complexes et les structures de données beaucoup plus faciles à lire.

Pratiquer l'Espacement et les Conventions de Nommage

Un espacement cohérent et des conventions de nommage claires sont également cruciaux pour la lisibilité du code. Cette étape couvre les règles PEP 8 pour ces deux aspects.

Espacement :

• Utiliser un seul espace autour de la plupart des opérateurs (=, +=, ==, <, >).
• Utiliser un espace après les virgules dans les listes, les tuples et les arguments de fonction.
• Éviter les espaces superflus immédiatement à l'intérieur des parenthèses, crochets ou accolades.

Conventions de Nommage :

• snake_case : À utiliser pour les fonctions et les variables (exemples : my_function, user_name).
• PascalCase : À utiliser pour les noms de classes (exemple : MyClass).
• UPPERCASE_SNAKE_CASE : À utiliser pour les constantes (exemple : MAX_CONNECTIONS).

Voyons ces règles en action. Dans l'explorateur de fichiers, ouvrez le fichier style_guide_example.py. Le code contient des exemples d'espacement et de nommage corrects, avec des versions incorrectes commentées pour comparaison.

## A constant
MAX_OVERFLOW = 100

## A class name in PascalCase
class MySampleClass:
    def __init__(self, name):
        ## A variable name in snake_case
        self.instance_name = name

    ## A function name in snake_case
    def sample_method(self, var_one, var_two):
        ## Correct spacing around operators and after comma
        result = var_one + var_two
        print(self.instance_name, result)

## --- Incorrect examples for comparison ---
## class mySampleClass:
##     def SampleMethod(self, varOne, varTwo):
##         result=varOne+varTwo
##         print(self.instance_name,result)

## Create an object and call the method
my_object = MySampleClass("TestObject")
my_object.sample_method(10, 5)

Enregistrez le fichier si vous avez effectué des modifications, puis exécutez-le depuis le terminal :

python ~/project/style_guide_example.py

La sortie affichera le nom de l'objet et le résultat du calcul :

TestObject 15

En suivant ces règles d'espacement et de nommage, vous rendez la structure et l'objectif de votre code immédiatement plus clairs pour tout lecteur.

Utiliser autopep8 pour le Formatage Automatique

Formater manuellement le code peut être fastidieux. Heureusement, des outils existent pour automatiser ce processus. Dans cette étape, vous allez installer et utiliser autopep8, un outil populaire qui reformatte automatiquement le code Python pour qu'il soit conforme au guide de style PEP 8.

Tout d'abord, vous devez installer le paquet autopep8. Ouvrez le terminal et exécutez la commande suivante. sudo est utilisé pour l'installer au niveau du système.

sudo pip3 install autopep8

Le processus d'installation va commencer, et vous devriez voir une sortie confirmant son installation réussie :

Collecting autopep8
...
Successfully installed autopep8-X.Y.Z

Ensuite, travaillons avec un fichier Python qui présente délibérément un mauvais formatage. Dans l'explorateur de fichiers, ouvrez unformatted_code.py et examinez son contenu :

a=1
b=2;
def  my_function ( arg1 , arg2 = 0 ):
    result = arg1+arg2
    print( result)

Ce code présente plusieurs problèmes de style : espacement incohérent, un point-virgule redondant et des espaces superflus dans la définition de la fonction.

Maintenant, utilisons autopep8 pour corriger cela. L'option --in-place indique à l'outil de modifier le fichier directement. Exécutez cette commande dans votre terminal :

autopep8 --in-place ~/project/unformatted_code.py

Une fois la commande terminée, rouvrez unformatted_code.py dans l'éditeur. Vous verrez que le code a été automatiquement nettoyé :

a = 1
b = 2


def my_function(arg1, arg2=0):
    result = arg1 + arg2
    print(result)

Remarquez comment autopep8 a corrigé l'espacement, supprimé le point-virgule et ajouté deux lignes vides avant la définition de la fonction, comme le recommande PEP 8. Utiliser un formateur automatique comme autopep8 est un moyen très efficace de maintenir un style de code cohérent dans tous vos projets.

Assembler le Tout : Refactorisation d'un Script

Il est maintenant temps d'appliquer tout ce que vous avez appris. Dans cette étape, vous allez refactoriser manuellement un script qui viole plusieurs directives PEP 8. Cet exercice testera votre compréhension de l'indentation, de l'espacement et des conventions de nommage.

Tout d'abord, ouvrez refactor_challenge.py depuis l'explorateur de fichiers. Il contient le code suivant, qui calcule l'aire d'un rectangle mais est écrit avec un mauvais style.

## This script calculates the area of a rectangle and prints it.
def CalculateArea(width,height):
    Area = width*height ## calculate area
    return Area

w = 10
h = 5
rectangle_area=CalculateArea(w,h)
print("The area of the rectangle is:",rectangle_area)

Votre tâche consiste à modifier manuellement ce code dans l'éditeur pour le rendre conforme à PEP 8. Recherchez les problèmes suivants :

1. Nommage des Fonctions : Les noms de fonctions doivent être en snake_case.
2. Nommage des Variables : Les noms de variables doivent également être en snake_case.
3. Espacement : Vérifiez l'espacement approprié autour des opérateurs et après les virgules.
4. Commentaires : Les commentaires en ligne doivent avoir un espace après le #.

Prenez un moment pour refactoriser le code vous-même. Une fois terminé, votre code devrait ressembler à ceci :

## This script calculates the area of a rectangle and prints it.
def calculate_area(width, height):
    """Calculate and return the area of a rectangle."""
    area = width * height  ## calculate area
    return area


w = 10
h = 5
rectangle_area = calculate_area(w, h)
print("The area of the rectangle is:", rectangle_area)

Remarquez les changements : CalculateArea est devenu calculate_area, Area est devenu area, et l'espacement a été corrigé. Nous avons également ajouté une docstring (chaîne de documentation) à la fonction, ce qui est une bonne pratique pour expliquer ce que fait une fonction.

Enregistrez vos modifications et exécutez le script pour vous assurer qu'il fonctionne toujours correctement :

python ~/project/refactor_challenge.py

La sortie devrait être :

The area of the rectangle is: 50

Cet exercice montre que la refactorisation pour le style ne change pas le fonctionnement du code, mais améliore considérablement sa lisibilité et sa maintenabilité.

Résumé

Dans ce laboratoire, vous avez appris les fondamentaux du guide de style PEP 8 pour Python. Vous avez pratiqué l'application des règles concernant l'indentation, la longueur des lignes, l'espacement et les conventions de nommage. Vous avez également découvert la puissance de autopep8 pour formater automatiquement votre code afin qu'il respecte ces normes. En réalisant un défi de refactorisation final, vous avez rassemblé tous ces concepts pour transformer un script mal stylisé en un code Python propre, lisible et maintenable. Le respect de PEP 8 est une pratique essentielle pour tout développeur Python professionnel, car il favorise la collaboration et améliore la qualité du code.