Est-il possible de déclarer une fonction en Python?

Est-il possible de déclarer une fonction en Python? Je veux trier une liste en utilisant ma propre cmp fonction avant qu'il ne soit déclaré.

print "\n".join([str(bla) for bla in sorted(mylist, cmp = cmp_configs)])

J'ai organisé mon code pour mettre la définition de cmp_configs méthode après l'invocation. Il échoue avec ce message d'erreur:

NameError: name 'cmp_configs' is not defined

Est-il un moyen de "déclarer" cmp_configs méthode avant qu'il est utilisé? Il serait de rendre mon code plus propre?

Je suppose que certaines personnes seront tentés de me dire que je devrais simplement réorganiser mon code pour que je n'ai pas ce problème. Cependant, il ya des cas où c'est probablement inévitable, par exemple lors de la mise en œuvre de certaines formes de la récursivité. Si vous n'aimez pas cet exemple, supposons que j'ai un cas dans lequel il est vraiment nécessaires pour déclarer une fonction.

Voici un cas où l'avant-déclaration d'une fonction serait nécessaire en Python:

def spam():
    if end_condition():
        return end_result()
    else:
        return eggs()

def eggs():
    if end_condition():
        return end_result()
    else:
        return spam()

Où end_condition et end_result ont été définis précédemment.

Est la seule solution pour réorganiser le code et toujours mettre définitions avant d'invocations?

InformationsquelleAutor Nathan Fellman | 2009-10-19

forward-declaration python

73

Si vous ne voulez pas définir une fonction avant il est utilisé, et la définition qu'il après est impossible, qu'en la définissant dans un autre module?

Techniquement, vous avez encore le définir en premier, mais c'est propre.

Vous pouvez créer une récursivité comme suit:
```
def foo():
    bar()

def bar():
    foo()
```
Python fonctions sont anonymes, tout comme les valeurs sont anonymes, mais ils peuvent être liées à un nom.

Dans le code ci-dessus, foo() ne pas appeler une fonction avec le nom toto, il appelle une fonction qui se trouve être lié au nom de foo au moment de l'appel. Il est possible de redéfinir foo quelque part d'autre, et bar appelait alors la nouvelle fonction.

Votre problème ne peut être résolu, car il est comme demander à obtenir une variable qui n'a pas été déclaré.
- en bref, si vous avez des if __name__ == '__principaux__': main() sur la dernière ligne de votre script tout ira bien!
- Je n'ai pas compris votre commentaire: pourquoi ne pas vous mettre la dernière ligne du code que simplement main() ?
- pour éviter d'exécution sur import your_module
- Je voudrais ajouter - il est parfois possible de contourner ces problèmes en utilisant des lambdas, car ils sont évalués à plus tard.
- W. r.t. "anonyme", vous vraiment dire "les objets de première classe".
- J'espère que vous êtes heureux avec mes modifications. Si il n'y avait pas la confusion entre déclarer et définir, je l'ai laissé seul. Je pense que votre réponse aurait pu le faire sans l'explication sur les valeurs anonymes, car elle permettra de confondre les gens et il la fait ressembler vous ne comprenez pas bien de quoi vous parlez. Moment de l'exécution des modifications de la table des symboles sont pas à la question et vous devriez avoir ignoré il.
- Qu'entendez-vous par "tout ira bien"? Quel problème est-ce que cela est censé résoudre?
- vous ne savez pas exactement ce que j'avais dans mon 7 ans auparavant, mais c'était probablement quelque chose autour de ce que l'OP a cette ligne en dehors d'une fonction. Si le code est à l'intérieur d'une fonction, et la dernière ligne du script/module appelle le point d'entrée (généralement main()) il n'y a pas besoin de s'inquiéter à propos de l'ordre des fonctions sont déclarées comme, à ce point (dernière ligne), tous ont été définis
- Ouais, 7 ans est un temps assez long. De toute façon, peut-être qu'il n'résoudre le problème lorsque vous utilisez des fonctions, mais je termine mon script avec if __name__ == '__main__': main() (bien que pas sur une seule ligne) et j'ai le même problème que l'OP. Je suis en train d'essayer d'accéder à une fonction dans une catégorie que j'ai définie ci-dessus, la fonction, si; c'est peut-être affecter le comportement.
- Je crains que je ne peux pas commenter sans voir le code réel, mais seulement si vous appelez une fonction dans une autre fonction, alors c'est toujours après qu'il a été déclaré...
- Que voulez-vous dire par "c'est toujours après qu'il a été déclaré"? Ce ne les deux "il" se réfèrent aux?
- "Le problème ne peut être résolu, car il est comme demander à obtenir une variable qui n'a pas été déclaré." Eh bien, il peut être résolu dans les langues distinctes de la déclaration des objets à partir de leurs définitions.
- La manière de l'extrait de code qui est montré ici est source de confusion. Ma première impression a été que cela signifie de dire quelque chose comme cela pourrait être fait -- alors que l'intention est de montrer une telle construction n'est pas possible à cause de l'erreur a expliqué par la suite.
InformationsquelleAutor RichN
101

