Python

Guide Complet : Les Fonctions en Python – Exercices Corrigés

Les fonctions en Python sont un élément clé de la programmation modulaire. Elles permettent de diviser un programme en sous-programmes ou blocs de code réutilisables, facilitant ainsi la maintenance et la compréhension du code. Ce guide vous propose un tour d’horizon des fonctions en Python, avec des explications théoriques suivies d’exercices corrigés pour renforcer vos compétences.

1. Qu’est-ce qu’une Fonction ?

Une fonction est un bloc de code qui effectue une tâche spécifique et peut être réutilisé plusieurs fois dans un programme. Les fonctions en Python sont définies à l’aide du mot-clé def suivi du nom de la fonction et des parenthèses ().

Exemple de Fonction

def bonjour():
    print("Bonjour, tout le monde!")

Dans cet exemple, la fonction bonjour affiche simplement un message de salutation.

Appel de la Fonction

Pour exécuter la fonction, il suffit de l’appeler en utilisant son nom suivi des parenthèses :

bonjour()

2. Les Paramètres et les Arguments

Les fonctions peuvent également accepter des paramètres pour effectuer des tâches plus complexes.

Exemple de Fonction avec Paramètres

def saluer(nom):
    print(f"Bonjour, {nom}!")

Ici, la fonction saluer prend un argument nom et l’utilise dans la chaîne de caractères à afficher.

Appel de la Fonction avec un Argument

saluer("Alice")

Cela affichera : Bonjour, Alice!

Paramètres par Défaut

Les fonctions peuvent aussi avoir des paramètres avec des valeurs par défaut.

def saluer(nom="tout le monde"):
    print(f"Bonjour, {nom}!")

Dans ce cas, si aucun argument n’est passé, le message par défaut sera affiché.

3. Les Fonctions avec Valeur de Retour

Une fonction peut également renvoyer une valeur à l’aide du mot-clé return.

Exemple

def ajouter(a, b):
    return a + b

Cette fonction additionne deux nombres et renvoie le résultat.

Appel de la Fonction avec Retour de Valeur

resultat = ajouter(5, 3)
print(resultat)

Cela affichera : 8

4. Les Fonctions Lambda

Les fonctions lambda sont des fonctions anonymes, c’est-à-dire des fonctions sans nom, créées à l’aide du mot-clé lambda.

Exemple

addition = lambda a, b: a + b
print(addition(5, 3))

Cela affichera également : 8

5. Les Fonctions Imbriquées

Python permet aussi de définir des fonctions à l’intérieur d’autres fonctions.

Exemple

def exterieur(x):
    def interieur(y):
        return y + 1
    return interieur(x)

Cette fonction exterieur appelle la fonction interieur définie en son sein.

6. Les Fonctions en tant qu’Arguments

Les fonctions peuvent être passées en tant qu’arguments à d’autres fonctions.

Exemple

def operation(fonction, x, y):
    return fonction(x, y)

def multiplier(a, b):
    return a * b

print(operation(multiplier, 5, 3))

Cela affichera : 15

Exercices Corrigés

Exercice 1 : Créer une fonction qui calcule la somme de deux nombres.

Correction :

def somme(a, b):
    return a + b

# Test de la fonction
print(somme(4, 5))  # Affiche 9

Exercice 2 : Créer une fonction qui renvoie la valeur absolue d’un nombre.

Correction :

def valeur_absolue(x):
    if x < 0:
        return -x
    return x

# Test de la fonction
print(valeur_absolue(-10))  # Affiche 10
print(valeur_absolue(7))    # Affiche 7

Exercice 3 : Créer une fonction qui renvoie le maximum de trois nombres.

Correction :

def maximum(a, b, c):
    if a > b and a > c:
        return a
    elif b > c:
        return b
    else:
        return c

# Test de la fonction
print(maximum(4, 7, 2))  # Affiche 7

Exercice 4 : Créer une fonction qui vérifie si un nombre est premier.

Correction :

def est_premier(n):
    if n <= 1:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

# Test de la fonction
print(est_premier(7))  # Affiche True
print(est_premier(4))  # Affiche False

Exercice 5 : Créer une fonction qui génère la table de multiplication pour un nombre donné.

Correction :

def table_multiplication(n):
    for i in range(1, 11):
        print(f"{n} x {i} = {n * i}")

# Test de la fonction
table_multiplication(5)

Conclusion

Les fonctions sont essentielles pour écrire un code clair, réutilisable et modulaire. Ce guide vous a introduit aux concepts de base et avancés des fonctions en Python, accompagnés d’exercices corrigés pour une meilleure compréhension. N’hésitez pas à créer vos propres exercices pour continuer à vous entraîner.

N’hésitez pas à demander des explications supplémentaires ou d’autres exercices si vous en avez besoin.

Exercices Avancés avec Cas Particuliers

Exercice 1 : Fonction de Division avec Gestion des Erreurs

