Exemples réels de fonctions imbriquées

Les décorateurs sont une utilisation très populaire pour les fonctions imbriquées. Voici un exemple de décorateur qui imprime une déclaration avant et après tout appel à la fonction décorée.

def entry_exit(f):
    def new_f(*args, **kwargs):
        print "Entering", f.__name__
        f(*args, **kwargs)
        print "Exited", f.__name__
    return new_f

@entry_exit
def func1():
    print "inside func1()"

@entry_exit
def func2():
    print "inside func2()"

func1()
func2()
print func1.__name__

Décorateurs Python

C'est en fait un autre sujet à apprendre, mais si vous regardez les trucs sur «Utilisation de fonctions comme décorateurs», vous verrez quelques exemples de fonctions imbriquées.

Fonctions imbriquées Évitez d'encombrer d'autres parties du programme avec d'autres fonctions et variables qui ne donnent aucun sens localement.

Une fonction de retour de Fibonacci pourrait être définie comme suit: P>

>>> def fib(n):
        def rec():
            return fib(n-1) + fib(n-2)

        if n == 0:
            return 0
        elif n == 1:
            return 1
        else:
            return rec()

>>> map(fib, range(10))
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Je n'ai eu qu'à utiliser des fonctions imbriquées lors de la création de décorateurs. Une fonction imbriquée est essentiellement une façon d'ajouter un comportement à une fonction sans savoir quelle est la fonction que vous ajoutez un comportement à. xxx pré>

ignorer tous les Mumbo Jumbo de la fonction "PrintCall" pour En ce moment et concentrez uniquement la fonction «Sayhello» et ci-dessous. Ce que nous faisons ici, c'est que nous voulons imprimer la manière dont la fonction "Sayhello" a été appelée à chaque fois qu'elle est appelée sans savoir ni modifier la fonction "Sayhello". Nous redéfinissons donc la fonction "Sayhello" en le passant à "PrintCall", qui renvoie une nouvelle fonction qui fait la fonction "Sayhello" et imprime la manière dont la fonction "Sayhello" a été appelée. C'est le concept de décorateurs. P>

Mettre "@printcall" au-dessus de la définition Sayhello accomplit la même chose: P>

@printCall
def sayHello(name):
   print "Hello, my name is %s" % (name)

if __name__ == "__main__":
   name = "Nimbuz"
   sayHello(name)

Votre question m'a fait curieux, alors j'ai regardé dans un code réel du monde: la bibliothèque standard Python. J'ai trouvé 67 exemples de fonctions imbriquées. Voici quelques-uns, avec des explications.

Une raison très simple d'utiliser une fonction imbriquée est simplement que la fonction que vous définissez n'a pas besoin d'être globale, car seule la fonction enfermante l'utilise. Un exemple typique de Python's Quopri.py standard Module de bibliothèque: P>

    def baba(xdummy, ydummy):
        clearscreen()
        bye()

    ...
    tri.write("  Click me!", font = ("Courier", 12, "bold") )
    tri.onclick(baba, 1)

Ils sont utiles lors de l'utilisation de fonctions qui prennent d'autres fonctions comme entrée. Dites que vous êtes dans une fonction et souhaitez trier une liste d'éléments basés sur la valeur d'éléments d'une dict: xxx

vous pouvez simplement définir clé droite Il y a une variable locale , une variable locale.

Un autre cas d'utilisation est des rappels.

OK, outre les décorateurs: dites que vous avez eu une application dans laquelle vous devez trier une liste de chaînes en fonction de sous-chaînes variant de temps à autre. Maintenant, les fonctions triés prend une clé = une fonction d'un argument: les éléments (chaînes dans ce cas) à trier. Alors, comment dire à cette fonction qui sous-tendent de trier? Une fonction de fermeture ou imbriquée est parfaite pour cela: xxx

simple eh? Vous pouvez étendre à ce sujet en encapsulant début et arrêtez-vous dans un tuple ou un objet de tranche, puis de transmettre une séquence ou irable de ceux-ci au tri_key_factory.

Un autre exemple (très simple). Une fonction qui renvoie une autre fonction. Notez comment la fonction interne (renvoyée) peut utiliser des variables de la portée de la fonction extérieure.

def create_adder(x):
   def _adder(y):
       return x + y
   return _adder

add2 = create_adder(2)
add100 = create_adder(100)

>>> add2(50)
52
>>> add100(50)
150