Ce que vous pouvez faire est d'envelopper l'invocation en fonction de sa propre.

De sorte que
```
foo()

def foo():
    print "Hi!"
```
va casser, mais
```
def bar():
    foo()

def foo():
    print "Hi!"

bar()
```
sera de travailler correctement.

Règle générale dans Python est pas que la fonction devrait être défini plus haut dans le code (comme dans Pascal), mais qu'elle doit être définie avant son utilisation.

Espère que ça aide.
- +1 la plupart de réponse directe, avec la clé de voûte du concept: Pascal=définir plus, Python=définir plus tôt.
- C'est la bonne réponse, il explique également pourquoi le if __name__=="__main__": solution fonctionne.
- Si je comprends bien, cela signifie que l'opération de spam() et les œufs() par exemple est très bien comme il est écrit. Est-ce exact?
- oui, c'est très bien comme il est écrit
InformationsquelleAutor Vanya
87

Si vous lancer votre script par le suivant:
```
if __name__=="__main__":
   main()
```
alors vous n'avez probablement pas à vous soucier de choses comme la "déclaration anticipée". Voyez-vous, l'interprète aller le chargement de toutes vos fonctions et de démarrer votre fonction main (). Bien sûr, assurez-vous que vous disposez de toutes les importations correct aussi 😉

Venez pour penser à elle, je n'ai jamais entendu une chose telle que la "déclaration anticipée" en python... mais encore une fois, j'ai peut-être tort 😉
- +1 la plupart des pratiques réponse: Si vous mettez ce code dans le bas de la ultrapériphériques fichier source, puis vous êtes libre de définir dans n'importe quel ordre.
- Grand conseil; m'aide vraiment, comme j'ai beaucoup plus préfèrent les "top-down" de la programmation ou le fond vers le haut.
InformationsquelleAutor jldupont

Si l'appel à cmp_configs est à l'intérieur de sa propre définition de la fonction, vous devriez être bien. Je vais vous donner un exemple.

def a():
  b()  # b() hasn't been defined yet, but that's fine because at this point, we're not
       # actually calling it. We're just defining what should happen when a() is called.

a()  # This call fails, because b() hasn't been defined yet, 
     # and thus trying to run a() fails.

def b():
  print "hi"

a()  # This call succeeds because everything has been defined.

En général, de mettre votre code à l'intérieur de fonctions (telles que le main()) permettra de résoudre votre problème; il suffit d'appeler main() à la fin du fichier.

InformationsquelleAutor BJ Homer

10

Je m'excuse pour la relance de ce fil, mais il y a une stratégie qui n'est pas discutée ici, qui peut être applicable.

À l'aide de réflexion, il est possible de faire quelque chose de semblable à l'avant de la déclaration. Par exemple, disons que vous avez une section de code qui ressemble à ceci:
```
# We want to call a function called 'foo', but it hasn't been defined yet.
function_name = 'foo'
# Calling at this point would produce an error

# Here is the definition
def foo():
    bar()

# Note that at this point the function is defined
    # Time for some reflection...
globals()[function_name]()
```
Donc, de cette façon, nous avons déterminé quelle est la fonction que nous voulons appeler avant, il est en fait défini, de manière efficace d'une déclaration anticipée. En python la déclaration globals()[function_name]() est le même que foo() si function_name = 'foo' pour les raisons évoquées ci-dessus, depuis le python doivent de recherche de chaque fonction avant de l'appeler. Si l'on devait utiliser le timeit module de voir comment ces deux états comparer, ils ont exactement le même coût de calcul.

Bien sûr, l'exemple ici est très inutile, mais si on veut disposer d'une structure complexe qui nécessaire à l'exécution d'une fonction, mais doit être déclarée avant (ou structurellement, il fait peu de sens par la suite), on peut enregistrer une chaîne et d'essayer d'appeler la fonction plus tard.

