Lenaick Sorimoutou

Retour

9. Les fonctions avancées en Python

Approfondissez vos connaissances sur les fonctions Python : paramètres par défaut, fonctions lambda, décorateurs et récursion.

PYTHON pour les DÉBUTANTS #9#

Les fonctions avancées en Python#

Maintenant que vous maîtrisez les bases des fonctions, découvrons les concepts avancés qui vous permettront d’écrire du code plus élégant et réutilisable.

Paramètres par défaut#

Les paramètres par défaut permettent de rendre certains arguments optionnels.

Syntaxe de base#

def saluer(nom, message="Bonjour"):
    return f"{message}, {nom}!"

# Utilisation avec paramètre par défaut
print(saluer("Alice"))  # "Bonjour, Alice!"

# Utilisation avec paramètre personnalisé
print(saluer("Bob", "Salut"))  # "Salut, Bob!"
python

Paramètres par défaut multiples#

def creer_profil(nom, age=25, ville="Paris", actif=True):
    return {
        "nom": nom,
        "age": age,
        "ville": ville,
        "actif": actif
    }

# Utilisation avec différents paramètres
profil1 = creer_profil("Alice")
profil2 = creer_profil("Bob", 30)
profil3 = creer_profil("Charlie", ville="Lyon")
python

Arguments nommés et positionnels#

Python permet de passer les arguments par position ou par nom.

Arguments positionnels#

def calculer_prix(prix_base, tva=0.2, remise=0):
    prix_final = prix_base * (1 + tva) * (1 - remise)
    return prix_final

# Arguments par position
prix1 = calculer_prix(100, 0.1, 0.05)
python

Arguments nommés#

# Arguments par nom (plus lisible)
prix2 = calculer_prix(
    prix_base=100,
    remise=0.1,
    tva=0.2
)
python

Fonctions avec un nombre variable d’arguments#

*args (arguments positionnels variables)#

def additionner(*nombres):
    total = 0
    for nombre in nombres:
        total += nombre
    return total

# Utilisation
resultat1 = additionner(1, 2, 3)  # 6
resultat2 = additionner(1, 2, 3, 4, 5)  # 15
python

**kwargs (arguments nommés variables)#

def creer_configuration(**options):
    config = {
        "debug": False,
        "timeout": 30,
        "retry": 3
    }
    config.update(options)
    return config

# Utilisation
config1 = creer_configuration(debug=True)
config2 = creer_configuration(timeout=60, retry=5)
python

Combinaison *args et **kwargs#

def fonction_complete(*args, **kwargs):
    print("Arguments positionnels:", args)
    print("Arguments nommés:", kwargs)

fonction_complete(1, 2, 3, nom="Alice", age=25)
python

Fonctions lambda (fonctions anonymes)#

Les fonctions lambda permettent de créer des fonctions simples en une ligne.

Syntaxe de base#

# Fonction normale
def carre(x):
    return x ** 2

# Fonction lambda équivalente
carre_lambda = lambda x: x ** 2

print(carre(5))  # 25
print(carre_lambda(5))  # 25
python

Utilisation avec les fonctions intégrées#

nombres = [1, 2, 3, 4, 5]

# Utilisation avec map()
carres = list(map(lambda x: x ** 2, nombres))
print(carres)  # [1, 4, 9, 16, 25]

# Utilisation avec filter()
pairs = list(filter(lambda x: x % 2 == 0, nombres))
print(pairs)  # [2, 4]

# Utilisation avec sorted()
noms = ["Alice", "Bob", "Charlie"]
noms_tries = sorted(noms, key=lambda nom: len(nom))
print(noms_tries)  # ["Bob", "Alice", "Charlie"]
python

Fonctions comme objets de première classe#

En Python, les fonctions sont des objets comme les autres.

Assignation de fonctions#

def dire_bonjour():
    return "Bonjour!"

def dire_aurevoir():
    return "Au revoir!"

# Assignation de fonction
salutation = dire_bonjour
print(salutation())  # "Bonjour!"

