Comment utiliser l’instruction ‘Pass’ en Python

Lors du développement d’un programme, il est rare de concevoir l’intégralité du code d’un seul trait et de le soumettre à l’exécution seulement à la fin. En règle générale, on procède par étapes : on écrit une partie du code, on l’exécute, on continue l’écriture et on répète ce processus jusqu’à la finalisation du projet.

Cette approche, consistant à diviser le problème en sous-problèmes plus maniables, permet de se concentrer sur des éléments clés et de reporter d’autres aspects à une phase ultérieure. Pour mettre en œuvre cette méthode de manière efficace en Python, il est indispensable de maîtriser l’instruction `pass`, qui fait l’objet de cet article.

Qu’est-ce que l’instruction « Pass » ?

Contrairement à la majorité des mots-clés qui ordonnent à l’interpréteur d’exécuter une action, l’instruction `pass` se distingue par son rôle : elle indique à l’interpréteur de ne rien faire. Elle est utilisée au sein de blocs de code.

En Python, les blocs de code sont définis par l’indentation de lignes sous des fonctions, des classes ou des instructions de contrôle de flux. Ces dernières modifient l’exécution séquentielle d’un programme en sautant du code via des conditions ou en répétant des portions de code à l’aide de boucles. Parmi les mots-clés de contrôle de flux courants en Python, on trouve `if`, `for` et `while`.

Pourquoi avons-nous besoin de l’instruction « Pass » ?

J’ai mentionné précédemment que l’instruction `pass` est une instruction qui ne réalise aucune action. Mais dans quel cas aurait-on besoin d’une instruction qui ne fait rien lors de la création d’un programme censé accomplir des actions ? Dans cette section, je vais exposer les différentes situations où l’instruction `pass` s’avère utile.

#1. Espace réservé pour une implémentation future

Comme évoqué en introduction, il est avantageux de diviser pour mieux régner lors de la conception de son programme. Par exemple, lors de l’élaboration d’une fonction, il peut être souhaitable de créer l’en-tête de la fonction et de revenir plus tard pour écrire le corps de la fonction.

Cependant, l’interpréteur Python générera une erreur si vous tentez d’exécuter le code sans corps de fonction. En effet, Python requiert que le corps d’une fonction, ou tout bloc de code, contienne au moins une instruction. Voici un exemple de fonction dans un fichier Python :

def ma_fonction():
    # Le code sera écrit ultérieurement
    # Pour l'instant, il n'y a aucune instruction

Si l’on essaye d’exécuter ce code, on obtient une erreur de syntaxe du type :

File "<ipython-input-1-58189b01193e>", line 3
    # Pour l'instant, il n'y a aucune instruction
                                     ^
SyntaxError: incomplete input

Notre stratégie de division ne sera pas possible si nous devons tout coder dès le départ, mais Python exige que nous inscrivions au moins une instruction. L’instruction `pass` est la solution à ce problème. Il s’agit techniquement d’une instruction, donc si vous l’incluez dans un bloc, Python ne générera pas d’erreur. De plus, comme elle ne fait rien, vous n’avez pas à vous préoccuper de sa logique d’exécution. Voici la fonction précédente modifiée avec l’instruction `pass` :

def ma_fonction():
    # Le code sera écrit ultérieurement
    # Pour l'instant, nous avons l'instruction pass
    pass

Maintenant, l’exécution de ce code ne déclenche plus d’erreur.

Il est également possible d’appeler la fonction pour vérifier qu’elle n’effectue aucune action.

C’est en substance le principal cas d’utilisation de l’instruction `pass` en Python : servir d’espace réservé pour les blocs de code vides. Cela n’est pas limité aux fonctions, mais peut aussi être appliqué aux conditions, boucles et classes.

#2. Mise en œuvre de classes abstraites et d’interfaces

L’instruction `pass` peut également être employée pour implémenter une classe abstraite. Une classe abstraite est une classe qui définit des méthodes abstraites, c’est-à-dire des méthodes qui sont déclarées, mais pas implémentées. Cela ressemble au cas d’utilisation mentionné précédemment où l’instruction `pass` était utilisée comme espace réservé. Cependant, contrairement au cas précédent où l’instruction `pass` n’était que temporaire, dans ce cas, elle est permanente.

Les classes abstraites sont des classes de base qui spécifient les méthodes que les sous-classes héritant doivent mettre en œuvre. Les classes abstraites n’implémentent pas de logique; elles définissent les méthodes qui composeront les classes qui en héritent. Par conséquent, on n’instancie pas directement une classe de base abstraite.

Pour créer des classes abstraites en Python, on utilise le décorateur `@abstractmethod` et la classe `ABC` définis dans le module `abc`. Si vous n’êtes pas familier avec les décorateurs, voici un article sur les décorateurs en Python.

