img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Python les Bases
Chapitre 9 : Fonctions

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.

Introduction aux fonctions

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.

Qu'est-ce qu'une fonction ?

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.

fonction_simple.py
# Définition d'une fonction simple
def salutation():
    print("Bonjour !")

# Appel de la fonction
salutation()  # Affiche "Bonjour !"

Pourquoi utiliser des fonctions ?

Les fonctions offrent plusieurs avantages : réutilisabilité du code, modularité, lisibilité et facilité de maintenance.

avantages_fonctions.py
# 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")

Syntaxe de base d'une fonction

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_fonction.py
# 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"

Définition et appel de fonctions

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`

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.

mot_cle_def.py
# 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

Structure d'une fonction simple

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.

structure_fonction.py
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.")

Appel d'une fonction

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.

appel_fonction.py
# 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`

L'instruction return termine l'exécution d'une fonction et renvoie une valeur au code appelant. Une fonction sans return renvoie None.

instruction_return.py
# 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"

Paramètres et arguments

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.

Paramètres obligatoires

Les paramètres obligatoires doivent être fournis lors de l'appel de la fonction, dans l'ordre de leur définition.

parametres_obligatoires.py
# 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}€")

Arguments par défaut

Les paramètres peuvent avoir des valeurs par défaut, rendant leur fourniture optionnelle lors de l'appel.

arguments_defaut.py
# 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

Paramètres nommés (keyword arguments)

Les arguments peuvent être passés en utilisant leur nom, ce qui permet de les spécifier dans n'importe quel ordre.

parametres_nommes.py
# 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"

Ordre des paramètres

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_parametres.py
# 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)

Types de fonctions avancé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.

Fonctions avec nombre variable d'arguments (`*args`)

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.

args_variables.py
# 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

Fonctions avec arguments nommés variables (`**kwargs`)

Le paramètre spécial **kwargs permet d'accepter un nombre variable d'arguments nommés. Ces arguments sont regroupés dans un dictionnaire.

kwargs_variables.py
# 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")

Fonctions avec les deux (`*args` et `**kwargs`)

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.

args_et_kwargs.py
# 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)

Portée des variables (Scope)

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.

Variables locales

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.

variables_locales.py
# 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

Variables globales

Les variables définies en dehors de toute fonction ont une portée globale. Elles sont accessibles partout dans le module.

variables_globales.py
# 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`

Le mot-clé global permet de modifier une variable globale depuis l'intérieur d'une fonction.

mot_cle_global.py
# 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`

Le mot-clé nonlocal permet de modifier une variable d'une portée englobante (mais non globale) dans une fonction imbriquée.

mot_cle_nonlocal.py
# 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}")

Fonctions spéciales

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.

Fonctions récursives

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.

fonctions_recursives.py
# 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

Fonctions lambda (anonymes)

Les fonctions lambda sont des fonctions anonymes définies avec le mot-clé lambda. Elles sont utiles pour des opérations simples et courtes.

fonctions_lambda.py
# 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

Fonctions comme objets de première classe

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.

fonctions_premiere_classe.py
# 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

Fonctions imbriquées

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.

fonctions_imbriquees.py
# 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()
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!

Revenir aux chapitres : Python les Bases | Allez au cours gratuits