Est-il possible d'utiliser des fonctions avant de déclarer leur corps en python?

Question

Est-il possible de rendre possible l'utilisation de fonctions dans votre fichier avant de déclarer leur corps?

Le code suivant ne semble pas fonctionner:

abc = myFunction 

def myFunction(): 
    print "123" 

Merci

Answer 1

Vous ne pouvez pas utiliser la variable myFunction avant d'être affectée. Votre exemple de code est similaire à:

def myFunction(): 
    print abc 
    abc = 123 

Pour faire ce que vous voulez, que ce soit réarranger l'ordre:

def myFunction(): 
    print "123" 

abc = myFunction 

Ou déclarer abc comme un simple proxy:

# Style 1 
abc = lambda: myFunction() 

# Style 2 
def abc(): 
    return myFunction() 

def myFunction(): 
    print "123" 

Si votre fonction prend les paramètres, utilisez *args et **kwargs:

# Style 1 
abc = lambda *args, **kwargs: myFunction(*args, **kwargs) 

# Style 2 
def abc(*args, **kwargs): 
    return myFunction(*args, **kwargs) 

def myFunction(x): 
    print x 

Answer 2

réponse courte est non.

En Python, les instructions sont évaluées au fur et à mesure de l'analyse - myFunction n'a pas été analysé, ce qui fait que Python ne le sait pas.

Answer 3

Vous pouvez déclarer fonctions qui utilisent avant les déclarations, mais Python exécute le code dans votre source de haut en bas. Donc, cela compiler et exécuter:

def foo(): 
    print "in foo" 
    bar() 

def bar(): 
    print "in bar" 
    foo() 

foo() 

(sauf qu'il causerait un débordement de pile lors de l'exécution, bien sûr). Dans votre exemple, Python est exécution la ligne

abc = myFunction 

avant myFunction est définie comme tout. Vous pourriez penser à cela en termes de saisie interactive de votre code source dans l'interpréteur. Lorsque vous tapez dans votre affectation, vous n'auriez même pas tapé la définition de myFunction encore, de sorte que Python ne serait pas en mesure de se référer à elle.

Une autre façon de regarder cela pourrait être le suivant:

>>> myFunction = "hello" 
>>> abc = myFunction 
>>> def myFunction(): 
...  print "there" 
... 
>>> abc 
'hello' 
>>> myFunction 
<function myFunction at 0x63270> 
>>> myFunction() 
there 

Comme vous pouvez le voir, la définition de la fonction myFunction change juste la liaison du symbole myFunction à un objet de fonction.

Answer 4

Vous pouvez déclarer une fonction vide, l'utiliser pour définir des attributs ou quelque chose comme ça, puis modifier son code plus tard.

def myFunction(): 
    pass 

myFunction.foo = 'bar' 

def makeFunction(obj): 
    def myFunction(): 
     print "123" 

    f = myFunction 
    for attr in dir(obj): 
     if attr not in dir(f): 
      setattr(f, attr, getattr(obj, attr)) 

    return f 


myFunction = makeFunction(myFunction) 
myFunction() 
print myFunction.foo 

Answer 5

Python déclenche une NameError qu'il rencontre toute référence à un nom (jeton qui est une variable valide/classe/fonction/nom de l'objet) pour lequel il n'y avait pas de liaison précédente.

L'interpréteur Python exécute le code source d'un fichier lors de sa lecture.Ainsi, def foo(): est en réalité une instruction qui définit foo() lorsque le code est en cours de chargement.

Il est facile de penser que les références directes sont supportées. Considérez ceci:

def foo(): 
    return abc 

abc="FooBar, Dude" 

print foo() 

... et vous verrez qu'il peut être exécuté sans problèmes. Il est préférable de penser à la définition de foo() comme étant citée. Le contenu n'est pas évalué tant que la fonction n'est pas appelée. L'erreur NameError n'est donc pas levée (tant que certaines valeurs ont été liées au nom "abc" avant l'appel de la fonction.)

Notez que certaines de ces sémantiques sont suffisamment différentes de celles de Java, C/C++, et Perl que les Pythonistes préfèrent souvent utiliser une terminologie légèrement différente Les variables et autres sont appelés "noms" et le processus d'association de ceux avec des valeurs (ou, plus généralement, des objets) est appelé "liaison". "attribuer des valeurs aux variables" vous "liez les objets aux noms"

Les noms, en particulier pour les objets numériques simples ou de chaîne, sont appelés "variables" et les instructions telles que x='foo' sont appelées des affectations. assez similaire que nous w on s'en fout.