Définition de la fonction dans un fichier python indépendant de l'ordre

Question

J'utilise Python CGI. Je ne peux pas appeler une fonction avant qu'elle ne soit définie.

Dans Oracle PL/SQL, il y avait cette astuce de "forward statement": nommer toutes les fonctions par-dessus donc l'ordre de définition n'a pas d'importance.

Y a-t-il une telle astuce dans Python?

exemple:

def do_something(ds_parameter): 
    helper_function(ds_parameter) 
    .... 

def helper_function(hf_parameter): 
    .... 

def main(): 
    do_something(my_value) 

main() 

David a raison, mon exemple est erroné. Qu'en est- :

<start of cgi-script> 

def do_something(ds_parameter): 
    helper_function(ds_parameter) 
    .... 

def print_something(): 
    do_something(my_value) 

print_something() 

def helper_function(hf_parameter): 
    .... 

def main() 
    .... 

main() 

Puis-je « déclarer avant » les fonctions en haut du script?

Answer 1

Toutes les fonctions doivent être définies avant toute utilisation.

Cependant, les fonctions peuvent être définies dans n'importe quel ordre, à condition qu'elles soient toutes définies avant que tout code exécutable utilise une fonction.

Vous n'avez pas besoin de "forward statement" car toutes les déclarations sont complètement indépendantes les unes des autres. Tant que toutes les déclarations arrivent avant tout code exécutable.

Avez-vous un problème? Si oui, veuillez poster le code qui ne fonctionne pas. Dans votre exemple, print_something() est hors de propos.

La règle: Toutes les fonctions doivent être définies avant tout code qui fonctionne réel

Par conséquent, mettre toutes les déclarations qui ne fonctionnent dernier.

Answer 2

En supposant que vous ayez un fragment de code qui appelle votre fonction main après qu'elle a été définie, votre exemple fonctionne comme indiqué. En raison de la façon dont Python est interprété, les fonctions appelées par le corps de do_something n'ont pas besoin d'être définies lorsque la fonction do_something est définie.

Les étapes que Python suivra lors de l'exécution de votre code sont les suivantes.

1. Définissez la fonction do_quelquechose.
2. Définir la fonction helper_function.
3. Définir la fonction principale.
4. (Compte tenu de mon hypothèse ci-dessus) Appel principal.
5. De la main, appelez do_something.
6. De do_something, appelez helper_function.

La seule fois où Python se soucie que helper_function existe, c'est quand il arrive à l'étape six. Vous devriez être capable de vérifier que Python fait tout le chemin jusqu'à l'étape 6 avant de déclencher une erreur quand il essaie de trouver helper_function pour qu'il puisse l'appeler.

Answer 3

Je ne suis jamais tombé sur un cas où "forward-function-definition" est nécessaire .. Pouvez-vous simplement déplacer print_something() à l'intérieur de votre fonction principale ..?

def do_something(ds_parameter): 
    helper_function(ds_parameter) 
    .... 

def print_something(): 
    do_something(my_value) 


def helper_function(hf_parameter): 
    .... 

def main() 
    print_something() 
    .... 

main() 

Python n'est défini après son utilisation sur la ligne 3 (dans la fonction do_something)

Je recommande pas que les soins helper_function() en utilisant quelque chose comme WinPDB et pas à pas dans votre code. Il montre bien comment l'analyseur/exécuteur Python fonctionne

Answer 4

Une façon encore meilleure illustration de votre point serait (?):

def main(): 
    print_something() 
    .... 

def do_something(ds_parameter): 
    helper_function(ds_parameter) 
    .... 

def print_something(): 
    do_something(my_value) 


def helper_function(hf_parameter): 
    .... 


main() 

En d'autres termes, vous pouvez garder votre définition de main() en haut, pour l'édition commodité - éviter le défilement fréquent, si la plupart du temps est consacré à l'édition principale.

Answer 5

def funB(d,c): 
    return funA(d,c) 

print funB(2,3) 

def funA(x,y): 
    return x+y 

Le code ci-dessus renverra une erreur. Mais, le code suivant est bien ...

def funB(d,c): 
    return funA(d,c) 

def funA(x,y): 
    return x+y 

print funB(2,3) 

Alors, même si vous devez définir définitivement la fonction avant que le travail réel est fait, il est possible de sortir si vous n'utilisez la fonction explicitement. Je pense que cela ressemble un peu au prototypage dans d'autres langues.