Introduction
En Python, une fonction est un bloc de code organisé et réutilisable utilisé pour effectuer une action unique et connexe. Les fonctions offrent une meilleure modularité pour votre application et un haut degré de réutilisation du code.
Dans ce laboratoire, vous apprendrez les fondamentaux de la création et de l'utilisation des fonctions en Python. Vous vous entraînerez à définir des fonctions qui acceptent des arguments, à utiliser des arguments par mot-clé (keyword arguments) pour plus de clarté, à retourner des valeurs, à comprendre la différence entre les portées de variables locales et globales, et à créer des fonctions anonymes concises avec lambda.
Arguments de Fonction
Dans cette étape, vous apprendrez à définir une fonction qui accepte des arguments. Une fonction peut prendre des arguments, qui sont des valeurs que vous lui passez lorsque vous l'appelez.
Note: Si vous n'êtes pas familier avec l'utilisation de WebIDE (similaire à VS Code), veuillez vous familiariser d'abord avec ce lab.
Créons une fonction qui prend un argument name et affiche une salutation personnalisée.
Tout d'abord, ouvrez le fichier arguments.py dans l'explorateur de fichiers à gauche.
Ensuite, copiez et collez le code suivant dans le fichier arguments.py. Ce code définit une fonction say_hello qui prend un argument, name.
## Define a function that takes one argument
def say_hello(name):
print(f'Hello {name}')
## Call the function with a string argument
say_hello('Carlos')
say_hello('Wanda')
say_hello('Rose')
Maintenant, exécutons le script. Ouvrez un terminal dans le WebIDE et exécutez la commande suivante :
python3 arguments.py
Vous devriez voir la fonction être appelée avec différents noms, produisant une salutation unique pour chacun d'eux.
Hello Carlos
Hello Wanda
Hello Rose
Ceci démontre comment les arguments rendent les fonctions flexibles et réutilisables.
Arguments par Mot-Clé (Keyword Arguments)
Dans cette étape, vous apprendrez à utiliser les arguments par mot-clé pour améliorer la lisibilité du code. Lorsqu'une fonction possède plusieurs paramètres, vous pouvez spécifier quel argument correspond à quel paramètre en utilisant le nom du paramètre. C'est ce qu'on appelle un argument par mot-clé (keyword argument).
Lorsque vous utilisez des arguments positionnels, l'ordre dans lequel vous les passez est important. Avec les arguments par mot-clé, l'ordre n'a pas d'importance, ce qui rend votre code plus explicite et plus facile à comprendre.
Ouvrez le fichier keywords.py dans l'explorateur de fichiers. Copiez et collez le code suivant dedans.
## Function with multiple parameters
def say_hi(name, greeting):
print(f"{greeting} {name}")
## Positional arguments: order matters
print("Calling with positional arguments:")
say_hi('John', 'Hello')
## Keyword arguments: order doesn't matter, more readable
print("\nCalling with keyword arguments:")
say_hi(name='Anna', greeting='Hi')
Maintenant, exécutez le script depuis le terminal :
python3 keywords.py
Vous verrez la sortie des deux appels de fonction. Remarquez comment les arguments par mot-clé vous permettent de passer des valeurs dans n'importe quel ordre.
Calling with positional arguments:
Hello John
Calling with keyword arguments:
Hi Anna
Valeurs de Retour
Dans cette étape, vous allez explorer comment utiliser l'instruction return pour qu'une fonction produise une sortie. Alors que print() affiche une valeur dans la console, return renvoie une valeur depuis la fonction. Cette valeur retournée peut être stockée dans une variable ou utilisée dans d'autres expressions.
Créons une fonction qui prend deux nombres, les additionne et retourne le résultat.
Ouvrez le fichier returns.py et ajoutez le code suivant. La fonction sum_two_numbers calcule la somme et utilise le mot-clé return pour renvoyer le résultat.
## Function that returns a value using return statement
def sum_two_numbers(number_1, number_2):
return number_1 + number_2
## Call function and store the returned value
result = sum_two_numbers(7, 8)
print(result)
Exécutez le script dans le terminal :
python3 returns.py
La sortie sera la valeur que la fonction a retournée, qui a été stockée dans la variable result puis affichée.
15
Portée Locale et Globale (Local and Global Scope)
Dans cette étape, vous allez découvrir la différence entre les portées (scopes) des variables locales et globales. La portée d'une variable détermine où dans votre code elle peut être accédée.
- Portée Globale (Global Scope) : Les variables définies en dehors de toute fonction sont dans la portée globale et peuvent être accédées depuis n'importe où dans le code, y compris à l'intérieur des fonctions.
- Portée Locale (Local Scope) : Les variables créées à l'intérieur d'une fonction sont dans la portée locale de cette fonction. Elles n'existent qu'à l'intérieur de cette fonction et ne peuvent pas être accédées depuis l'extérieur.
Voyons d'abord ce qui se passe lorsque vous essayez d'accéder à une variable locale depuis la portée globale. Si vous exécutiez le code suivant, cela provoquerait une erreur NameError car local_variable n'est pas définie dans la portée globale.
## This code will cause an error
global_variable = 'I am available everywhere'
def some_function():
print(global_variable)
local_variable = "only available within this function"
print(local_variable)
## This will raise NameError because local_variable doesn't exist here
## print(local_variable)
L'Instruction global
Si vous avez besoin de modifier une variable globale depuis l'intérieur d'une fonction, vous devez explicitement indiquer à Python que vous le faites avec l'instruction global.
Ouvrez le fichier scope.py et ajoutez le code suivant. Ici, la fonction spam utilise le mot-clé global pour modifier la variable globale eggs.
## Use 'global' keyword to modify global variable from inside function
def spam():
global eggs ## Declare that we're modifying the global variable
eggs = 'spam' ## This changes the global variable
eggs = 'global'
print(f"Before calling spam(), eggs is: {eggs}")
spam() ## Function modifies global variable
print(f"After calling spam(), eggs is: {eggs}")
Maintenant, exécutez le script :
python3 scope.py
Observez la sortie. La valeur de la variable globale eggs est modifiée de manière permanente par l'appel de fonction.
Before calling spam(), eggs is: global
After calling spam(), eggs is: spam
Fonctions Lambda
Dans cette étape, vous apprendrez à créer des fonctions anonymes sur une seule ligne en utilisant le mot-clé lambda. Une fonction lambda peut avoir n'importe quel nombre d'arguments mais ne peut avoir qu'une seule expression. Elles sont utiles pour créer de petites fonctions temporaires sans la surcharge d'une définition de fonction standard avec def.
Par exemple, une fonction normale pour additionner deux nombres :
## Regular function definition
def add(x, y):
return x + y
Ceci est équivalent à la fonction lambda suivante :
## Lambda function: anonymous function defined in one line
add = lambda x, y: x + y
Les lambdas peuvent également fonctionner comme des fermetures lexicales (lexical closures), ce qui signifie qu'elles peuvent "se souvenir" d'une valeur du contexte englobant où elles ont été créées. Créons une fonction qui retourne une lambda.
Ouvrez le fichier lambdas.py et ajoutez le code suivant. La fonction make_adder prend un nombre n et retourne une nouvelle fonction lambda qui ajoute n à n'importe quel nombre x.
## Lambda closure: lambda function that captures a variable from the outer scope
def make_adder(n):
return lambda x: x + n ## Lambda captures 'n' from the outer function
## Create a function that adds 3
plus_3 = make_adder(3)
## Use the new function
result = plus_3(4) ## This will be 4 + 3
print(result)
Exécutez le script depuis votre terminal :
python3 lambdas.py
La sortie montre le résultat de l'appel de la fonction lambda qui a été créée et retournée par make_adder.
7
Vous pouvez également créer d'autres fonctions d'addition, par exemple plus_5 = make_adder(5), ce qui créerait une fonction qui ajoute 5 à son argument.
Résumé
Dans ce laboratoire, vous avez exploré les concepts fondamentaux des fonctions en Python. Vous avez appris à définir des fonctions et à leur transmettre des informations en utilisant des arguments. Vous vous êtes exercé à utiliser à la fois les arguments positionnels et les arguments par mot-clé (keyword arguments) pour rendre vos appels de fonction plus clairs. Vous avez également appris comment faire produire des résultats aux fonctions avec l'instruction return, comment gérer l'accessibilité des variables avec les portées locales et globales, et comment utiliser le mot-clé global pour modifier des variables en dehors d'une fonction. Enfin, vous avez découvert la puissance et la concision des fonctions anonymes lambda pour créer des fonctions simples sur une seule ligne et des fermetures (closures).