Objectif : Créer une fonction qui divise deux nombres, avec une gestion particulière des cas où le diviseur est égal à zéro.

Consignes :

La fonction doit prendre deux arguments, a et b.
Si b est égal à zéro, la fonction doit retourner un message d’erreur indiquant que la division par zéro n’est pas possible.
Sinon, elle doit renvoyer le résultat de la division.

Correction :

def division(a, b):
    if b == 0:
        return "Erreur : Division par zéro impossible."
    return a / b

# Test de la fonction
print(division(10, 2))  # Affiche 5.0
print(division(10, 0))  # Affiche "Erreur : Division par zéro impossible."

Exercice 2 : Fonction de Calcul de Racine Carrée avec Vérification des Nombres Négatifs

Objectif : Créer une fonction qui calcule la racine carrée d’un nombre. Si le nombre est négatif, la fonction doit retourner un message indiquant que la racine carrée d’un nombre négatif n’est pas définie dans les nombres réels.

Consignes :

La fonction doit prendre un argument n.
Si n est négatif, la fonction doit retourner un message d’erreur.
Sinon, elle doit retourner la racine carrée de n.

Correction :

import math

def racine_carree(n):
    if n < 0:
        return "Erreur : Racine carrée d'un nombre négatif non définie."
    return math.sqrt(n)

# Test de la fonction
print(racine_carree(9))    # Affiche 3.0
print(racine_carree(-4))   # Affiche "Erreur : Racine carrée d'un nombre négatif non définie."

Exercice 3 : Fonction de Tri avec Cas Particulier d’Entrée Vide

Objectif : Créer une fonction qui trie une liste de nombres. Si la liste est vide, la fonction doit retourner un message spécifique.

Consignes :

La fonction doit prendre une liste comme argument.
Si la liste est vide, la fonction doit retourner un message indiquant que la liste est vide.
Sinon, elle doit retourner la liste triée.

Correction :

def tri_liste(liste):
    if len(liste) == 0:
        return "La liste est vide, rien à trier."
    return sorted(liste)

# Test de la fonction
print(tri_liste([3, 1, 4, 1, 5, 9]))  # Affiche [1, 1, 3, 4, 5, 9]
print(tri_liste([]))                  # Affiche "La liste est vide, rien à trier."

Exercice 4 : Fonction de Calcul de Moyenne avec Gestion des Valeurs Extrêmes

Objectif : Créer une fonction qui calcule la moyenne d’une liste de nombres, en excluant les valeurs extrêmes (la plus petite et la plus grande).

Consignes :

La fonction doit prendre une liste de nombres comme argument.
Si la liste contient moins de trois éléments, la fonction doit retourner un message indiquant qu’il n’y a pas assez de données pour exclure les valeurs extrêmes.
Sinon, la fonction doit calculer la moyenne après avoir retiré la plus petite et la plus grande valeur.

Correction :

def moyenne_sans_extremes(liste):
    if len(liste) < 3:
        return "Pas assez de données pour exclure les valeurs extrêmes."
    liste_sans_extremes = sorted(liste)[1:-1]
    return sum(liste_sans_extremes) / len(liste_sans_extremes)

# Test de la fonction
print(moyenne_sans_extremes([1, 2, 3, 4, 5]))  # Affiche 3.0
print(moyenne_sans_extremes([10, 5]))          # Affiche "Pas assez de données pour exclure les valeurs extrêmes."

Exercice 5 : Fonction d’Analyse de Chaîne de Caractères avec Cas Particulier de Longueur

Objectif : Créer une fonction qui analyse une chaîne de caractères pour déterminer si elle est un palindrome (mot qui se lit de la même manière de gauche à droite et de droite à gauche). Si la chaîne est de longueur 1, la fonction doit indiquer qu’il est impossible de déterminer si c’est un palindrome.

Consignes :

La fonction doit prendre une chaîne de caractères comme argument.
Si la chaîne est de longueur 1, la fonction doit retourner un message indiquant que la vérification est inutile.
Sinon, la fonction doit vérifier si la chaîne est un palindrome et renvoyer le résultat.

Correction :

def est_palindrome(chaine):
    if len(chaine) == 1:
        return "Vérification inutile pour une chaîne d'une seule lettre."
    return chaine == chaine[::-1]

# Test de la fonction
print(est_palindrome("radar"))  # Affiche True
print(est_palindrome("python"))  # Affiche False
print(est_palindrome("a"))       # Affiche "Vérification inutile pour une chaîne d'une seule lettre."

Ces exercices avancés couvrent des cas particuliers que vous pourriez rencontrer lors de la création de fonctions en Python. Ils sont conçus pour vous aider à anticiper et gérer les exceptions, à travailler avec des conditions spécifiques, et à améliorer la robustesse de vos programmes. N’hésitez pas à les adapter à vos besoins ou à les combiner pour créer des exercices encore plus complexes.