Comment vérifier si une fonction Python accepte certains arguments

Introduction

Dans ce labo (lab), vous apprendrez à vérifier si une fonction Python accepte certains arguments en explorant les signatures de fonction. Le labo utilise le module inspect pour accéder et examiner les signatures de fonction, fournissant des informations précieuses sur les arguments attendus et les valeurs de retour d'une fonction.

Le labo vous guide dans la création d'un script Python avec une fonction d'exemple, puis utilise inspect.signature() pour obtenir et afficher la signature de la fonction. Vous apprendrez également à interpréter la sortie pour comprendre les paramètres de la fonction et le type de retour. Enfin, le labo démontrera comment tester le passage d'arguments à l'aide de blocs try-except.

Skills Graph

Apprenez les signatures de fonction

Dans cette étape, vous apprendrez les signatures de fonction en Python. Les signatures de fonction fournissent des informations précieuses sur les arguments attendus et les valeurs de retour d'une fonction. Comprendre les signatures de fonction est essentiel pour écrire un code propre, maintenable et exempt d'erreurs.

Une signature de fonction inclut les informations suivantes :

• Nom de la fonction : Le nom de la fonction.
• Paramètres : Les noms et les types des arguments que la fonction accepte.
• Type de retour : Le type de valeur que la fonction retourne (le cas échéant).

Python propose plusieurs façons d'accéder et d'examiner les signatures de fonction. L'une des méthodes les plus courantes et les plus puissantes consiste à utiliser le module inspect. Explorons comment utiliser le module inspect pour apprendre les signatures de fonction.

Tout d'abord, créons un simple script Python nommé my_function.py dans votre répertoire ~/project en utilisant l'éditeur VS Code. Ce script définira une fonction, puis utilisera le module inspect pour examiner sa signature.

## filename: ~/project/my_function.py
import inspect

def add_numbers(x: int, y: int) -> int:
    """This function adds two numbers and returns the result."""
    return x + y

sig = inspect.signature(add_numbers)

print(sig)

Dans ce script :

• Nous importons le module inspect.
• Nous définissons une fonction appelée add_numbers qui prend deux arguments entiers (x et y) et retourne leur somme sous forme d'entier.
• Nous utilisons des indications de type (x: int, y: int, -> int) pour spécifier les types attendus des arguments et de la valeur de retour.
• Nous utilisons inspect.signature() pour obtenir la signature de la fonction add_numbers et la stocker dans la variable sig.
• Nous affichons la signature dans la console.

Maintenant, exécutons le script en utilisant la commande python :

python ~/project/my_function.py

Vous devriez voir la sortie suivante :

(x: int, y: int) -> int

Cette sortie représente la signature de la fonction add_numbers. Elle montre que la fonction accepte deux paramètres, x et y, tous deux censés être des entiers, et que la fonction retourne un entier.

Comprendre les signatures de fonction vous aide à utiliser les fonctions correctement et à éviter les erreurs courantes. Dans les étapes suivantes, vous apprendrez plus en détail comment utiliser le module inspect pour extraire des informations précises des signatures de fonction.

Utilisez inspect.signature()

Dans l'étape précédente, vous avez appris à obtenir la signature d'une fonction en utilisant inspect.signature(). Dans cette étape, vous allez approfondir l'utilisation de l'objet signature pour extraire des informations plus détaillées sur les paramètres de la fonction.

La fonction inspect.signature() retourne un objet Signature, qui possède plusieurs attributs et méthodes utiles pour examiner les paramètres de la fonction. Modifions le script my_function.py pour explorer ces fonctionnalités.

Ouvrez le fichier my_function.py dans votre répertoire ~/project en utilisant l'éditeur VS Code et modifiez-le comme suit :

## filename: ~/project/my_function.py
import inspect

def add_numbers(x: int, y: int = 10) -> int:
    """This function adds two numbers and returns the result."""
    return x + y

sig = inspect.signature(add_numbers)

for param in sig.parameters.values():
    print(f"Parameter Name: {param.name}")
    print(f"Parameter Default: {param.default}")
    print(f"Parameter Annotation: {param.annotation}")
    print(f"Parameter Kind: {param.kind}")
    print("-" * 20)

Dans ce script modifié :

• Nous avons ajouté une valeur par défaut de 10 au paramètre y (y: int = 10).
• Nous parcourons l'attribut parameters de l'objet Signature, qui est un dictionnaire ordonné d'objets Parameter.
• Pour chaque objet Parameter, nous affichons ses attributs name, default, annotation et kind.

Maintenant, exécutez le script en utilisant la commande python :

python ~/project/my_function.py

Vous devriez voir la sortie suivante :

