Améliorer la qualité du code grâce au linting en Python

Python est un langage en plein essor. À mesure qu’il évolue et se développe, le nombre d’outils et de stratégies de développement disponibles pour l’utiliser augmente également. Le linting — c’est-à-dire la vérification du code pour détecter d’éventuels problèmes — est une pratique de plus en plus populaire. Il signale les erreurs dans le code afin que nous puissions corriger les pratiques de programmation inhabituelles susceptibles d’entraîner des problèmes.

Le linting est effectué pendant l’écriture du code source, avant sa compilation. Autrement dit, il s’agit d’une vérification préalable à la compilation, également appelée « analyse statique du code ». Vérifier régulièrement notre code avec le linting garantit sa cohérence dans l’ensemble du code et de la base de code. Cela réduit le risque que de petites erreurs se transforment en problèmes complexes après l’exécution du code.

De nombreux développeurs n’utilisent pas le linting, car ils n’en perçoivent pas la valeur ajoutée : il ne permet pas d’éviter les bugs. Mais cette vision sous-estime l’intérêt du linting pour améliorer la qualité du code.

Dans cet article pratique, nous allons découvrir à quel point il est rapide et facile d’effectuer des vérifications de linting en Python avec Pylint, l’un des outils de linting les plus populaires. Nous verrons également comment le linting peut nous aider à respecter le guide de style de code PEP8.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Python et pip installés sur votre machine

• Une connaissance de base des interfaces en ligne de commande (CLI)

• Une bonne compréhension des concepts Python, comme les fonctions et les classes

Notez également que, si les commandes présentées ici sont compatibles avec Linux et macOS, vous devez faire preuve de prudence lorsque vous travaillez sous Windows.

Linting du code Python

Avant de voir comment utiliser un linter en Python, préparons notre environnement en créant un répertoire et un environnement virtuel.

Préparer notre environnement

Commencez par créer un répertoire pour le projet. Pour ce tutoriel, nous l’appellerons pylint-demo.

1$ mkdir pylint-demo
2
3$ cd pylint-demo

Créez ensuite un environnement virtuel. Il isolera les dépendances de notre projet et évitera les conflits avec d’autres projets.

1$ pip install pipenv
2
3$ pipenv shell

Votre invite de commande devrait ressembler à ceci : (pylint-demo) $. Cela indique que l’environnement virtuel est actif.

Une fois l’environnement virtuel activé, installez le linter à l’aide de la commande suivante :

1$ pipenv install pylint

Nous pouvons maintenant lancer le linter avec la commande pylint. Pour vérifier que Pylint est bien installé, exécutez la commande suivante :

1$ pylint –help

Premiers pas avec le linting

Écrivons un programme Python simple et utilisons Pylint pour voir comment il fonctionne. Créez un fichier main.py et copiez-y le code suivant :

1def is_number_even(num):
2    return "Even" if num % 2 == 0 else "Odd"
3
4num = 5
5print(f"The number {num} is {is_number_even(num)}")

Dans le code ci-dessus, nous avons ajouté une fonction qui vérifie si le nombre est pair ou impair. Pour vérifier la présence d’erreurs dans ce code avec Pylint, exécutons la commande suivante :

1$ pylint <<file_name>>
2$ pylint main.py

Voici le résultat de Pylint :

1************* Module main
2main.py:12:0: C0304: Final newline missing (missing-final-newline)
3main.py:1:0: C0114: Missing module docstring (missing-module-docstring)
4main.py:8:0: C0116: Missing function or method docstring (missing-function-docstring)
5main.py:8:19: W0621: Redefining name 'num' from outer scope (line 11) (redefined-outer-name)
6main.py:11:0: C0103: Constant name "num" doesn't conform to UPPER_CASE naming style (invalid-name)
7
8------------------------------------------------------------------
9Your code has been rated at 0.00/10 (previous run: 0.00/10, +0.00)

Nous pouvons repérer plusieurs problèmes évidents dans le code, chacun identifié par un code tel que C0304. Pylint attribue une lettre à chaque erreur pour en distinguer la gravité et la nature. Il existe cinq catégories d’erreurs :

