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

Est-il un moyen de le rendre possible à utiliser les fonctions de votre fichier avant de vous déclarer leur corps?

Le code suivant ne semble pas fonctionner:

abc = myFunction

def myFunction():
    print "123"

Grâce

OriginalL'auteur devoured elysium | 2009-12-15

python

18

Vous ne pouvez pas utiliser la myFunction variable avant d'être affecté. Votre code d'exemple est similaire à:
```
def myFunction():
    print abc
    abc = 123
```
De faire ce que vous souhaitez, réorganiser l'ordre:
```
def myFunction():
    print "123"

abc = myFunction
```
Ou de 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 en 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
```
Salut. Je me demandais si il y avait un moyen d'utiliser le style # 1 pour les fonctions qui acceptent des arguments. merci
Pradyot: Utilisation *args et *kwargs. abc = lambda *args, **kwargs: mafonction(*args, **kwargs)

OriginalL'auteur John Millikin
13

Vous pouvez déclarer les fonctions qui utilisent des déclarations de l'avant, mais Python exécute le code dans votre source de haut en bas. Donc, ce serait de compiler et d'exécuter:
```
def foo():
    print "in foo"
    bar()

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

foo()
```
(sauf qu'il serait de provoquer un débordement de pile lors de l'exécution, bien sûr). Dans votre exemple, le Python est l'exécution de la ligne
```
abc = myFunction
```
avant myFunction est défini comme quoi que ce soit. Vous pourriez penser en termes de saisie de votre code source de manière interactive dans l'interprète. Lorsque vous tapez dans votre mission, vous n'auriez pas le même tapé dans la définition de myFunction, de sorte que Python ne serait pas en mesure de les consulter.

Une autre façon de regarder ce qui 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 myFunction fonction des changements de la liaison du symbole myFunction à une fonction d'objet.

+1: très lucide explication!

OriginalL'auteur Greg Hewgill
1

réponse courte est non.

En Python, les relevés sont évalués comme ils sont analysées - myFunction n'était pas analysée afin de Python ne sait pas à ce sujet.

Est-il une réponse?
Quelle est la réponse?
... si seulement il y avait un "enregistrer le brouillon" option sur SO...

OriginalL'auteur jldupont

Vous pouvez déclarer une fonction vide, l'utiliser pour définir des attributs ou quelque chose comme cela, et puis le modifier 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

OriginalL'auteur jbochi

1

Python de soulever un 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 a pas de précédent de liaison.

L'interpréteur Python exécute le code source d'un fichier tel qu'il se lit. Ainsi def foo(): est en fait une déclaration qui définit foo() que le code est en cours de chargement.

Il est facile de penser que les références sont pris en charge. 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() que d'être cités. Le contenu ne sont pas évaluées jusqu'à ce que la fonction est appelée. Ainsi, le NameError n'est pas soulevée (à condition qu'une valeur a été lié au nom "abc" avant l'appel à la fonction.

Remarquer que certaines de ces règles sont suffisamment différents de ceux de langues comme Java, C/C++, Perl et que les Pythoneux préfèrent souvent utiliser légèrement différente de la terminologie. Variables sont appelés "noms" et le processus d'associer les personnes avec des valeurs (ou, plus généralement, les objets) est dénommé "contraignantes". Ainsi, au lieu de "l'affectation de valeurs à des variables" vous êtes "la liaison des objets de noms."

De manière informelle les noms, surtout pour de simples numérique ou une chaîne d'objets, sont appelés "variables" et des déclarations telles que x='foo' sont appelés les affectations. La sémantique est généralement assez similaire que nous ne de soins.

OriginalL'auteur Jim Dennis

Vous devez vous connecter pour publier un commentaire.