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’utilise pas les parenthèses :
# la fonction n'est pas appelé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 as e:
    print(e)
    #output: "name 'crier' is not defined"
 
print(hurler())
# output: 'Yes!'

def parler():
 
    # On peut définir 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 appelé à l’intérieur 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’appelle 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ètre
def decorateur_tout_neuf(fonction_a_decorer):
 
    # En interne, le décorateur définit une fonction à la volée: le wrapper.
    # Le wrapper va enrober la fonction originale de telle sorte qu'il
    # puisse exécuter du code avant et après celle-ci
    def wrapper_autour_de_la_fonction_originale():
 
        # Mettre ici le code que l'on souhaite exécuter AVANT que la
        # fonction s’exécute
        print("Avant que la fonction ne s’exécute")
 
        # Apperler la fonction (en utilisant donc les parenthèses)
        fonction_a_decorer()
 
        # Mettre ici le code que l'on souhaite exécuter APRES que la
        # fonction s’exécute
        print("Après que la fonction se soit exécutée")
 
    # Arrivé ici, la "fonction_a_decorer" n'a JAMAIS ETE EXECUTEE
    # On retourne le wrapper que l'on vient de créer.
    # Le wrapper contient la fonction originale et le code à exé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 son 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’exécute
#Je suis une fonction intouchable, on ne me modifie pas !
#Après que la fonction se soit exécutée

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

@decorateur_tout_neuf
def fonction_intouchable():
    print("Me touche pas !")
 
fonction_intouchable()
#output:
#Avant que la fonction ne s’exécute
#Me touche pas !
#Après que la fonction se soit exé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(nourriture="--jambon--"):
    print(nourriture)
 
sandwich()
#output:
#</''''''\>
# #tomates#
# --jambon--
# ~salade~
#<\______/>

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