InformationsquelleAutor KGardevoir
7

Non, je ne crois pas qu'il existe un moyen de transmettre la déclaration d'une fonction en Python.

Imaginez que vous êtes l'interpréteur Python. Lorsque vous arrivez à la ligne
```
print "\n".join([str(bla) for bla in sorted(mylist, cmp = cmp_configs)])
```
soit vous savez ce qu'cmp_configs est ou on ne l'est pas. Afin de procéder, vous devez
savoir cmp_configs. Il n'a pas d'importance si il y a récursivité.
- eh bien, c'est si votre seulement de faire passer le code. Certains compilateurs (et je me rends compte de python dans interprété) faire deux passes, de sorte que ces choses peuvent être compris. l'avant-déclaration, ou au moins un certain type de l'étendue de la découverte, ce serait vraiment bien.
InformationsquelleAutor unutbu
7

Il n'y a pas une telle chose en python comme la déclaration anticipée. Vous avez juste à vous assurer que votre fonction est déclarée avant est nécessaire.
Notez que le corps d'une fonction n'est pas interprété jusqu'à ce que la fonction est exécutée.

Considérons l'exemple suivant:
```
def a():
   b() # won't be resolved until a is invoked.

def b(): 
   print "hello"

a() # here b is already defined so this line won't fail.
```
Vous pouvez penser qu'un corps d'une fonction est un autre script qui sera interprété une fois que vous appelez la fonction.

InformationsquelleAutor Piotr Czapla
6

Parfois un algorithme est plus facile à comprendre de haut en bas, en commençant par l'ensemble de la structure et de forage vers le bas dans les détails.

Vous pouvez le faire sans déclaration:
```
def main():
  make_omelet()
  eat()

def make_omelet():
  break_eggs()
  whisk()
  fry()

def break_eggs():
  for egg in carton:
    break(egg)

# ...

main()
```
InformationsquelleAutor funroll
3