Pour rappel, le module `abc` définit le décorateur `@abstractmethod` et la classe `ABC`, que l’on utilise de la manière suivante :

from abc import (abstractmethod, ABC)

class ClasseBasique(ABC):

    @abstractmethod
    def methode_basique(self):
        # methode_basique est une méthode que toute sous-classe de ClasseBasique doit mettre en œuvre
        # On se contente donc de la définir ici sans l'implémenter
        # On utilise donc l'instruction pass dans le corps pour obtenir un code valide
        pass

`ClasseBasique` hérite de la classe `ABC`. De plus, le décorateur `@abstractmethod` est appliqué à la `methode_basique`. Il est maintenant possible d’hériter de cette classe et d’implémenter `methode_basique`.

class ClasseDerivee(ClasseBasique):
    def methode_basique(self):
        print("Bonjour de la méthode basique définie")

Ensuite, vous pouvez créer une instance de cette classe et tester l’exécution de `methode_basique`.

mon_objet = ClasseDerivee()

mon_objet.methode_basique()

L’exécution de ce code devrait afficher le message suivant :

Bonjour de la méthode basique définie

#3. Ne rien faire avec les exceptions capturées

Lorsqu’une erreur survient lors de l’exécution d’un programme en Python, une exception est levée. Les exceptions sont perturbatrices, car elles interrompent l’exécution du programme. Cependant, il est possible d’intercepter et de gérer les exceptions afin d’empêcher le programme de planter. L’instruction `pass` peut être employée si vous ne souhaitez effectuer aucune action particulière lors de la gestion de l’erreur. Voici un exemple :

try:
    # code qui lèvera certainement une exception
    raise Exception('Une exception quelconque')
except:
    pass

Si vous exécutez le code précédent, rien ne se produira. L’exception est levée et gérée par le code du bloc `except`, mais ce dernier ne réalise aucune action. Habituellement, il est préférable de consigner l’exception ou de la traiter de manière appropriée, mais si vous ne souhaitez rien faire, c’est la méthode à employer.

Quelle est la différence entre l’instruction « Pass » et les instructions « Break » et « Continue » ?

D’autres mots-clés que vous pourriez rencontrer sont `break` et `continue`. En résumé, je vais vous expliquer ce qu’ils font afin que vous puissiez voir en quoi ils diffèrent de l’instruction `pass`.

Instruction « Break »

L’instruction `break` est utilisée pour sortir d’une boucle. Toute itération suivante de la boucle est annulée. Par exemple, si vous écrivez une fonction de recherche linéaire, une fois que l’élément est trouvé, il n’est plus nécessaire de continuer à parcourir la liste. Il est alors logique de sortir de la boucle. Dans ce cas, vous utiliserez l’instruction `break`. Voici un exemple de fonction de recherche linéaire :

def recherche_lineaire(valeurs, valeur_recherchee):
    for i in range(len(valeurs)):
        if valeurs[i] == valeur_recherchee:
            print("Valeur trouvée à l'index", i)
            break

Instruction « Continue »

L’instruction `continue` est utilisée pour ignorer l’itération actuelle dans une boucle. Si vous parcourez une liste de nombres, lorsque votre programme rencontre une instruction `continue`, il arrête l’itération en cours et passe à l’itération suivante. La boucle continue de s’exécuter. Voici un exemple de fonction qui utilise l’instruction `continue`. Le programme double tous les nombres impairs pour qu’une liste ne contienne que des nombres pairs.

def rendre_pairs(nombres):
    for i in range(len(nombres)):
        if nombres[i] % 2 == 0:
            # Si le nombre est déjà pair, on passe à l'itération suivante avec continue
            continue
        
        # Seuls les nombres impairs arrivent ici
        # On double le nombre pour qu'il devienne pair
        nombres[i] *= 2

En ayant une bonne compréhension des instructions `break` et `continue`, vous êtes maintenant en mesure de faire la distinction avec l’instruction `pass`.

Bonnes pratiques pour l’utilisation de l’instruction « Pass »

✅ Gardez à l’esprit que l’instruction `pass` est généralement utilisée comme espace réservé temporaire ; n’oubliez pas de remplacer l’instruction `pass` par le code réel lorsque vous êtes prêt.

✅ Si vous utilisez l’instruction `pass` pour autre chose qu’un espace réservé temporaire, ajoutez un commentaire expliquant la raison de sa présence.

En guise de conclusion

Dans cet article, j’ai expliqué l’instruction `pass` en Python, un mot-clé utile qui vous permet de diviser pour mieux régner lors de l’écriture de code. L’instruction `pass` est également mentionnée dans la documentation de Python.

Pour aller plus loin, explorez les types d’erreurs Python courantes et les méthodes pour les résoudre.