9. Les fonctions avancées en Python • Lenaick Sorimoutou

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#

Syntaxe de base#

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

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

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

Paramètres par défaut multiples#

1
def creer_profil(nom, age=25, ville="Paris", actif=True):
2
    return {
3
        "nom": nom,
4
        "age": age,
5
        "ville": ville,
6
        "actif": actif
7
    }
8

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

Arguments nommés et positionnels#

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

Arguments positionnels#

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

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

Arguments nommés#

1
# Arguments par nom (plus lisible)
2
prix2 = calculer_prix(
3
    prix_base=100,
4
    remise=0.1,
5
    tva=0.2
6
)

Fonctions avec un nombre variable d’arguments#

`*args` (arguments positionnels variables)#

1
def additionner(*nombres):
2
    total = 0
3
    for nombre in nombres:
4
        total += nombre
5
    return total
6

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

`**kwargs` (arguments nommés variables)#

1
def creer_configuration(**options):
2
    config = {
3
        "debug": False,
4
        "timeout": 30,
5
        "retry": 3
6
    }
7
    config.update(options)
8
    return config
9

10
# Utilisation
11
config1 = creer_configuration(debug=True)
12
config2 = creer_configuration(timeout=60, retry=5)

Combinaison `*args` et `**kwargs`#

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

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

Fonctions lambda (fonctions anonymes)#

Syntaxe de base#

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

5
# Fonction lambda équivalente
6
carre_lambda = lambda x: x ** 2
7

8
print(carre(5))  # 25
9
print(carre_lambda(5))  # 25

Utilisation avec les fonctions intégrées#

```python title=“Lambda avec map(), filter() et sorted()” showLineNumbers nombres = [1, 2, 3, 4, 5]

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

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

noms = [“Alice”, “Bob”, “Charlie”] noms_tries = sorted(noms, key=lambda nom: len(nom)) print(noms_tries) # [“Bob”, “Alice”, “Charlie”]

1
<Callout variant="tip">
2
Les fonctions lambda sont idéales pour des opérations simples. Pour des logiques plus complexes, préférez les fonctions normales avec `python:def` qui sont plus lisibles et peuvent contenir plusieurs instructions.
3
</Callout>
4

5
## Fonctions comme objets de première classe
6

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

9
### Assignation de fonctions
10

11
```python title="Assignation et manipulation de fonctions" showLineNumbers
12
def dire_bonjour():
13
    return "Bonjour!"
14

15
def dire_aurevoir():
16
    return "Au revoir!"
17

18
# Assignation de fonction
19
salutation = dire_bonjour
20
print(salutation())  # "Bonjour!"
21

22
salutation = dire_aurevoir
23
print(salutation())  # "Au revoir!"

Fonctions comme paramètres#

1
def appliquer_operation(nombres, operation):
2
    resultats = []
3
    for nombre in nombres:
4
        resultats.append(operation(nombre))
5
    return resultats
6

7
def doubler(x):
8
    return x * 2
9

10
def tripler(x):
11
    return x * 3
12

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

15
# Utilisation
16
doubles = appliquer_operation(nombres, doubler)
17
triples = appliquer_operation(nombres, tripler)
18

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

Fonctions imbriquées et closures#

Fonctions imbriquées#

1
def calculatrice():
2
    def addition(a, b):
3
        return a + b
4

5
    def soustraction(a, b):
6
        return a - b
7

8
    def multiplication(a, b):
9
        return a * b
10

11
    return {
12
        "add": addition,
13
        "sub": soustraction,
14
        "mul": multiplication
15
    }
16

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

Closures (fermetures)#

1
def creer_multiplicateur(facteur):
2
    def multiplier(nombre):
3
        return nombre * facteur
4
    return multiplier
5

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

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

Décorateurs (introduction)#

Décorateur simple#

1
def chronometrer(fonction):
2
    def wrapper(*args, **kwargs):
3
        import time
4
        debut = time.time()
5
        resultat = fonction(*args, **kwargs)
6
        fin = time.time()
7
        print(f"Temps d'exécution: {fin - debut:.2f} secondes")
