Définir et Utiliser des Fonctions en Python

Introduction

Dans ce laboratoire, vous apprendrez à définir et à utiliser des fonctions en Python. Les fonctions sont essentielles pour organiser le code et favoriser la réutilisabilité. Vous commencerez par comprendre le concept de fonctions et explorerez les fonctions intégrées (built-in functions) de Python, apprenant comment les appeler avec des paramètres et observer leur sortie.

Après l'exploration des fonctions intégrées, vous apprendrez à définir vos propres fonctions simples. Enfin, vous vous entraînerez à appeler ces fonctions définies par l'utilisateur pour exécuter les blocs de code qu'elles contiennent, consolidant ainsi votre compréhension de la création et de l'utilisation des fonctions en Python.

Comprendre et Utiliser les Fonctions Intégrées

Dans cette étape, nous allons explorer le concept de fonctions et apprendre à utiliser les fonctions intégrées de Python. Une fonction est un bloc de code réutilisable qui exécute une action spécifique. Python fournit de nombreuses fonctions intégrées prêtes à l'emploi, telles que print(), len() et sum().

Commençons par écrire un script Python pour observer quelques-unes de ces fonctions en action.

Tout d'abord, trouvez le fichier builtin_functions.py dans l'explorateur de fichiers du WebIDE sur la gauche. Ce fichier a été pré-créé pour vous dans le répertoire ~/project. Double-cliquez sur le fichier pour l'ouvrir dans l'éditeur.

Maintenant, ajoutez le code Python suivant au fichier builtin_functions.py. Ce code montre comment appeler plusieurs fonctions intégrées.

## Utilisation de la fonction print() pour afficher la sortie
print("Hello, Python Functions!")

## Utilisation de la fonction len() pour obtenir la longueur d'une chaîne de caractères
message = "Hello World"
print(len(message))

## Utilisation de la fonction sum() pour additionner les nombres dans une liste
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total)

Après avoir écrit le code, enregistrez le fichier en appuyant sur Ctrl+S.

Pour exécuter le script, ouvrez le terminal intégré dans le WebIDE (s'il n'est pas déjà ouvert, allez dans le menu supérieur et sélectionnez Terminal > New Terminal). Ensuite, exécutez la commande suivante :

python ~/project/builtin_functions.py

Vous verrez la sortie de chaque appel print() dans le terminal.

Hello, Python Functions!
11
15

Cette sortie montre les résultats de l'appel des fonctions intégrées : print() affiche du texte, len() retourne le nombre de caractères dans une chaîne, et sum() calcule la somme des éléments d'une liste.

Utiliser des Fonctions avec Paramètres et Valeurs de Retour

Les fonctions ont souvent besoin de données d'entrée pour fonctionner. Ces données sont passées à la fonction sous forme de paramètres (aussi appelés arguments). Après traitement, une fonction peut renvoyer un résultat, ce que l'on appelle la valeur de retour (return value).

Étendons notre script builtin_functions.py pour explorer les fonctions qui acceptent des paramètres et voyons comment nous pouvons utiliser leurs valeurs de retour.

Ouvrez à nouveau le fichier builtin_functions.py dans l'éditeur du WebIDE. Ajoutez le code suivant à la fin du fichier :

## Utilisation de la fonction max() avec plusieurs paramètres numériques
largest_number = max(10, 25, 15)
print(largest_number)

## Utilisation de la fonction round() avec deux paramètres
pi_approx = 3.14159
rounded_pi = round(pi_approx, 2) ## arrondir à 2 décimales
print(rounded_pi)

## Utilisation de la fonction sorted() avec un paramètre de liste
unsorted_list = ['cherry', 'apple', 'banana']
sorted_list = sorted(unsorted_list)
print(sorted_list)

Enregistrez les modifications du fichier (Ctrl+S).

Exécutez maintenant le script mis à jour depuis le terminal :

python ~/project/builtin_functions.py

Le terminal affichera la sortie du code original et du nouveau code.

Hello, Python Functions!
11
15
25
3.14
['apple', 'banana', 'cherry']

Examinons la nouvelle sortie :

• max(10, 25, 15) prend trois nombres comme paramètres et retourne le plus grand, 25.
• round(pi_approx, 2) prend un nombre et le nombre de décimales comme paramètres. Il retourne la valeur arrondie, 3.14.
• sorted(unsorted_list) prend une liste comme paramètre et retourne une nouvelle liste avec les éléments triés par ordre croissant.

Dans chaque cas, nous avons stocké la valeur de retour de la fonction dans une variable (largest_number, rounded_pi, sorted_list) avant de l'afficher. C'est une pratique courante et utile.

