Sous-programmes et fonctions | Exercices corrigés

Concepts & Exercices

\(\text{f}(x) = \text{résultat}\)

Fonction mathématique

Définition

def nom():

Création

Appel

nom()

Utilisation

Retour

return

Résultat

🔄

Réutilisation : Permet de réutiliser le même code plusieurs fois.

🧩

Modularité : Divise un programme en parties plus petites et gérables.

🎯

Abstraction : Cache la complexité pour se concentrer sur l'interface.

Exercice 1

Définir et appeler une fonction simple sans paramètres

Exercice 2

Créer une fonction avec des paramètres

Exercice 3

Utiliser return pour renvoyer un résultat

Exercice 4

Imbriquer des appels de fonctions

Exercice 5

Gérer la portée des variables dans les fonctions

Corrigé : Exercices 1 à 3

1 Fonction simple

Définition :

Fonction sans paramètre : Bloc de code nommé qui exécute une tâche spécifique sans recevoir d'arguments.

Méthode de définition :

Utiliser le mot-clé def
Donner un nom à la fonction
Ajouter (): après le nom
Indenter le corps de la fonction
Appeler la fonction avec nom()

                def salutation():
                    print("Bonjour !")
                    print("Bienvenue dans le programme")
                
                def afficher_menu():
                    print("=== MENU ===")
                    print("1. Option 1")
                    print("2. Option 2")
                    print("3. Quitter")
                    print("============")
                
                # Appel des fonctions
                salutation()
                afficher_menu()
              

┌─────────────────┐
│ Appel salutation() │
│ ↓ │
│ ┌─────────────┐ │
│ │print("Bonjour!")│
│ │print("Bienvenue")│
│ └─────────────┘ │
│ ↓ │
│ Retour au programme │
└─────────────────┘

Étape 1 : Définition de la fonction

Utilisation de def salutation(): pour créer la fonction

Étape 2 : Corps de la fonction

Instructions indentées exécutées quand la fonction est appelée

Étape 3 : Appel de la fonction

salutation() exécute le bloc de code défini

Résultat :

Les instructions dans la fonction sont exécutées quand elle est appelée

Règles appliquées :

• Indentation : Le corps de la fonction doit être indenté

• Nommage : Utiliser des noms descriptifs pour les fonctions

• Appel : Une fonction n'est exécutée que lorsqu'elle est appelée

2 Fonction avec paramètres

Définition :

Fonction avec paramètres : Fonction qui reçoit des valeurs (arguments) lors de son appel pour personnaliser son comportement.

Concept Définition Exemple Paramètre Variable dans la définition de la fonction def f(x): Argument Valeur réelle passée lors de l'appel f(5)

                def afficher_personne(nom, age):
                    print(f"Nom: {nom}")
                    print(f"Âge: {age}")
                    print("-" * 15)
                
                def calculer_surface(longueur, largeur):
                    surface = longueur * largeur
                    print(f"Surface: {surface} m²")
                
                # Appels avec arguments
                afficher_personne("Alice", 25)
                afficher_personne("Bob", 30)
                calculer_surface(5, 3)
              

┌─────────────────────────────────┐
│ Appel afficher_personne("Alice", 25) │
│ ↓ │
│ ┌─────────────────────────────┐ │
│ │nom = "Alice", age = 25 │ │
│ │print(f"Nom: {nom}") │ │
│ │print(f"Âge: {age}") │ │
│ └─────────────────────────────┘ │
│ ↓ │
│ Retour au programme │
└─────────────────────────────────┘

Étape 1 : Définir les paramètres

Entre parenthèses dans la définition de la fonction

Étape 2 : Utiliser les paramètres

Les paramètres agissent comme des variables locales dans la fonction

Étape 3 : Passer les arguments

Les valeurs sont transmises lors de l'appel de la fonction

Résultat :

Les paramètres reçoivent les valeurs des arguments et sont utilisés dans la fonction

Règles appliquées :

• Ordre : Les arguments correspondent aux paramètres dans l'ordre

• Nombre : Le nombre d'arguments doit correspondre au nombre de paramètres

• Utilisation : Les paramètres sont accessibles comme des variables locales

3 Renvoi de valeur

Définition :

Return : Instruction qui termine l'exécution d'une fonction et renvoie une valeur au code appelant.

                def carre(nombre):
                    resultat = nombre ** 2
                    return resultat  # Renvoie la valeur
                
                def maximum(a, b):
                    if a > b:
                        return a
                    else:
                        return b
                
                def est_pair(nombre):
                    return nombre % 2 == 0  # Renvoie True ou False
                
                # Utilisation des valeurs retournées
                resultat_carre = carre(5)  # resultat_carre = 25
                plus_grand = maximum(10, 7)  # plus_grand = 10
                est_paire = est_pair(8)  # est_paire = True
                
                print(f"Le carré de 5 est {resultat_carre}")
                print(f"Le maximum entre 10 et 7 est {plus_grand}")
                print(f"8 est pair: {est_paire}")
              

