**Le décorateur** fonctionne en prenant une fonction comme argument et en l'exécutant ensuite dans une fonction **wrapper**.

Pour appliquer un décorateur, on peut utiliser le symbole **@** suivi du nom de la fonction décoratrice, placé juste au-dessus de la fonction qui doit être modifiée. Voici un exemple :

``` python
def decorator(func):
    ...

# First method
@decorator
add(a,b):
    print(f"Function add: {a} + {b}")

add(2, 3)

# Second method
add(a,b):
    print(f"Function add: {a} + {b}")

inner = decorator(add)

inner(2, 3)
```

Dans cet exemple, les deux méthodes atteignent le même résultat. La première méthode, utilisant le symbole `@`, est une manière plus lisible et concise d'appliquer les `decorators`, souvent appelée "*sucre syntaxique*".

Il est typique d'utiliser une fonction imbriquée nommée `wrapper` dans les décorateurs.

#### Décorateurs Flexibles : Accommoder Divers Arguments de Fonction

Les fonctions nécessitent souvent un nombre variable d'arguments. 
Pour développer un décorateur capable d'être appliqué à des fonctions avec des nombres d'arguments différents, il est efficace d'utiliser `*args` et `**kwargs` dans la fonction `wrapper()`.

def indicate(func):
    def wrapper(*args, **kwargs):
        print("=" * 15)
        print("Taken arguments:", *args, kwargs)
        result = func(*args, **kwargs)
        print("=" * 15)
        return result
    return wrapper


@indicate
def avg_two(a, b):
    """Calculate the average of two numbers"""
    return round((a + b) / 2, 1)

@indicate
def avg_three(a, b, c):
    """Calculate the average of three numbers"""
    return round((a + b + c) / 3, 1)

@indicate
def avg_many_kwargs(**kwargs):
    """Calculate the average of multiple numbers in a dictionary"""
    keys = 0
    total = 0

    for value in kwargs.values():
        keys += 1
        total += value

    return round(total / keys, 1)

print("Returned:", avg_two(14, 21), "\n")
print("Returned:", avg_three(225, 12, 11), "\n")
print("Returned:", avg_many_kwargs(first=51, second=11, third=47, fourth=93))

Dans ce cours, vous apprendrez des sujets avancés tels que les arguments de fonction, les itérateurs, les générateurs, les fermetures et les décorateurs. Des dizaines d'exercices pratiques vous aideront à comprendre ces sujets.

Vous trouverez ce sujet agréable, et vous apprendrez à pack et déballer des valeurs en une seule affectation.

Explorez la puissance des arguments de fonction en Python, *args, **kwargs, et apprenez à utiliser efficacement les fonctions comme arguments.

Découvrez les fonctions d'ordre supérieur et comment les fonctions peuvent être passées comme arguments à d'autres fonctions en programmation.

Qu'est-ce que la portée des variables, et comment avons-nous fait sans elle auparavant ? Ce sujet est essentiel pour comprendre les sujets suivants : Closures et Décorateurs. Je vous assure que ce sujet sera à la fois agréable et pratique. Vous acquerrez des connaissances sur les variables locales, non locales et globales.

Cette section offre une exploration approfondie des décorateurs Python, une fonctionnalité puissante qui permet la modification et l'amélioration du comportement des fonctions. Les participants apprendront à écrire leurs propres décorateurs, à comprendre les décorateurs intégrés et à appliquer les décorateurs dans des scénarios pratiques.

Techniques Python Intermédiaires

Syntaxe

Décorateurs Flexibles : Accommoder Divers Arguments de Fonction