Définir une Fonction Simple

Bien que les fonctions intégrées soient puissantes, vous aurez souvent besoin de créer vos propres fonctions pour effectuer des tâches personnalisées. C'est ce qu'on appelle définir une fonction.

En Python, vous définissez une fonction en utilisant le mot-clé def. La syntaxe de base est la suivante :

def function_name(parameters):
    """Docstring: Une description optionnelle de la fonction."""
    ## Code à exécuter (le corps de la fonction)
    ## ...
    return value  ## Instruction de retour optionnelle

• def: Le mot-clé qui commence une définition de fonction.
• function_name: Un nom descriptif pour votre fonction.
• (parameters): Les variables d'entrée pour la fonction. Une fonction peut avoir zéro paramètre ou plus.
• :: Les deux-points marquent la fin de l'en-tête de la fonction.
• Indentation: Les lignes de code à l'intérieur de la fonction doivent être indentées (généralement avec 4 espaces). C'est ainsi que Python regroupe les instructions.

Créons notre première fonction. Dans l'explorateur de fichiers du WebIDE, trouvez et ouvrez le fichier my_functions.py.

Ajoutez le code suivant à my_functions.py pour définir une fonction qui affiche un message de salutation :

## Définir une fonction simple nommée 'greet'
def greet():
    """Cette fonction affiche un message de salutation simple."""
    print("Hello from a user-defined function!")

Enregistrez le fichier.

À ce stade, vous avez réussi à définir une fonction nommée greet. Cependant, si vous exécutez ce script, rien ne se passera. Définir une fonction indique simplement à Python ce que fait la fonction ; cela n'exécute pas réellement le code qu'elle contient. Pour exécuter le code de la fonction, vous devez l'appeler (la "call"), ce que nous aborderons à l'étape suivante.

Appeler une Fonction Définie par l'Utilisateur

Après avoir défini une fonction, vous devez l'appeler (call) pour exécuter son code. Appeler une fonction est simple : il suffit de taper son nom suivi de parenthèses ().

Appelons la fonction greet que nous avons définie à l'étape précédente.

Ouvrez le fichier my_functions.py dans l'éditeur du WebIDE. Ajoutez une ligne de code après la définition de la fonction pour l'appeler.

## Définir une fonction simple nommée 'greet'
def greet():
    """Cette fonction affiche un message de salutation simple."""
    print("Hello from a user-defined function!")

## Appeler la fonction greet pour exécuter son code
print("Calling the function now...")
greet()

Enregistrez le fichier. Il est important que l'appel de fonction greet() apparaisse après le bloc def greet():. Python lit les fichiers de haut en bas, vous devez donc définir une fonction avant de pouvoir l'appeler.

Exécutez maintenant le script depuis le terminal :

python ~/project/my_functions.py

Vous verrez la sortie s'afficher dans la console :

Calling the function now...
Hello from a user-defined function!

Le grand avantage des fonctions est leur réutilisabilité. Vous pouvez appeler la même fonction plusieurs fois sans réécrire son code. Appelons greet() à nouveau. Modifiez my_functions.py pour qu'il ressemble à ceci :

## Définir une fonction simple nommée 'greet'
def greet():
    """Cette fonction affiche un message de salutation simple."""
    print("Hello from a user-defined function!")

## Appeler la fonction greet plusieurs fois
print("Calling the function...")
greet()
print("Calling it again...")
greet()

Enregistrez le fichier et exécutez-le une fois de plus :

python ~/project/my_functions.py

La sortie montre maintenant que la fonction a été exécutée deux fois :

Calling the function...
Hello from a user-defined function!
Calling it again...
Hello from a user-defined function!

Ceci démontre comment les fonctions vous aident à écrire un code plus propre, mieux organisé et réutilisable.

Résumé

Dans ce laboratoire, vous avez appris les fondamentaux des fonctions en Python. Vous avez commencé par explorer les fonctions intégrées (built-in functions) de Python, telles que print(), len(), et sum(), et vous vous êtes exercé à les appeler dans un script. Vous avez ensuite approfondi le fonctionnement des fonctions en passant des paramètres et en utilisant leurs valeurs de retour avec des exemples comme max(), round(), et sorted().

Enfin, vous avez appris la syntaxe pour définir vos propres fonctions personnalisées en utilisant le mot-clé def et vous vous êtes exercé à appeler votre fonction définie par l'utilisateur pour exécuter son code. Ce laboratoire vous a fourni une base solide pour créer du code modulaire et réutilisable, une compétence clé pour tout programmeur Python.