• C : Convention (non-respect des conventions de code)

• R : Refactorisation (problème lié à une mauvaise qualité du code ou à sa refactorisation)

• W : Avertissement (problème de programmation qui ne constitue pas une erreur)

• E : Erreur (problème de programmation constituant une erreur)

• F : Erreur fatale (problème grave ayant interrompu l’exécution de Pylint)

Pylint attribue également une note sur 10 à notre code, en fonction du nombre d’erreurs détectées.

Dans notre exemple, toutes les erreurs sauf une relèvent des conventions ; la dernière est un avertissement. Pour corriger ces problèmes, apportons quelques modifications à notre code, puis relançons Pylint pour voir la note obtenue.

1""" File contains various function to under Pylint """
2
3def is_number_even(num):
4    """Function to check if number is even or odd"""
5    return "Even" if num % 2 == 0 else "Odd"
6
7NUM = 5
8print(f"The number {NUM} is {is_number_even(NUM)}")

Dans cette version, nous avons ajouté une docstring au module et à la fonction, ajouté une nouvelle ligne à la fin et renommé la variable utilisée dans le code ci-dessus. En relançant Pylint, nous obtenons 10/10 sans aucun problème.

Exécuter Pylint sur un seul fichier

Maintenant que nous savons mieux comment fonctionne Pylint, examinons un autre exemple. Saisissez le code suivant :

1""" File contains various function to under Pylint """
2
3class animal:
4  def __init__(self, name):
5    self.name = name
6
7obj1 = animal("Horse", 21)
8print(obj1.name)

Dans cet extrait, nous avons une classe simple appelée animal et un objet de cette classe nommé obj1. Utilisons maintenant Pylint sur ce code.

1************* Module main
2main.py:4:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
3main.py:5:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
4main.py:3:0: C0115: Missing class docstring (missing-class-docstring)
5main.py:3:0: C0103: Class name "animal" doesn't conform to PascalCase naming style (invalid-name)
6main.py:3:0: R0903: Too few public methods (0/2) (too-few-public-methods)
7main.py:7:7: E1121: Too many positional arguments for constructor call (too-many-function-args)

Remarquez que, cette fois, les problèmes de qualité du code ont laissé place à des erreurs plus importantes. Maintenant que les problèmes ont été signalés, essayons de les corriger avec le code ci-dessous :

1""" File contains various function to under Pylint """
2
3class Animal:
4    "Animal Class"
5    def __init__(self, name):
6        self.name = name
7
8obj1 = Animal("John")
9print(obj1.name)

Relancez ensuite Pylint. Après avoir renommé la classe animal en Animal, ajouté une docstring à la classe, supprimé les arguments inutiles des appels de fonction et ajouté une indentation correcte, nous avons presque éliminé toutes les erreurs de notre code. Il en reste toutefois une :

1************* Module main
2main.py:3:0: R0903: Too few public methods (0/2) (too-few-public-methods)

Voyons comment corriger cette dernière erreur. Selon Pylint, nous n’avons pas deux méthodes publiques ou plus. Or, il est fort probable que notre code n’ait pas deux méthodes publiques ou plus. Comment résoudre ce problème ?

Dans ce cas, nous pouvons utiliser des commentaires Python pour ignorer ces problèmes. Voici la syntaxe à employer :

1# pylint: disable=<<issue_name>>

Voici à quoi ressemblera le code :

1""" File contains various function to under Pylint """
2
3# pylint: disable=too-few-public-methods
4class Animal:
5    "Animal Class"
6    def __init__(self, name):
7        self.name = name
8
9obj1 = Animal("John")
10print(obj1.name)

En vérifiant à nouveau le résultat de Pylint, nous constaterons que le problème a disparu.

Exécuter Pylint sur un répertoire

Nous avons vu comment exécuter Pylint sur un seul fichier. Mais dans un projet, nous ne pouvons pas nous limiter à un seul fichier à vérifier. Nous devons effectuer le linting de notre répertoire.

Pour utiliser Pylint sur l’ensemble du répertoire, exécutez la commande suivante :

1$ pylint <<name_of_directory>>

