Comprendre les décorateurs Python pas à pas (partie 1)

def crier(mot="yes"):
    return mot.capitalize()+"!"
 
print crier()
# output : 'Yes!'
 
# Puisque les fonctions sont des objets,
# on peut les assigner à des variables
 
hurler = crier
 
# Notez que l'on n'utilsie pas les parenthèses :
# la fonction n'est pas apellée. Ici nous mettons la fonction "crier"
# dans la variable "hurler" afin de pouvoir appeler "crier" avec "hurler"
 
print hurler()
# output : 'Yes!'
 
# Et vous pouvez même supprimer l'ancien nom "crier",
# la fonction restera accessible avec "hurler"
 
del crier
try:
    print crier()
except NameError, e:
    print e
    #output: "name 'crier' is not defined"
 
print hurler()
# output: 'Yes!'

def parler():
 
    # On peut definir une fonction à la volée dans "parler" ...
    def chuchoter(mot="yes"):
        return mot.lower()+"...";
 
    # ... et l'utiliser immédiatement !
 
    print chuchoter()
 
# On appelle "parler", qui définit "chuchoter" A CHAQUE APPEL,
# puis "chuchoter" est appélé à l'intérieux de "parler"
 
parler()
# output:
# "yes..."
 
# Mais "chuchoter" N'EXISTE PAS en dehors de "parler"
 
try:
    print chuchoter()
except NameError, e:
    print e
    #output : "name 'chuchoter' is not defined"*

def creerParler(type="crier"):
 
    # On fabrique 2 fonctions à la volée
    def crier(mot="yes"):
        return mot.capitalize()+"!"
 
    def chuchoter(mot="yes") :
        return mot.lower()+"...";
 
    # Puis on retourne l'une ou l'autre
    if type == "crier":
        # on utilise pas "()", on n'appele pas la fonction
        # on retourne l'objet fonction
        return crier
    else:
        return chuchoter
 
# Comment ce truc bizarre s'utilise ?
 
# Obtenir la fonction et l'assigner à une variable
parler = creerParler()
 
# "parler" est une variable qui contient la fonction "crier":
print parler
#output : <function crier at 0xb7ea817c>
 
# On peut appeler "crier" depuis "parler":
print parler()
#ouput : YES!
 
# Et si on se sent chaud, on peut même créer et appeler la
# fonction en une seule fois:
print creerParler("chuchoter")()
#output : yes...

def faireQuelqueChoseAvant(fonction):
    print "Je fais quelque chose avant d'appeler la fonction"
    print fonction()
 
faireQuelqueChoseAvant(hurler)
#output:
#Je fais quelque chose avant d'appeler la fonction
#Yes!

# Un décorateur est une fonction qui attend une autre fonction en paramètres
def decorateur_tout_neuf(fonction_a_decorer):
 
    # En interne, le décorateur définie une fonction à la volée: le wrapper.
    # Le wrapper va enrober la fonction orginale de telle sorte qu'il
    # puisse éxécuter du code avant et après celle-ci
    def wrapper_autour_de_la_fonction_originale():
 
        # Mettre ici le code que l'on souhaite éxécuter AVANT que la
        # fonction s'éxécute
        print "Avant que la fonction ne s'éxécute"
 
        # Apperler la fonction (en utilisant donc les parenthèses)
        fonction_a_decorer()
 
        # Mettre ici le code que l'on souhaite éxécuter APRES que la
        # fonction s'éxécute
        print "Après que la fonction soit éxécutée"
 
    # Arrivé ici, la "fonction_a_decorer" n'a JAMAIS ETE EXECUTE
    # On retourne le wrapper qu'on l'on vient de créer.
    # Le wrapper contient la fonction originale et le code à éxécuter 
    # avant et après, prêt à être utilisé.
    return wrapper_autour_de_la_fonction_originale
 
# Maintenant imaginez une fonction que l'on ne souhaite pas modifier.
def une_fonction_intouchable():
    print "Je suis une fonction intouchable, on ne me modifie pas !"
 
une_fonction_intouchable()
#output: Je suis une fonction intouchable, on ne me modifie pas !
 
# On peut malgré tout étendre ton comportement
# Il suffit de la passer au décorateur, qui va alors l'enrober dans
# le code que l'on souhaite, pour ensuite retourner une nouvelle fonction
 
une_fonction_intouchable_decoree = decorateur_tout_neuf(une_fonction_intouchable)
une_fonction_intouchable_decoree()
#output:
#Avant que la fonction ne s'éxécute
#Je suis une fonction intouchable, on ne me modifie pas !
#Après que la fonction soit éxécutée

une_fonction_intouchable = decorateur_tout_neuf(une_fonction_intouchable)
une_fonction_intouchable()
#output:
#Avant que la fonction ne s'éxécute
#Je suis une fonction intouchable, on ne me modifie pas !
#Après que la fonction soit éxécutée

@decorateur_tout_neuf
def fonction_intouchable():
    print "Me touche pas !"
 
fonction_intouchable()
#output:
#Avant que la fonction ne s'éxécute
#Me touche pas !
#Après que la fonction soit éxécutée

fonction_intouchable = decorateur_tout_neuf(fonction_intouchable)

def pain(func):
    def wrapper():
        print "</''''''\>"
        func()
        print "<\______/>"
    return wrapper
 
def ingredients(func):
    def wrapper():
        print "#tomates#"
        func()
        print "~salade~"
    return wrapper
 
def sandwich(food="--jambon--"):
    print food
 
sandwich()
#output: --jambon--
sandwich = pain(ingredients(sandwich))
sandwich()
#output:
#</''''''\>
# #tomates#
# --jambon--
# ~salade~
#<\______/>

@pain
@ingredients
def sandwich(nouriture="--jambon--"):
    print nouriture
 
sandwich()
#output:
#</''''''\>
# #tomates#
# --jambon--
# ~salade~
#<\______/>

@ingredients
@pain
def sandwich_zarb(nouriture="--jambon--"):
    print nouriture
 
sandwich_zarb()
#output:
##tomates#
#</''''''\>
# --jambon--
#<\______/>
# ~salade~