┌─────────────────┐
│ Appel carre(5) │
│ ↓ │
│ ┌─────────────┐ │
│ │nombre = 5 │ │
│ │resultat = 25│ │
│ │return resultat│ │
│ └─────────────┘ │
│ ↓ │
│ Valeur 25 retournée │
│ affectée à variable │
└─────────────────┘

Étape 1 : Calculer le résultat

Effectuer les opérations nécessaires dans la fonction

Étape 2 : Renvoyer la valeur

Utiliser return pour envoyer la valeur au code appelant

Étape 3 : Utiliser la valeur retournée

La valeur peut être affectée à une variable ou utilisée dans une expression

Résultat :

La fonction renvoie une valeur qui peut être utilisée ailleurs dans le programme

Règles appliquées :

• Exécution : return termine immédiatement l'exécution de la fonction

• Valeur : Ce qui suit return est la valeur renvoyée

• Utilisation : La valeur retournée peut être affectée ou utilisée dans une expression

Corrigé : Exercices 4 à 5

4 Imbrication de fonctions

Définition :

Imbrication de fonctions : Situation où une fonction appelle une autre fonction, créant une hiérarchie d'appels.

                def aire_rectangle(longueur, largeur):
                    return longueur * largeur
                
                def aire_triangle(base, hauteur):
                    aire_rect = aire_rectangle(base, hauteur)  # Appel d'une autre fonction
                    return aire_rect / 2
                
                def aire_cercle(rayon):
                    import math
                    return math.pi * rayon ** 2
                
                def aire_figure_composee(rect_l, rect_h, tri_b, tri_h, cer_r):
                    aire_totale = 0
                    aire_totale += aire_rectangle(rect_l, rect_h)
                    aire_totale += aire_triangle(tri_b, tri_h)
                    aire_totale += aire_cercle(cer_r)
                    return aire_totale
                
                # Utilisation
                resultat = aire_figure_composee(5, 3, 4, 6, 2)
                print(f"Aire totale: {resultat}")
              

Appel Paramètres Valeur retournée aire_figure_composee(5, 3, 4, 6, 2) rect_l=5, rect_h=3, etc. ? → aire_rectangle(5, 3) longueur=5, largeur=3 15 → aire_triangle(4, 6) base=4, hauteur=6 12 → aire_cercle(2) rayon=2 ≈12.57 Total ≈39.57

Étape 1 : Analyser la structure

Chaque fonction effectue une tâche spécifique et peut appeler d'autres fonctions

Étape 2 : Comprendre la hiérarchie

Une fonction peut utiliser les résultats d'autres fonctions pour accomplir sa tâche

Étape 3 : Suivre la chaîne d'appels

Chaque appel de fonction est résolu avant de continuer dans la fonction appelante

Résultat :

Les fonctions peuvent s'appeler mutuellement pour construire des solutions complexes

Règles appliquées :

• Modularité : Chaque fonction a une responsabilité claire

• Hiérarchie : Les fonctions de haut niveau utilisent celles de bas niveau

• Composabilité : Les fonctions peuvent être combinées pour des tâches complexes

5 Portée des variables

Définition :

Portée des variables : Règles qui déterminent où une variable est accessible dans le programme.

                variable_globale = "Je suis globale"
                
                def fonction_externe():
                    variable_locale = "Je suis locale à fonction_externe"
                    
                    def fonction_interne():
                        variable_locale_interne = "Je suis locale à fonction_interne"
                        print(f"Depuis fonction_interne: {variable_globale}")  # Accès global
                        print(f"Depuis fonction_interne: {variable_locale}")  # Accès enclosing
                        print(f"Locale à fonction_interne: {variable_locale_interne}")  # Accès local
                    
                    fonction_interne()
                    print(f"Depuis fonction_externe: {variable_locale}")
                    # print(variable_locale_interne)  # Erreur! Variable non accessible
                
                def modifier_globale():
                    global variable_globale  # Autorise la modification de la variable globale
                    variable_globale = "J'ai été modifiée"
                
                fonction_externe()
                print(f"Variable globale: {variable_globale}")
                modifier_globale()
                print(f"Variable globale modifiée: {variable_globale}")
              

Portée Niveau Accès Exemple Locale (L) Fonction courante Accès direct dans_fonction = 5 Enclosing (E) Fonction englobante Accès en lecture fonction_externe() Global (G) Module entier Accès avec mot-clé global var Built-in (B) Python intégré Accès automatique print(), len()

Étape 1 : Comprendre la règle LEGB

Python cherche les variables dans l'ordre : Local → Enclosing → Global → Built-in

Étape 2 : Variables locales

Ne sont accessibles que dans la fonction où elles sont définies

Étape 3 : Variables globales

Accessibles partout, mais modifiables seulement avec le mot-clé global

Résultat :

La portée détermine où les variables sont accessibles et modifiables

Règles appliquées :

• Local : Les variables locales ne sont pas accessibles en dehors de leur fonction

• Global : Nécessite global pour modification

• Enclosing : Les fonctions internes peuvent lire les variables externes

Sous-programmes et fonctionsExercices corrigés

Sous-programmes et fonctions
Exercices corrigés