8
        return resultat
9
    return wrapper
10

11
@chronometrer
12
def calcul_long():
13
    total = 0
14
    for i in range(1000000):
15
        total += i
16
    return total
17

18
resultat = calcul_long()

Récursion#

Exemple classique : factorielle#

1
def factorielle(n):
2
    if n <= 1:
3
        return 1
4
    else:
5
        return n * factorielle(n - 1)
6

7
print(factorielle(5))  # 120

Exemple : suite de Fibonacci#

1
def fibonacci(n):
2
    if n <= 1:
3
        return n
4
    else:
5
        return fibonacci(n - 1) + fibonacci(n - 2)
6

7
print(fibonacci(10))  # 55

Récursion avec mémorisation#

1
def fibonacci_memo(n, memo={}):
2
    if n in memo:
3
        return memo[n]
4
    if n <= 1:
5
        return n
6
    memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)
7
    return memo[n]
8

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

Bonnes pratiques#

Documentation des fonctions#

1
def calculer_moyenne(nombres):
2
    """
3
    Calcule la moyenne d'une liste de nombres.
4

5
    Args:
6
        nombres (list): Liste de nombres à moyenner
7

8
    Returns:
9
        float: La moyenne des nombres
10

11
    Raises:
12
        ValueError: Si la liste est vide
13
    """
14
    if not nombres:
15
        raise ValueError("La liste ne peut pas être vide")
16

17
    return sum(nombres) / len(nombres)

Gestion des erreurs#

1
def diviser(a, b):
2
    try:
3
        return a / b
4
    except ZeroDivisionError:
5
        print("Erreur: Division par zéro")
6
        return None
7
    except TypeError:
8
        print("Erreur: Types invalides")
9
        return None

Exercices pratiques#

Conclusion#

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

Paramètres par défaut : Pour des fonctions plus pratiques
Arguments variables (*args, **kwargs) : 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 !

Les fonctions avancées en Python

En bref

Les fonctions avancées en Python#

Paramètres par défaut#

Syntaxe de base#

Paramètres par défaut multiples#

Arguments nommés et positionnels#

Arguments positionnels#

Arguments nommés#

Fonctions avec un nombre variable d’arguments#

`*args` (arguments positionnels variables)#

`**kwargs` (arguments nommés variables)#

Combinaison `*args` et `**kwargs`#

Fonctions lambda (fonctions anonymes)#

Syntaxe de base#

Utilisation avec les fonctions intégrées#

Fonctions comme paramètres#

Fonctions imbriquées et closures#

Fonctions imbriquées#

Closures (fermetures)#

Décorateurs (introduction)#

Décorateur simple#

Récursion#

Exemple classique : factorielle#

Exemple : suite de Fibonacci#

Récursion avec mémorisation#

Bonnes pratiques#

Documentation des fonctions#

Gestion des erreurs#

Exercices pratiques#

Conclusion#

Formation Python 101

~/ En bref

Les fonctions avancées en Python#

Paramètres par défaut#

Syntaxe de base#

Paramètres par défaut multiples#

Arguments nommés et positionnels#

Arguments positionnels#

Arguments nommés#

Fonctions avec un nombre variable d’arguments#

*args (arguments positionnels variables)#

**kwargs (arguments nommés variables)#

Combinaison *args et **kwargs#

Fonctions lambda (fonctions anonymes)#

Syntaxe de base#

Utilisation avec les fonctions intégrées#

Fonctions comme paramètres#

Fonctions imbriquées et closures#

Fonctions imbriquées#

Closures (fermetures)#

Décorateurs (introduction)#

Décorateur simple#

Récursion#

Exemple classique : factorielle#

Exemple : suite de Fibonacci#

Récursion avec mémorisation#

Bonnes pratiques#

Documentation des fonctions#

Gestion des erreurs#

Exercices pratiques#

Conclusion#

~/ Formation Python 101

En bref

`*args` (arguments positionnels variables)#

`**kwargs` (arguments nommés variables)#

Combinaison `*args` et `**kwargs`#

Formation Python 101