salutation = dire_aurevoir
print(salutation())  # "Au revoir!"
python

Fonctions comme paramètres#

def appliquer_operation(nombres, operation):
    resultats = []
    for nombre in nombres:
        resultats.append(operation(nombre))
    return resultats

def doubler(x):
    return x * 2

def tripler(x):
    return x * 3

nombres = [1, 2, 3, 4, 5]

# Utilisation
doubles = appliquer_operation(nombres, doubler)
triples = appliquer_operation(nombres, tripler)

print(doubles)  # [2, 4, 6, 8, 10]
print(triples)  # [3, 6, 9, 12, 15]
python

Fonctions imbriquées et closures#

Fonctions imbriquées#

def calculatrice():
    def addition(a, b):
        return a + b
    
    def soustraction(a, b):
        return a - b
    
    def multiplication(a, b):
        return a * b
    
    return {
        "add": addition,
        "sub": soustraction,
        "mul": multiplication
    }

# Utilisation
calc = calculatrice()
resultat = calc["add"](5, 3)  # 8
python

Closures (fermetures)#

def creer_multiplicateur(facteur):
    def multiplier(nombre):
        return nombre * facteur
    return multiplier

# Création de fonctions spécialisées
multiplier_par_2 = creer_multiplicateur(2)
multiplier_par_3 = creer_multiplicateur(3)

print(multiplier_par_2(5))  # 10
print(multiplier_par_3(5))  # 15
python

Décorateurs (introduction)#

Les décorateurs permettent de modifier le comportement des fonctions.

Décorateur simple#

def chronometrer(fonction):
    def wrapper(*args, **kwargs):
        import time
        debut = time.time()
        resultat = fonction(*args, **kwargs)
        fin = time.time()
        print(f"Temps d'exécution: {fin - debut:.2f} secondes")
        return resultat
    return wrapper

@chronometrer
def calcul_long():
    total = 0
    for i in range(1000000):
        total += i
    return total

resultat = calcul_long()
python

Récursion#

La récursion permet à une fonction de s’appeler elle-même.

Exemple classique : factorielle#

def factorielle(n):
    if n <= 1:
        return 1
    else:
        return n * factorielle(n - 1)

print(factorielle(5))  # 120
python

Exemple : suite de Fibonacci#

def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55
python

Récursion avec mémorisation#

def fibonacci_memo(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)
    return memo[n]

print(fibonacci_memo(50))  # Beaucoup plus rapide !
python

Bonnes pratiques#

Documentation des fonctions#

def calculer_moyenne(nombres):
    """
    Calcule la moyenne d'une liste de nombres.
    
    Args:
        nombres (list): Liste de nombres à moyenner
        
    Returns:
        float: La moyenne des nombres
        
    Raises:
        ValueError: Si la liste est vide
    """
    if not nombres:
        raise ValueError("La liste ne peut pas être vide")
    
    return sum(nombres) / len(nombres)
python

Gestion des erreurs#

def diviser(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("Erreur: Division par zéro")
        return None
    except TypeError:
        print("Erreur: Types invalides")
        return None
python

Exercices pratiques#

  1. Calculatrice avancée : Créez une calculatrice avec des opérations personnalisées.

  2. Filtre de données : Utilisez des fonctions lambda pour filtrer des listes de données.

  3. Décorateur de logging : Créez un décorateur qui enregistre les appels de fonction.

  4. Fonction récursive : Implémentez une fonction pour parcourir un arbre de répertoires.

Conclusion#

Les fonctions avancées en Python offrent une grande flexibilité :

  • Paramètres par défaut : Pour des fonctions plus pratiques
  • Arguments variables : Pour une adaptabilité maximale
  • Fonctions lambda : Pour des opérations simples et élégantes
  • Closures : Pour créer des fonctions spécialisées
  • Récursion : Pour résoudre des problèmes complexes

Maîtrisez ces concepts et vous écrirez du code Python plus professionnel et maintenable ! 🐍✨

RESSOURCES