Vous ne pouvez pas transmettre la déclaration d'une fonction en Python. Si vous disposez d'une logique d'exécution avant d'avoir défini les fonctions, vous avez probablement un problème de toute façon. Mettez votre action dans un if __name__ == '__main__' à la fin de votre script (par l'exécution d'une fonction, vous nom "principale" si c'est non-trivial) et de votre code plus modulaire et vous serez capable de l'utiliser comme un module, si jamais vous avez besoin de.

Aussi, remplacez-la compréhension de liste avec un générateur express (c'est à dire, print "\n".join(str(bla) for bla in sorted(mylist, cmp=cmp_configs)))

Aussi, ne pas utiliser cmp, qui est obsolète. Utilisation key et de fournir un moins-que la fonction.
- Comment puis-je fournir un moins-que la fonction?
- Au lieu de cmp_configs, vous définissez une fonction qui prend deux arguments et renvoie True si le premier est inférieur au second, et False sinon.
- Pour ceux d'entre nous à venir à partir d'un C-comme arrière-plan, il n'y a rien de déraisonnable à propos de la logique d'exécution avant de fonctions sont définies. Pense: "multi-pass compilateur". Parfois, il faut un certain temps pour s'adapter aux nouvelles langues 🙂
InformationsquelleAutor Mike Graham

Importer le fichier lui-même. En supposant que le fichier est appelé test.py:

import test

if __name__=='__main__':
    test.func()
else:
    def func():
        print('Func worked')

InformationsquelleAutor user10488833

# declare a fake function (prototype) with no body
def foo(): pass

def bar():
    # use the prototype however you see fit
    print(foo(), "world!")

# define the actual function (overwriting the prototype)
def foo():
    return "Hello,"

bar()

De sortie:

Hello, world!

InformationsquelleAutor jmurphy61

0

"juste réorganiser mon code pour que je n'ai pas ce problème." Correct. Facile à faire. Fonctionne toujours.

Vous pouvez toujours fournir la fonction au préalable de référence.

"Cependant, il y a des cas où cela est probablement inévitable, par exemple lors de la mise en œuvre de certaines formes de la récursivité"

Ne vois pas comment c'est même à distance possible. Veuillez fournir un exemple d'un endroit où vous ne pouvez pas définir la fonction avant de l'utiliser.
- J'ai une telle situation. Je suis en train de passer dans une fonction de décorateur, et les types sont définis plus bas du module. Je ne peux pas déplacer la délinquance types d', parce que ce serait briser la chaîne d'héritage.
- Je l'ai fixée par le passage d'un lambda de mon décorateur au lieu de le type réel; mais je ne sais pas comment résoudre le problème autrement (qui ne m'obligent à réorganiser mon héritage)
InformationsquelleAutor S.Lott
0

Maintenant, attendez une minute. Lorsque votre module atteint l'impression instruction dans votre exemple, avant de cmp_configs a été défini, ce qui est exactement ce que vous attendez d'elle?

Si votre publication d'une question à l'aide de l'impression est vraiment essayer de représenter quelque chose comme ceci:
```
fn = lambda mylist:"\n".join([str(bla)
                         for bla in sorted(mylist, cmp = cmp_configs)])
```
alors il n'est pas nécessaire de définir cmp_configs avant l'exécution de cette instruction, il suffit de définir plus tard dans le code et tout ira bien.

Maintenant, si vous essayez de référence cmp_configs comme valeur par défaut d'un argument pour le lambda, alors c'est une autre histoire:
```
fn = lambda mylist,cmp_configs=cmp_configs : \
    "\n".join([str(bla) for bla in sorted(mylist, cmp = cmp_configs)])
```
Maintenant, vous avez besoin d'un cmp_configs variable définie avant d'arriver à cette ligne.

[EDIT - la partie qui s'avère ne pas être correcte, parce que l'argument par défaut la valeur assignée lorsque la fonction est compilé, et cette valeur sera utilisé même si vous modifiez la valeur de cmp_configs plus tard.]

Heureusement, Python étant de type accueillir comme il est, ne se soucie pas ce que vous définissez comme cmp_configs, de sorte que vous pouvez simplement préface à la présente déclaration:
```
cmp_configs = None
```
Et le compilateur va être heureux. Juste être sûr de déclarer le véritable cmp_configs avant de vous jamais invoquer fn.

InformationsquelleAutor PaulMcG
-1

Une façon est de créer une fonction de gestionnaire. Définir le gestionnaire d'tôt, et de mettre le gestionnaire ci-dessous toutes les méthodes que vous devez appeler.

Ensuite, lorsque vous appelez la méthode de gestionnaire d'appeler vos fonctions, ils seront toujours disponibles.

Le gestionnaire peut prendre un argument nameOfMethodToCall. Utilise ensuite un tas de si les déclarations d'appeler la bonne méthode.

Cela devrait résoudre votre problème.
```
def foo():
    print("foo")
    #take input
    nextAction=input('What would you like to do next?:')
    return nextAction

def bar():
    print("bar")
    nextAction=input('What would you like to do next?:')
    return nextAction

def handler(action):
    if(action=="foo"):
        nextAction = foo()
    elif(action=="bar"):
        nextAction = bar()
    else:
        print("You entered invalid input, defaulting to bar")
        nextAction = "bar"
    return nextAction

nextAction=input('What would you like to do next?:')

while 1:
    nextAction = handler(nextAction)
```
- qui semble très unpythonic. Python doit gérer ce genre de choses par lui-même.
- re-lecture de la accepté de répondre. Python n'a pas besoin de la fonction définie jusqu'à ce que vous appel, de ne pas l'utiliser dans une définition.
InformationsquelleAutor obesechicken13
-3

Oui, on peut vérifier cela.

D'entrée
```
print_lyrics() 
def print_lyrics():

    print("I'm a lumberjack, and I'm okay.")
    print("I sleep all night and I work all day.")

def repeat_lyrics():
    print_lyrics()
    print_lyrics()
repeat_lyrics()
```
De sortie
```
I'm a lumberjack, and I'm okay.
I sleep all night and I work all day.
I'm a lumberjack, and I'm okay.
I sleep all night and I work all day.
I'm a lumberjack, and I'm okay.
I sleep all night and I work all day.
```
Comme BJ Homer mentionné plus de commentaires ci-dessus, Une règle générale en Python n'est pas que la fonction devrait être défini plus haut dans le code (comme en Pascal), mais qu'elle doit être définie avant son utilisation.

Espère que ça aide.
- N'est-ce pas print_lyrics() appelé (utilisé), ligne 1, avant qu'elle soit définie? J'ai copié ce bout de code et essayé de l'exécuter, et il me donne l'erreur NameError: name 'print_lyrics' is not defined sur la Ligne 1. Pouvez-vous expliquer cela?
InformationsquelleAutor Satish Reddy Venkannagari

Vous devez vous connecter pour publier un commentaire.

D'entrée

De sortie