Skip to main content

Module : Linting et Formatage (Flake8, Black)

Objectif​

Ce module a pour but de vous initier aux outils de qualité de code essentiels en Python : les linters (comme Flake8) pour détecter les erreurs et les problèmes de style, et les formateurs de code (comme Black) pour standardiser la mise en forme de votre code automatiquement.

1. Pourquoi la Qualité du Code est-elle Importante ?​

Un code qui "fonctionne" n'est pas nécessairement un bon code. La qualité du code est cruciale pour :

  • La lisibilité : Un code facile à lire est plus facile à comprendre, à déboguer et à maintenir.
  • La maintenance : La majorité du coût d'un logiciel réside dans sa maintenance. Un code propre réduit ce coût.
  • La collaboration : Des règles de style communes permettent aux équipes de travailler plus efficacement sur une même base de code.

Le PEP 8 est le guide de style officiel pour le code Python. Il définit des conventions sur la longueur des lignes, l'indentation, les imports, les espaces, etc. Les outils de linting et de formatage aident à respecter ces conventions.

2. Le Linting avec Flake8​

Un linter est un outil d'analyse statique qui vérifie le code source pour y trouver des erreurs de programmation, des bugs, des erreurs stylistiques et des constructions suspectes.

Flake8 est l'un des linters les plus populaires. Il combine trois outils en un :

  • Pyflakes : Détecte les erreurs logiques (variable non utilisée, import non utilisé, etc.).
  • pycodestyle (anciennement pep8) : Vérifie la conformité au guide de style PEP 8.
  • McCabe : Mesure la complexité cyclomatique de votre code (aide à détecter les fonctions trop complexes).

Utilisation de Flake8​

  1. Installation :

    pip install flake8

  2. Créer un fichier mal formaté (mauvais_code.py) :

    import os # Import non utilisé

    def ma_fonction(arg1,arg2): # Pas d'espaces autour des virgules
        resultat=arg1+arg2 # Pas d'espaces autour de = et +
        print("Le resultat est",resultat) # Espace avant la parenthèse de print
        return resultat

    # Ligne trop longue
    variable_tres_longue_pour_rien = "une valeur qui rend la ligne beaucoup trop longue pour respecter les standards du PEP 8 qui limitent la longueur à 79 ou 88 caractères"

  3. Lancer Flake8 :

    flake8 mauvais_code.py

  4. Résultat : Flake8 va lister tous les problèmes trouvés, avec le nom du fichier, le numéro de ligne, le numéro de colonne et un code d'erreur.

    mauvais_code.py:1:1: F401 'os' imported but unused
    mauvais_code.py:3:19: E231 missing whitespace after ','
    mauvais_code.py:4:13: E225 missing whitespace around operator
    mauvais_code.py:5:11: E211 whitespace before '('
    mauvais_code.py:8:80: E501 line too long (139 > 79 characters)
    • F... : Erreur Pyflakes (logique)
    • E... / W... : Erreur / Avertissement pycodestyle (style)
    • C... : Erreur McCabe (complexité)

Configuration de Flake8​

On peut configurer Flake8 pour ignorer certaines règles ou ajuster des paramètres (comme la longueur de ligne max) via un fichier de configuration à la racine du projet : .flake8, setup.cfg ou tox.ini.

Exemple de fichier .flake8 :

[flake8]
# Ignorer l'erreur de ligne trop longue (E501) et d'import non utilisé (F401)
ignore = E501, F401
# Augmenter la longueur de ligne maximale à 88 (pour être compatible avec Black)
max-line-length = 88

3. Le Formatage Automatique avec Black​

Un formateur de code est un outil qui réécrit automatiquement votre code pour qu'il respecte un ensemble de règles de style.

Black est le formateur le plus en vogue. Il est décrit comme "The Uncompromising Code Formatter". Son avantage est qu'il ne laisse quasiment aucune option de configuration. Tout le monde qui utilise Black produit un code qui a exactement la même apparence. Cela met fin aux débats sur le style.

Utilisation de Black​

  1. Installation :

    pip install black

  2. Formater un fichier : Black modifie les fichiers en place.

    black mauvais_code.py

  3. Résultat : La commande affiche :

    reformatted mauvais_code.py
    All done! ✨ 🍰 ✨
    1 file reformatted.

    Le fichier mauvais_code.py est maintenant formaté :

    import os  # Import non utilisé (Black ne supprime pas le code)

    def ma_fonction(arg1, arg2):  # Espaces corrects
        resultat = arg1 + arg2  # Espaces corrects
        print("Le resultat est", resultat)  # Espace avant parenthèse supprimé
        return resultat

    # Ligne trop longue, Black l'a ré-indentée
    variable_tres_longue_pour_rien = (
        "une valeur qui rend la ligne beaucoup trop longue pour respecter les standards du"
        " PEP 8 qui limitent la longueur à 79 ou 88 caractères"
    )

Commandes utiles de Black​

  • black . : Formate tous les fichiers du dossier courant et des sous-dossiers.
  • black --check . : Vérifie si des fichiers ont besoin d'être formatés, mais ne les modifie pas. C'est très utile en intégration continue (CI) pour s'assurer que le code est bien formaté.
  • black --diff . : Affiche les différences, comme git diff, sans modifier les fichiers.

4. Intégration des Outils​

Flake8 et Black sont conçus pour bien fonctionner ensemble. Black s'occupe du formatage (où mettre les espaces, les sauts de ligne, etc.), et Flake8 s'occupe des problèmes de logique (imports non utilisés, variables non définies, etc.).

Le workflow typique est :

  1. Écrire son code.
  2. Lancer black . pour formater automatiquement tout le projet.
  3. Lancer flake8 . pour vérifier les erreurs de logique restantes.
  4. Corriger manuellement les erreurs signalées par Flake8.

Intégration avec les Éditeurs de Code​

La plupart des éditeurs modernes (VS Code, PyCharm, etc.) peuvent être configurés pour :

  • Formater automatiquement le code avec Black à chaque sauvegarde.
  • Afficher les erreurs Flake8 directement dans l'éditeur au fur et à mesure que vous tapez.

C'est la manière la plus productive de travailler.

Intégration avec les Hooks de Pre-commit​

On peut utiliser le framework pre-commit pour lancer black et flake8 automatiquement avant chaque git commit. Si les outils échouent, le commit est annulé, garantissant que seul du code propre et bien formaté entre dans le dépôt Git.

Conclusion​

Adopter des outils comme Flake8 et Black est un pas de géant vers l'écriture de code Python professionnel. Black élimine les soucis de formatage en rendant le style du code cohérent et non négociable, tandis que Flake8 agit comme un filet de sécurité, attrapant les erreurs courantes et les mauvaises pratiques. En intégrant ces outils dans votre workflow (éditeur, pre-commit hooks, CI), vous améliorez drastiquement la qualité, la lisibilité et la maintenabilité de vos projets, que vous travailliez seul ou en équipe.