Ce chapitre vous enseignera à créer des fonctions robustes et réutilisables pour organiser votre code Python. Vous maîtriserez les paramètres, les valeurs de retour, la portée des variables et les bonnes pratiques. Ces concepts essentiels vous permettront d'écrire du code modulaire, maintenable et efficace.
Les fonctions sont des blocs de code réutilisables qui effectuent une tâche spécifique. Elles permettent de structurer un programme en le divisant en parties plus petites et plus gérables.
Une fonction est un bloc de code nommé qui effectue une opération spécifique. Elle peut prendre des données en entrée (paramètres), les traiter, et retourner un résultat.
# Définition d'une fonction simple def salutation(): print("Bonjour !") # Appel de la fonction salutation() # Affiche "Bonjour !"
Les fonctions offrent plusieurs avantages : réutilisabilité du code, modularité, lisibilité et facilité de maintenance.
# Sans fonction - code répétitif print("=== Rapport de vente ===") print("Chiffre d'affaires: 15000€") print("========================") print("=== Rapport de stock ===") print("Articles en stock: 45") print("========================") # Avec fonction - code réutilisable def afficher_rapport(titre, contenu): print(f"=== {titre} ===") print(contenu) print("========================") # Appels de la fonction afficher_rapport("Rapport de vente", "Chiffre d'affaires: 15000€") afficher_rapport("Rapport de stock", "Articles en stock: 45")
La définition d'une fonction en Python commence par le mot-clé def, suivi du nom de la fonction et de parenthèses.
# Syntaxe de base d'une fonction def nom_de_la_fonction(parametre1, parametre2): """Docstring (documentation de la fonction)""" # Corps de la fonction resultat = parametre1 + parametre2 return resultat # Retourne un résultat (optionnel) # Exemple concret def calculer_moyenne(a, b): """Calcule la moyenne de deux nombres.""" moyenne = (a + b) / 2 return moyenne # Utilisation moyenne_resultat = calculer_moyenne(10, 20) print(f"La moyenne est: {moyenne_resultat}") # Affiche "La moyenne est: 15.0"
En Python, les fonctions sont définies avec le mot-clé def et peuvent être appelées (exécutées) à tout moment dans le code une fois définies.
Le mot-clé def est utilisé pour définir une fonction en Python. Il est suivi du nom de la fonction et de parenthèses contenant les paramètres.
# Syntaxe de base avec le mot-clé def def ma_fonction(): # Corps de la fonction print("Cette fonction a été définie avec def") # Définition avec paramètres def addition(a, b): resultat = a + b print(f"La somme de {a} et {b} est {resultat}") # Définition avec valeur de retour def multiplication(x, y): return x * y
Une fonction Python typique comprend : le mot-clé def, le nom de la fonction, des paramètres, une docstring, un corps de fonction, et éventuellement une instruction return.
def calculer_tva(prix_ht, taux_tva=20.0): """ Calcule le montant de la TVA et le prix TTC. Args: prix_ht (float): Prix hors taxes taux_tva (float): Taux de TVA en pourcentage (défaut: 20.0) Returns: tuple: (montant_tva, prix_ttc) """ # Corps de la fonction montant_tva = prix_ht * (taux_tva / 100) prix_ttc = prix_ht + montant_tva # Retour des résultats return montant_tva, prix_ttc # Exemple de fonction sans paramètres ni retour def afficher_bienvenue(): """Affiche un message de bienvenue.""" print("Bienvenue dans notre application !") print("Nous sommes heureux de vous accueillir.")
Pour exécuter une fonction, il suffit de l'appeler par son nom suivi de parenthèses. Si la fonction a des paramètres, on les passe entre les parenthèses.
# Définition de quelques fonctions def dire_bonjour(): print("Bonjour !") def calculer_carre(n): return n * n def afficher_infos(nom, age): print(f"Nom: {nom}, Âge: {age} ans") # Appels de fonctions dire_bonjour() # Appel sans paramètres resultat = calculer_carre(5) # Appel avec un paramètre et récupération du résultat print(f"Le carré de 5 est {resultat}") afficher_infos("Alice", 25) # Appel avec plusieurs paramètres # Appels multiples for i in range(3): dire_bonjour() # Appel dans une expression total = calculer_carre(3) + calculer_carre(4) print(f"3² + 4² = {total}")
L'instruction return termine l'exécution d'une fonction et renvoie une valeur au code appelant. Une fonction sans return renvoie None.
# Fonction avec return simple def obtenir_nom(): return "Pierre" # Fonction avec return conditionnel def est_majeur(age): if age >= 18: return True else: return False # Fonction avec multiple return def calculer_stats(nombres): if not nombres: # Si la liste est vide return 0, 0, 0 # Retour multiple moyenne = sum(nombres) / len(nombres) minimum = min(nombres) maximum = max(nombres) return moyenne, minimum, maximum # Fonction sans return (retourne None) def afficher_message(message): print(message) # Pas de return -> retourne None # Utilisation des fonctions avec return nom = obtenir_nom() print(f"Nom: {nom}") majeur = est_majeur(20) print(f"Est majeur: {majeur}") stats = calculer_stats([10, 20, 30, 40, 50]) moyenne, min_val, max_val = stats # Déballage du tuple print(f"Moyenne: {moyenne}, Min: {min_val}, Max: {max_val}") resultat = afficher_message("Hello!") print(f"Valeur retournée: {resultat}") # Affiche "Valeur retournée: None"
Les paramètres sont les variables définies dans la déclaration d'une fonction, tandis que les arguments sont les valeurs réelles passées à la fonction lors de son appel.
Les paramètres obligatoires doivent être fournis lors de l'appel de la fonction, dans l'ordre de leur définition.
# Fonction avec paramètres obligatoires def afficher_personne(nom, age, ville): print(f"Nom: {nom}, Âge: {age}, Ville: {ville}") # Appel correct - tous les paramètres obligatoires sont fournis afficher_personne("Alice", 25, "Paris") # Erreur: paramètre manquant # afficher_personne("Bob", 30) # TypeError: missing 1 required positional argument # Erreur: trop d'arguments # afficher_personne("Charlie", 35, "Lyon", "France") # TypeError: too many arguments # Fonction avec calcul utilisant les paramètres def calculer_prix_ttc(prix_ht, taux_tva): tva = prix_ht * (taux_tva / 100) prix_ttc = prix_ht + tva return prix_ttc # Utilisation prix_final = calculer_prix_ttc(100, 20) # 120.0 print(f"Prix TTC: {prix_final}€")
Les paramètres peuvent avoir des valeurs par défaut, rendant leur fourniture optionnelle lors de l'appel.
# Fonction avec paramètres par défaut def salutation(nom, message="Bonjour"): print(f"{message} {nom}!") # Appels possibles salutation("Alice") # Utilise la valeur par défaut: "Bonjour Alice!" salutation("Bob", "Bonsoir") # "Bonsoir Bob!" # Fonction avec plusieurs paramètres par défaut def creer_utilisateur(nom, email, actif=True, admin=False): print(f"Utilisateur créé: {nom}, {email}") print(f"Actif: {actif}, Admin: {admin}") # Différentes façons d'appeler la fonction creer_utilisateur("Alice", "alice@email.com") creer_utilisateur("Bob", "bob@email.com", False) creer_utilisateur("Charlie", "charlie@email.com", True, True) # Attention: les paramètres avec valeur par défaut doivent # venir après les paramètres obligatoires # Ceci est VALIDE: def fonction_valide(a, b, c=10): pass # Ceci est INVALIDE (SyntaxError): # def fonction_invalide(a=10, b, c): # pass
Les arguments peuvent être passés en utilisant leur nom, ce qui permet de les spécifier dans n'importe quel ordre.
# Fonction avec plusieurs paramètres def decrire_animal(nom, espece, age, couleur): print(f"{nom} est un {espece} de {age} ans, de couleur {couleur}.") # Appel avec arguments positionnels (dans l'ordre) decrire_animal("Rex", "chien", 5, "marron") # Appel avec arguments nommés (dans n'importe quel ordre) decrire_animal(nom="Félix", espece="chat", couleur="noir", age=3) decrire_animal(espece="poisson", couleur="orange", nom="Nemo", age=1) # Mixte: arguments positionnels puis nommés decrire_animal("Medor", "chien", couleur="blanc", age=4) # INVALIDE: arguments nommés puis positionnels # decrire_animal(nom="Rex", "chien", age=5, "marron") # SyntaxError # Fonction pratique avec paramètres nommés def formater_date(jour, mois, annee, separateur="/"): return f"{jour:02d}{separateur}{mois:02d}{separateur}{annee}" # Utilisation flexible date1 = formater_date(15, 8, 2023) # "15/08/2023" date2 = formater_date(15, 8, 2023, separateur="-") # "15-08-2023" date3 = formater_date(jour=1, mois=12, annee=2023, separateur=".") # "01.12.2023"
Python suit des règles spécifiques pour l'ordre des paramètres : obligatoires d'abord, puis par défaut, et enfin les paramètres spéciaux.
# Ordre correct des paramètres def fonction_correcte(a, b, c=10, d=20): print(f"a={a}, b={b}, c={c}, d={d}") # Appels valides fonction_correcte(1, 2) # a=1, b=2, c=10, d=20 fonction_correcte(1, 2, 3) # a=1, b=2, c=3, d=20 fonction_correcte(1, 2, 3, 4) # a=1, b=2, c=3, d=4 fonction_correcte(1, 2, d=40) # a=1, b=2, c=10, d=40 # Ordre incorrect (provoque une SyntaxError) # def fonction_incorrecte(a=10, b, c=20): # pass # Bonne pratique: ordre logique des paramètres def enregistrer_utilisateur(nom, prenom, email, actif=True, admin=False): """ Enregistre un nouvel utilisateur. Args: nom (str): Nom de famille prenom (str): Prénom email (str): Adresse email actif (bool): Statut actif (défaut: True) admin (bool): Statut administrateur (défaut: False) """ print(f"Utilisateur {prenom} {nom} enregistré avec email {email}") print(f"Statut: {'Actif' if actif else 'Inactif'}, Admin: {admin}") # Appels avec différents ordres d'arguments enregistrer_utilisateur("Dupont", "Jean", "jean.dupont@email.com") enregistrer_utilisateur("Martin", "Marie", "marie.martin@email.com", admin=True) enregistrer_utilisateur( email="pierre.durand@email.com", nom="Durand", prenom="Pierre", actif=False ) # Règle générale: # 1. Paramètres obligatoires (sans valeur par défaut) # 2. Paramètres optionnels (avec valeur par défaut) # 3. Paramètres *args (pour arguments variables positionnels) # 4. Paramètres **kwargs (pour arguments variables nommés)
Python offre des mécanismes puissants pour créer des fonctions flexibles qui peuvent accepter un nombre variable d'arguments, à la fois positionnels et nommés.
Le paramètre spécial *args permet à une fonction d'accepter un nombre variable d'arguments positionnels. Ces arguments sont regroupés dans un tuple.
# Fonction avec *args def additionner(*args): print(f"Arguments reçus: {args} (type: {type(args).__name__})") return sum(args) # Appels avec différents nombres d'arguments resultat1 = additionner(1, 2, 3) print(f"Résultat: {resultat1}") # 6 resultat2 = additionner(10, 20, 30, 40, 50) print(f"Résultat: {resultat2}") # 150 resultat3 = additionner(5) print(f"Résultat: {resultat3}") # 5 # Fonction avec paramètres normaux et *args def decrire_produit(nom, *caracteristiques): print(f"Produit: {nom}") print("Caractéristiques:") for i, carac in enumerate(caracteristiques, 1): print(f" {i}. {carac}") # Utilisation decrire_produit("Smartphone", "Écran 6.1 pouces", "128GB stockage", "Double caméra") # *args avec d'autres paramètres (l'ordre est important) def fonction_ordre(a, b, *args, c=10): print(f"a={a}, b={b}, args={args}, c={c}") fonction_ordre(1, 2, 3, 4, 5, c=99) # a=1, b=2, args=(3, 4, 5), c=99
Le paramètre spécial **kwargs permet d'accepter un nombre variable d'arguments nommés. Ces arguments sont regroupés dans un dictionnaire.
# Fonction avec **kwargs def afficher_infos(**kwargs): print(f"Arguments nommés reçus: {kwargs} (type: {type(kwargs).__name__})") for cle, valeur in kwargs.items(): print(f"{cle}: {valeur}") # Appels avec différents arguments nommés afficher_infos(nom="Alice", age=25, ville="Paris") afficher_infos(produit="Laptop", prix=999, stock=True) # Fonction avec paramètres normaux et **kwargs def creer_utilisateur(nom, email, **infos_supplementaires): utilisateur = { 'nom': nom, 'email': email } utilisateur.update(infos_supplementaires) return utilisateur # Utilisation user1 = creer_utilisateur("Alice", "alice@email.com") user2 = creer_utilisateur("Bob", "bob@email.com", age=30, ville="Lyon", admin=True) print(f"Utilisateur 1: {user1}") print(f"Utilisateur 2: {user2}") # **kwargs pour des configurations flexibles def configurer_affichage(titre, **options): config = { 'titre': titre, 'couleur': options.get('couleur', 'noir'), 'taille': options.get('taille', 12), 'gras': options.get('gras', False) } print(f"Configuration: {config}") return config # Différentes configurations config1 = configurer_affichage("Mon Titre") config2 = configurer_affichage("Titre Important", couleur="rouge", gras=True) config3 = configurer_affichage("Titre Petit", taille=10, couleur="bleu")
Il est possible de combiner *args et **kwargs dans une même fonction pour une flexibilité maximale. L'ordre doit être respecté : d'abord les paramètres normaux, puis *args, puis **kwargs.
# Fonction avec *args et **kwargs def fonction_complete(a, b, *args, **kwargs): print(f"a={a}, b={b}") print(f"args={args}") print(f"kwargs={kwargs}") print("-" * 20) # Différents appels fonction_complete(1, 2) fonction_complete(1, 2, 3, 4, 5) fonction_complete(1, 2, 3, 4, nom="test", valeur=100) fonction_complete(1, 2, option="special") # Exemple pratique: fonction de logging flexible def logger(niveau, *messages, **metadonnees): timestamp = __import__('datetime').datetime.now().strftime("%Y-%m-%d %H:%M:%S") message_complet = " ".join(str(m) for m in messages) log_entry = { 'timestamp': timestamp, 'niveau': niveau, 'message': message_complet } log_entry.update(metadonnees) print(f"[{timestamp}] {niveau.upper()}: {message_complet}") if metadonnees: print(f" Métadonnées: {metadonnees}") return log_entry # Utilisation du logger flexible logger("info", "Démarrage de l'application") logger("warning", "Ressource faible:", "mémoire à 85%", seuil=80) logger("error", "Échec connexion", "timeout après 30s", serveur="api.example.com", code_erreur=503) # Fonction wrapper générique (pattern courant) def temporiser(fonction): def wrapper(*args, **kwargs): print(f"Appel de {fonction.__name__} avec args={args}, kwargs={kwargs}") resultat = fonction(*args, **kwargs) print(f"Résultat: {resultat}") return resultat return wrapper # Application du wrapper def addition(a, b): return a + b def multiplier(x, y, z=1): return x * y * z addition_temporisee = temporiser(addition) multiplication_temporisee = temporiser(multiplier) # Appels des fonctions wrappées addition_temporisee(5, 3) multiplication_temporisee(2, 4, z=3)
La portée (scope) détermine la visibilité et l'accessibilité des variables dans différentes parties du code. Python utilise des règles spécifiques pour gérer les portées des variables.
Les variables définies à l'intérieur d'une fonction ont une portée locale. Elles ne sont accessibles qu'à l'intérieur de cette fonction.
# Variable globale variable_globale = "Je suis globale" def ma_fonction(): # Variable locale - accessible seulement dans cette fonction variable_locale = "Je suis locale" print("Dans la fonction:") print(f" Locale: {variable_locale}") print(f" Globale: {variable_globale}") # Accessible # On peut créer une variable locale avec le même nom qu'une globale variable_globale = "Je masque la globale" # Variable locale print(f" Locale (même nom): {variable_globale}") # Appel de la fonction ma_fonction() # En dehors de la fonction print("En dehors de la fonction:") print(f" Globale: {variable_globale}") # Toujours "Je suis globale" # Erreur: variable locale non accessible # print(variable_locale) # NameError: name 'variable_locale' is not defined # Variables locales dans des fonctions différentes def fonction1(): x = 10 # Locale à fonction1 print(f"Fonction1 - x: {x}") def fonction2(): x = 20 # Locale à fonction2 (différente de celle de fonction1) print(f"Fonction2 - x: {x}") fonction1() # Affiche: Fonction1 - x: 10 fonction2() # Affiche: Fonction2 - x: 20
Les variables définies en dehors de toute fonction ont une portée globale. Elles sont accessibles partout dans le module.
# Variables globales compteur = 0 NOM_APPLICATION = "MonApp" utilisateurs_connectes = [] def incrementer_compteur(): # Accès en lecture à la variable globale print(f"Compteur actuel: {compteur}") # Ceci créera une variable locale, pas une modification de la globale # compteur = compteur + 1 # UnboundLocalError def afficher_configuration(): print(f"Application: {NOM_APPLICATION}") print(f"Utilisateurs connectés: {utilisateurs_connectes}") def ajouter_utilisateur(nom): # On peut modifier des objets mutables globaux utilisateurs_connectes.append(nom) print(f"Utilisateur {nom} ajouté") # Utilisation incrementer_compteur() afficher_configuration() ajouter_utilisateur("Alice") ajouter_utilisateur("Bob") afficher_configuration() # Variables globales accessibles partout if compteur == 0: print("Le compteur est à zéro") # Portée globale dans les fonctions imbriquées def fonction_externe(): print(f"Dans fonction_externe: {NOM_APPLICATION}") def fonction_interne(): print(f"Dans fonction_interne: {NOM_APPLICATION}") fonction_interne() fonction_externe()
Le mot-clé global permet de modifier une variable globale depuis l'intérieur d'une fonction.
# Variables globales compteur = 0 config = {"mode": "production", "debug": False} def incrementer_compteur(): # Déclarer qu'on veut utiliser la variable globale global compteur compteur += 1 print(f"Compteur incrémenté: {compteur}") def reset_compteur(): global compteur ancienne_valeur = compteur compteur = 0 print(f"Compteur réinitialisé de {ancienne_valeur} à {compteur}") def changer_mode(nouveau_mode): # Pour les objets mutables comme les dictionnaires, listes, etc. # on peut modifier leur contenu sans mot-clé global config["mode"] = nouveau_mode print(f"Mode changé à: {config['mode']}") def activer_debug(): config["debug"] = True print("Mode debug activé") # Utilisation print(f"Compteur initial: {compteur}") print(f"Config initiale: {config}") incrementer_compteur() incrementer_compteur() incrementer_compteur() changer_mode("development") activer_debug() print(f"Compteur final: {compteur}") print(f"Config finale: {config}") reset_compteur() print(f"Compteur après reset: {compteur}") # Attention: bonne pratique # L'utilisation excessive de global peut rendre le code difficile à comprendre # et maintenir. Il est souvent préférable de retourner des valeurs # ou d'utiliser des classes. def incrementer_sans_global(valeur): # Meilleure approche: retourner la nouvelle valeur return valeur + 1 compteur = incrementer_sans_global(compteur) print(f"Compteur sans global: {compteur}")
Le mot-clé nonlocal permet de modifier une variable d'une portée englobante (mais non globale) dans une fonction imbriquée.
# Exemple avec nonlocal def fonction_externe(): variable_externe = "valeur externe" compteur = 0 print(f"Avant fonction_interne: variable_externe = {variable_externe}") print(f"Avant fonction_interne: compteur = {compteur}") def fonction_interne(): # nonlocal permet de modifier la variable de la fonction englobante nonlocal variable_externe, compteur variable_externe = "modifiée par interne" compteur += 1 print(f"Dans fonction_interne: variable_externe = {variable_externe}") print(f"Dans fonction_interne: compteur = {compteur}") # Appel de la fonction interne fonction_interne() print(f"Après fonction_interne: variable_externe = {variable_externe}") print(f"Après fonction_interne: compteur = {compteur}") return compteur # Utilisation resultat = fonction_externe() print(f"Compteur final retourné: {resultat}") # Exemple pratique: compteur avec fermeture (closure) def creer_compteur(): compte = 0 def incrementer(): nonlocal compte compte += 1 return compte def decrementer(): nonlocal compte compte -= 1 return compte def obtenir_valeur(): return compte return incrementer, decrementer, obtenir_valeur # Création du compteur inc, dec, get = creer_compteur() print("Utilisation du compteur:") print(f"Valeur initiale: {get()}") # 0 print(f"Incrément: {inc()}") # 1 print(f"Incrément: {inc()}") # 2 print(f"Décrément: {dec()}") # 1 print(f"Valeur actuelle: {get()}") # 1 # Différence entre global et nonlocal variable_globale = "globale" def test_portees(): variable_nonlocal = "nonlocal" def interne(): global variable_globale # Réfère à la variable globale du module nonlocal variable_nonlocal # Réfère à la variable de la fonction englobante variable_globale = "modifiée globalement" variable_nonlocal = "modifiée non localement" interne() print(f"Dans test_portees: variable_nonlocal = {variable_nonlocal}") test_portees() print(f"En dehors: variable_globale = {variable_globale}")
Python offre plusieurs types de fonctions avancées qui permettent une programmation plus expressive et flexible : fonctions récursives, lambda, objets de première classe et fonctions imbriquées.
Une fonction récursive est une fonction qui s'appelle elle-même. Elle doit avoir une condition d'arrêt pour éviter une récursion infinie.
# Factorielle avec récursion def factorielle(n): # Condition d'arrêt if n == 0 or n == 1: return 1 # Appel récursif else: return n * factorielle(n - 1) # Test print(f"Factorielle de 5: {factorielle(5)}") # 120 print(f"Factorielle de 0: {factorielle(0)}") # 1 # Suite de Fibonacci récursive def fibonacci(n): if n <= 1: return n else: return fibonacci(n - 1) + fibonacci(n - 2) # Test print("Suite de Fibonacci:") for i in range(10): print(f"F({i}) = {fibonacci(i)}") # Parcours récursif d'une structure imbriquée def afficher_structure(data, niveau=0): indent = " " * niveau if isinstance(data, dict): for key, value in data.items(): print(f"{indent}{key}:") afficher_structure(value, niveau + 1) elif isinstance(data, list): for item in data: afficher_structure(item, niveau + 1) else: print(f"{indent}{data}") # Test structure_complexe = { "personnes": [ {"nom": "Alice", "age": 25}, {"nom": "Bob", "age": 30, "hobbies": ["lecture", "sport"]} ], "config": {"debug": True, "version": 1.2} } print("Structure complexe:") afficher_structure(structure_complexe) # Attention: récursion peut causer des erreurs de profondeur maximum # print(factorielle(1000)) # RecursionError pour les grandes valeurs
Les fonctions lambda sont des fonctions anonymes définies avec le mot-clé lambda. Elles sont utiles pour des opérations simples et courtes.
# Fonction lambda basique carre = lambda x: x * x print(f"Carre de 5: {carre(5)}") # 25 # Lambda avec plusieurs paramètres addition = lambda a, b: a + b print(f"Addition: {addition(3, 4)}") # 7 # Utilisation courante: tri avec key personnes = [ {"nom": "Alice", "age": 25}, {"nom": "Bob", "age": 30}, {"nom": "Charlie", "age": 20} ] # Trier par age personnes_triees = sorted(personnes, key=lambda p: p["age"]) print("Tri par age:", personnes_triees) # Trier par nom personnes_triees_nom = sorted(personnes, key=lambda p: p["nom"]) print("Tri par nom:", personnes_triees_nom) # Utilisation avec filter() nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] pairs = list(filter(lambda x: x % 2 == 0, nombres)) print("Nombres pairs:", pairs) # [2, 4, 6, 8, 10] # Utilisation avec map() carres = list(map(lambda x: x * x, nombres)) print("Carrés:", carres) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] # Lambda conditionnelle categoriser = lambda x: "pair" if x % 2 == 0 else "impair" print(f"5 est {categoriser(5)}") # impair print(f"8 est {categoriser(8)}") # pair # Limitations: les lambda sont limitées à une seule expression # Ceci est INVALIDE: # lambda x: print(x); return x * 2 # SyntaxError
En Python, les fonctions sont des objets de première classe : elles peuvent être assignées à des variables, passées comme arguments et retournées par d'autres fonctions.
# Assignation à une variable def salutation(nom): return f"Bonjour, {nom}!" ma_fonction = salutation # Pas de parenthèses! print(f"Type: {type(ma_fonction)}") # <class 'function'> print(ma_fonction("Alice")) # Bonjour, Alice! # Passage comme argument def appliquer_fonction(fonction, valeur): return fonction(valeur) resultat = appliquer_fonction(salutation, "Bob") print(resultat) # Bonjour, Bob! # Fonctions dans des structures de données operations = { "addition": lambda a, b: a + b, "soustraction": lambda a, b: a - b, "multiplication": lambda a, b: a * b, "division": lambda a, b: a / b if b != 0 else "Erreur" } # Utilisation a, b = 10, 5 for nom, operation in operations.items(): resultat = operation(a, b) print(f"{nom}: {a} et {b} = {resultat}") # Retourner une fonction depuis une fonction def creer_multiplicateur(facteur): def multiplicateur(x): return x * facteur return multiplicateur doubleur = creer_multiplicateur(2) tripleur = creer_multiplicateur(3) print(f"Double de 5: {doubleur(5)}") # 10 print(f"Triple de 5: {tripleur(5)}") # 15 # Fonctions d'ordre supérieur def composer(f, g): def composition(x): return f(g(x)) return composition def ajouter_un(x): return x + 1 def multiplier_deux(x): return x * 2 ajouter_puis_multiplier = composer(multiplier_deux, ajouter_un) multiplier_puis_ajouter = composer(ajouter_un, multiplier_deux) print(f"Ajouter puis multiplier 3: {ajouter_puis_multiplier(3)}") # 8 print(f"Multiplier puis ajouter 3: {multiplier_puis_ajouter(3)}") # 7
Python permet de définir des fonctions à l'intérieur d'autres fonctions. Ces fonctions imbriquées ont accès aux variables de la fonction englobante.
# Fonction avec fonctions imbriquées def calculatrice(operation): # Fonctions imbriquées def addition(a, b): return a + b def soustraction(a, b): return a - b def multiplication(a, b): return a * b def division(a, b): if b == 0: return "Erreur: division par zéro" return a / b # Sélection de l'opération if operation == "addition": return addition elif operation == "soustraction": return soustraction elif operation == "multiplication": return multiplication elif operation == "division": return division else: return None # Utilisation op_add = calculatrice("addition") op_mult = calculatrice("multiplication") print(f"Addition: {op_add(10, 5)}") # 15 print(f"Multiplication: {op_mult(10, 5)}") # 50 # Fonction avec closure (fermeture) def creer_compteur(): compte = 0 # Variable de la fonction englobante def incrementer(): nonlocal compte # Permet de modifier la variable englobante compte += 1 return compte def decrementer(): nonlocal compte compte -= 1 return compte def valeur(): return compte return incrementer, decrementer, valeur # Création d'un compteur inc, dec, val = creer_compteur() print("Compteur:") print(f"Valeur initiale: {val()}") # 0 print(f"Incrément: {inc()}") # 1 print(f"Incrément: {inc()}") # 2 print(f"Décrément: {dec()}") # 1 print(f"Valeur finale: {val()}") # 1 # Fonction de décorateur avec fonction imbriquée def decorateur_temps(fonction): import time def wrapper(*args, **kwargs): debut = time.time() resultat = fonction(*args, **kwargs) fin = time.time() print(f"Temps d'exécution: {fin - debut:.4f} secondes") return resultat return wrapper # Utilisation du décorateur def calcul_long(): sum(i * i for i in range(1000000)) calcul_long_decore = decorateur_temps(calcul_long) calcul_long_decore()
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!