Numérique et Sciences Informatiques1ère

Fonctions et modularité
Exercices corrigés

Maîtrisez les fonctions et la modularité : définition, appel, portée des variables, modules et organisation du code grâce à ces 5 exercices détaillés.

Concepts & Exercices
Fonction = Entrées → Traitement → Sortie
Modèle de base
Définition
def nom_fonction(...):
Appel
nom_fonction(...)
Module
import module
🧩
Exercice 1
Définir une fonction simple
Exercice 2
Appeler une fonction avec paramètres
Exercice 3
Gérer la portée des variables
Exercice 4
Créer un module réutilisable
Exercice 5
Organiser le code en modules
Corrigé : Exercices 1 à 3
1 Définition de fonction
Définition :

Fonction : Bloc de code réutilisable qui effectue une tâche spécifique et peut prendre des paramètres en entrée et retourner une valeur.

Méthode de définition :
  1. Utiliser le mot-clé def suivi du nom de la fonction
  2. Spécifier les paramètres entre parenthèses
  3. Ajouter deux-points pour commencer le bloc
  4. Écrire le corps de la fonction avec indentation
  5. Optionnellement, utiliser return pour renvoyer une valeur
def calculer_surface_rectangle(longueur, largeur): """Calcule la surface d'un rectangle""" surface = longueur * largeur return surface # Appel de la fonction resultat = calculer_surface_rectangle(5, 3) print(f"Surface: {resultat}") # Affiche: Surface: 15
Élément Description Exemple
Nom de la fonction Identifiant unique calculer_surface_rectangle
Paramètres Variables d'entrée longueur, largeur
Instruction return Valeur de sortie return surface
Étape 1 : Déclaration de la fonction

Utiliser def suivi du nom et des paramètres

Étape 2 : Corps de la fonction

Écrire le code avec une indentation appropriée

Étape 3 : Retour de la valeur

Utiliser return pour renvoyer le résultat

Réponse finale :

Fonction définie correctement avec paramètres et valeur de retour

Règles appliquées :

Nom descriptif : Le nom doit indiquer la fonction de la fonction

Indentation : Le corps doit être correctement indenté

Documentation : Ajouter un docstring pour expliquer la fonction

2 Appel de fonction
Définition :

Appel de fonction : Action d'exécuter une fonction en lui fournissant les arguments nécessaires.

def saluer_personne(nom, heure): """Salutation personnalisée selon l'heure""" if heure < 12: salutation = f"Bonjour {nom}" elif heure < 18: salutation = f"Bonsoir {nom}" else: salutation = f"Bonne nuit {nom}" return salutation # Appels de la fonction avec différents arguments message1 = saluer_personne("Alice", 10) message2 = saluer_personne("Bob", 15) message3 = saluer_personne("Charlie", 22) print(message1) # Affiche: Bonjour Alice print(message2) # Affiche: Bonsoir Bob print(message3) # Affiche: Bonne nuit Charlie
Étape 1 : Fournir les arguments

Passer les valeurs correspondant aux paramètres de la fonction

Étape 2 : Exécuter la fonction

Le code de la fonction est exécuté avec les arguments fournis

Étape 3 : Recevoir le résultat

La valeur de retour est affectée à une variable ou utilisée directement

Réponse finale :

Fonction appelée correctement avec différents arguments

Règles appliquées :

Ordre des arguments : Doit correspondre à l'ordre des paramètres

Type des arguments : Doit être compatible avec les paramètres

Nombre d'arguments : Doit correspondre au nombre de paramètres

3 Portée des variables
Définition :

Portée des variables : Région du programme où une variable est accessible (locale ou globale).

# Variable globale compteur_global = 0 def fonction_locale(): """Fonction qui manipule des variables locales""" # Variable locale compteur_local = 5 global compteur_global compteur_global += 1 print(f"Variable locale: {compteur_local}") print(f"Variable globale: {compteur_global}") return compteur_local def fonction_pas_global(): """Fonction qui ne modifie pas la variable globale""" # Cette variable est locale, elle masque la globale compteur_global = 10 print(f"Dans fonction_pas_global: {compteur_global}") # Appel des fonctions resultat = fonction_locale() print(f"Retour de la fonction: {resultat}") fonction_pas_global() print(f"Variable globale finale: {compteur_global}")
Type de variable Portée Accessibilité
Locale À l'intérieur de la fonction Seulement dans la fonction
Globale Dans tout le programme Partout (avec mot-clé global)
Paramètre À l'intérieur de la fonction Seulement dans la fonction
Étape 1 : Comprendre la portée

Les variables locales ne sont accessibles qu'à l'intérieur de leur fonction

Étape 2 : Manipuler les variables globales

Utiliser le mot-clé global pour modifier une variable globale

Étape 3 : Éviter les conflits

Utiliser des noms distincts pour éviter la confusion entre variables locales et globales

Réponse finale :

Compréhension de la portée des variables locale et globale

Règles appliquées :

Variables locales : Accessibles uniquement dans la fonction

Variables globales : Accessibles partout, modifiables avec global

Préférer les locales : Moins de risques de conflits