Pour voir comment fonctionne le linting d’un répertoire, créons deux fichiers supplémentaires et ajoutons-y du code.

1$ mkdir src; cd src
2$ touch helpers.py config.py __init__.py

Déplacez le fichier main.py dans le répertoire src, puis collez le code suivant dans les fichiers correspondants :

1<<main.py>>
2""" File contains various function to under Pylint """
3
4from helpers import connect_db
5from config import DB_USER, DB_PASS
6
7is_connected = connect_db(DB_USER, DB_PASS)
8
9if is_connected:
10    print("Connected to DB")
11else:
12    print("Failed to connect to DB")
13
14<<helpers.py>>
15def connect_db(user, password):
16    """Dummy function to connect to DB"""
17    if user is None or password is None:
18        return False
19    return True
20
21<<config.py>>
22DB_USER = "root"
23DB_PASS = "toor"

Le répertoire src contient trois fichiers : main.py, helpers.py et config.py. Dans main.py, une fonction factice indique si nous sommes connectés à la base de données. helpers.py contient une fonction utilitaire factice qui se connecte à la base de données, et le fichier config.py contient le nom d’utilisateur et le mot de passe de la base de données.

Exécutons maintenant Pylint sur l’ensemble du répertoire à l’aide de la commande suivante, depuis le répertoire racine :

1$ pylint src

Voici le résultat de la commande :

1************* Module src.config
2src/config.py:2:0: C0304: Final newline missing (missing-final-newline)
3src/config.py:1:0: C0114: Missing module docstring (missing-module-docstring)
4************* Module src.main
5src/main.py:11:0: C0304: Final newline missing (missing-final-newline)
6src/main.py:3:0: E0401: Unable to import 'helpers' (import-error)
7src/main.py:4:0: E0401: Unable to import 'config' (import-error)
8************* Module src.helpers
9src/helpers.py:6:0: C0304: Final newline missing (missing-final-newline)
10src/helpers.py:1:0: C0114: Missing module docstring (missing-module-docstring)

Comme nous pouvons le voir, Pylint affiche les résultats pour différents fichiers, séparés par *** et par le nom du module. Pour corriger les problèmes, nous devons apporter les modifications suivantes :

• Ajouter une nouvelle ligne à la fin de chaque fichier.

• Ajouter une docstring à chaque fichier et à chaque fonction.

• Modifier l’instruction import en remplaçant helpers import connect_db par .helpers import connect_db.

Une fois ces problèmes corrigés, un autre apparaît : nous devons mettre la variable is_connected en majuscules. Nous pouvons soit renommer la variable, soit ignorer l’avertissement pour résoudre ce problème.

Ignorer les avertissements

Il est fort probable que vous deviez personnaliser ou ignorer plusieurs avertissements lors du linting de votre code Python. Ajouter un commentaire à chaque fois ne serait pas pratique. Plutôt que de traiter les avertissements un à un, vous pouvez créer un fichier .rc pour personnaliser le comportement de Pylint et ignorer les avertissements dans tout le projet directement depuis ce fichier .rc.

Vous pouvez en créer un avec la commande suivante :

1$ pylint --generate-rcfile > pylint.rc

Un code de meilleure qualité et plus sûr grâce au linting

Le linting en Python vérifie le code source au fur et à mesure de son écriture et signale les erreurs avant l’exécution. Vous pouvez également intégrer Pylint à votre éditeur pour visualiser les résultats du linting en temps réel.

Même si le linting ne corrige pas automatiquement les bugs, son utilisation régulière contribue à maintenir une qualité de code élevée. Ainsi, contrairement à certains développeurs qui le considèrent comme une perte de temps, le linting est très efficace pour détecter les petits problèmes avant qu’ils ne prennent de l’ampleur.

Dans cet article, nous avons vu comment le linting et l’application des recommandations de Pylint ont amélioré notre exemple de code. Cette démarche nous aide également à respecter le guide de style PEP8. Maintenant que vous savez intégrer le linting à vos projets, explorez les nombreux outils disponibles pour trouver celui qui complète et améliore le mieux votre approche du développement Python.