Parameter Name: x
Parameter Default: <class 'inspect._empty'>
Parameter Annotation: <class 'int'>
Parameter Kind: POSITIONAL_OR_KEYWORD
--------------------
Parameter Name: y
Parameter Default: 10
Parameter Annotation: <class 'int'>
Parameter Kind: POSITIONAL_OR_KEYWORD
--------------------

Analysons la sortie :

• Nom du paramètre : Le nom du paramètre (x et y).
• Valeur par défaut du paramètre : La valeur par défaut du paramètre. Si un paramètre n'a pas de valeur par défaut, cela sera inspect._empty.
• Annotation du paramètre : L'annotation de type du paramètre (par exemple, <class 'int'>).
• Type de paramètre : Le type de paramètre, qui peut être POSITIONAL_OR_KEYWORD, VAR_POSITIONAL, VAR_KEYWORD, KEYWORD_ONLY ou POSITIONAL_ONLY. Dans ce cas, tant x que y sont POSITIONAL_OR_KEYWORD, ce qui signifie qu'ils peuvent être passés comme arguments positionnels ou nommés.

En utilisant inspect.signature(), vous pouvez mieux comprendre les paramètres d'une fonction et leurs propriétés. Ces informations sont précieuses pour écrire un code qui interagit correctement avec les fonctions et pour documenter efficacement votre code.

Tester le passage d'arguments avec try-except

Dans cette étape, vous apprendrez à utiliser les blocs try-except pour gérer les erreurs potentielles lors du passage d'arguments à une fonction. Cela est particulièrement important lorsqu'il s'agit de traiter des entrées utilisateur ou des données externes, où le type ou le format des données peut ne pas être celui attendu par la fonction.

Modifions le script my_function.py pour inclure la gestion des erreurs à l'aide de try-except. Nous allons essayer d'appeler la fonction add_numbers avec des arguments invalides et capturer l'erreur TypeError qui en résulte.

Ouvrez le fichier my_function.py dans votre répertoire ~/project en utilisant l'éditeur VS Code et modifiez-le comme suit :

## filename: ~/project/my_function.py
import inspect

def add_numbers(x: int, y: int = 10) -> int:
    """This function adds two numbers and returns the result."""
    return x + y

try:
    result = add_numbers("hello", 5)
    print(f"Result: {result}")
except TypeError as e:
    print(f"Error: {e}")

try:
    result = add_numbers(5, "world")
    print(f"Result: {result}")
except TypeError as e:
    print(f"Error: {e}")

try:
    result = add_numbers(5, 5)
    print(f"Result: {result}")
except TypeError as e:
    print(f"Error: {e}")

Dans ce script modifié :

• Nous enveloppons les appels à add_numbers dans des blocs try-except.
• Nous essayons d'appeler add_numbers avec une chaîne de caractères comme premier argument et un entier comme deuxième argument.
• Nous essayons d'appeler add_numbers avec un entier comme premier argument et une chaîne de caractères comme deuxième argument.
• Nous essayons d'appeler add_numbers avec deux entiers comme arguments.
• Si une erreur TypeError se produit (ce qui arrivera lorsque nous passerons une chaîne de caractères au lieu d'un entier), nous capturons l'exception et affichons un message d'erreur.
• Si aucune erreur TypeError ne se produit, nous affichons le résultat de l'appel de la fonction.

Maintenant, exécutez le script en utilisant la commande python :

python ~/project/my_function.py

Vous devriez voir la sortie suivante :

Error: unsupported operand type(s) for +: 'str' and 'int'
Error: unsupported operand type(s) for +: 'int' and 'str'
Result: 10

Cette sortie montre comment les blocs try-except peuvent être utilisés pour gérer gracieusement les erreurs qui se produisent lors du passage d'arguments invalides à une fonction. Les deux premiers appels à add_numbers entraînent des exceptions TypeError, qui sont capturées et gérées par les blocs except. Le troisième appel à add_numbers avec deux entiers s'exécute avec succès, et le résultat est affiché.

L'utilisation de blocs try-except est une bonne pratique pour écrire un code robuste et fiable. Elle vous permet d'anticiper les erreurs potentielles et de les gérer de manière à éviter que votre programme ne plante.

Résumé

Dans ce laboratoire, vous avez appris à connaître les signatures de fonction en Python et en quoi elles fournissent des informations sur les arguments attendus et les valeurs de retour d'une fonction. Comprendre les signatures de fonction est essentiel pour écrire un code propre et maintenable.

Le laboratoire montre comment utiliser le module inspect, plus précisément la fonction inspect.signature(), pour récupérer et examiner la signature d'une fonction Python. Vous avez créé une fonction simple avec des indications de type, puis utilisé inspect.signature() pour afficher la signature de la fonction dans la console, ce qui révèle les types d'arguments attendus et le type de retour.