Corrigé : Exercices 4 à 5
4 Création de module
Définition :

Module : Fichier contenant des définitions de fonctions, classes et variables pouvant être importées dans d'autres programmes.

# fichier: maths_utils.py def calculer_moyenne(liste): """Calcule la moyenne d'une liste de nombres""" if not liste: return 0 return sum(liste) / len(liste) def est_premier(nombre): """Vérifie si un nombre est premier""" if nombre < 2: return False for i in range(2, int(nombre ** 0.5) + 1): if nombre % i == 0: return False return True def trier_liste(liste, ordre="croissant"): """Trie une liste dans l'ordre spécifié""" if ordre == "croissant": return sorted(liste) elif ordre == "decroissant": return sorted(liste, reverse=True) else: raise ValueError("L'ordre doit être 'croissant' ou 'decroissant'") # Utilisation du module dans un autre fichier # import maths_utils # moyenne = maths_utils.calculer_moyenne([10, 15, 20]) # premier = maths_utils.est_premier(17) # triee = maths_utils.trier_liste([5, 2, 8, 1], "decroissant")
Étape 1 : Créer le module

Écrire les fonctions dans un fichier avec extension .py

Étape 2 : Importer le module

Utiliser import pour accéder aux fonctions

Étape 3 : Utiliser les fonctions

Appeler les fonctions en utilisant le préfixe du module

Réponse finale :

Module créé avec fonctions réutilisables

Règles appliquées :

Organisation : Regrouper les fonctions par thème

Documentation : Ajouter des docstrings pour chaque fonction

Nommage : Utiliser des noms de fichiers descriptifs

5 Organisation en modules
Définition :

Modularité : Principe de diviser un programme en modules distincts pour améliorer la lisibilité et la réutilisabilité.

# fichier: gestion_utilisateurs.py class Utilisateur: def __init__(self, nom, email): self.nom = nom self.email = email self.actif = True def desactiver(self): self.actif = False def __str__(self): statut = "actif" if self.actif else "inactif" return f"Utilisateur: {self.nom} ({self.email}) - {statut}" def charger_utilisateurs(fichier): """Charge les utilisateurs depuis un fichier""" utilisateurs = [] with open(fichier, 'r') as f: for ligne in f: nom, email = ligne.strip().split(',') utilisateurs.append(Utilisateur(nom, email)) return utilisateurs def sauvegarder_utilisateurs(utilisateurs, fichier): """Sauvegarde les utilisateurs dans un fichier""" with open(fichier, 'w') as f: for utilisateur in utilisateurs: f.write(f"{utilisateur.nom},{utilisateur.email}\n") # fichier: main.py from gestion_utilisateurs import Utilisateur, charger_utilisateurs, sauvegarder_utilisateurs # Création d'utilisateurs user1 = Utilisateur("Alice", "alice@example.com") user2 = Utilisateur("Bob", "bob@example.com") # Désactivation d'un utilisateur user2.desactiver() # Sauvegarde sauvegarder_utilisateurs([user1, user2], "utilisateurs.txt") # Chargement utilisateurs = charger_utilisateurs("utilisateurs.txt") for u in utilisateurs: print(u)
Étape 1 : Identifier les responsabilités

Regrouper les fonctions et classes par fonctionnalité

Étape 2 : Créer des modules

Diviser le code en fichiers selon les responsabilités

Étape 3 : Importer et utiliser

Utiliser import pour accéder aux modules

Réponse finale :

Code organisé en modules avec responsabilités clairement définies

Règles appliquées :

Séparation des responsabilités : Chaque module a un but précis

Encapsulation : Masquer les détails d'implémentation

Réutilisabilité : Les modules peuvent être réutilisés dans d'autres projets

Cours bien détaillé
Module → Fonction → Réutilisation
Chaîne de modularité
🎯
Fonction : Bloc de code réutilisable effectuant une tâche spécifique.
📏
Module : Fichier contenant des définitions pouvant être importées.
📐
Portée : Région du programme où une variable est accessible.
📝
Modularité : Principe de division du code en unités indépendantes.
💡
Conseil : Créer des fonctions courtes et avec une seule responsabilité
🔍
Attention : Éviter d'utiliser trop de variables globales
Astuce : Documenter les fonctions avec des docstrings
📋
Méthode : Regrouper les fonctions apparentées dans des modules
Vérification : Tester les fonctions individuellement
Principes de modularité :
  • Cohésion : Chaque module devrait avoir une seule responsabilité
  • Couplage : Les modules devraient être faiblement couplés entre eux
  • Réutilisabilité : Les modules devraient être réutilisables dans d'autres contextes
  • Lisibilité : Le code devrait être facile à comprendre
  • Maintenance : Les modules devraient être faciles à modifier
Avantages de la modularité :
  • Réduction de la complexité du code
  • Amélioration de la lisibilité et de la maintenance
  • Facilité de test et de débogage
  • Réutilisation du code dans d'autres projets
  • Collaboration facilitée entre développeurs
Fonction
Bloc de code réutilisable
Module
Fichier de définitions
Portée
Accès aux variables
Fonctions et modularité Structure du code