È possibile dichiarare in avanti una funzione in Python?

È possibile dichiarare in avanti una funzione in Python? Voglio ordinare un elenco usando la mia cmpfunzione prima che venga dichiarato.

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

Ho organizzato il mio codice per inserire la definizione del cmp_configsmetodo dopo l'invocazione. Non riesce con questo errore:

NameError: name 'cmp_configs' is not defined

C'è un modo per "dichiarare" cmp_configs metodo prima che venga utilizzato? Renderebbe il mio codice più pulito?

Presumo che alcune persone saranno tentate di dirmi che dovrei semplicemente riorganizzare il mio codice in modo da non avere questo problema. Tuttavia, ci sono casi in cui questo è probabilmente inevitabile, ad esempio quando si implementano alcune forme di ricorsione. Se non ti piace questo esempio, supponi che io abbia un caso in cui è davvero necessario inoltrare una funzione.

Considera questo caso in cui in Python sarebbe necessaria la dichiarazione in avanti di una funzione:

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

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

Dove end_conditione end_resultsono stati precedentemente definiti.

È l'unica soluzione per riorganizzare il codice e mettere sempre le definizioni prima delle invocazioni?

Se non si desidera definire una funzione prima che venga utilizzata e definirla successivamente è impossibile, che ne dici di definirla in qualche altro modulo?

Tecnicamente lo definisci ancora per primo, ma è pulito.

È possibile creare una ricorsione come la seguente:

def foo():
    bar()

def bar():
    foo()

Le funzioni di Python sono anonime proprio come i valori sono anonimi, ma possono essere associati a un nome.

Nel codice sopra, foo()non chiama una funzione con il nome pippo, chiama una funzione che sembra essere legata al nome foonel punto in cui viene effettuata la chiamata. È possibile ridefinire fooaltrove e barquindi chiamare la nuova funzione.

Il tuo problema non può essere risolto perché è come chiedere di ottenere una variabile che non è stata dichiarata.

Quello che puoi fare è avvolgere l'invocazione in una sua funzione.

Così che

foo()

def foo():
    print "Hi!"

si romperà, ma

def bar():
    foo()

def foo():
    print "Hi!"

bar()

funzionerà correttamente.

La regola generale in nonPython è che la funzione debba essere definita più in alto nel codice (come inPascal ), ma che dovrebbe essere definita prima del suo utilizzo.

Spero che aiuti.

Se avvii il tuo script in modo da avviare quanto segue:

if __name__=="__main__":
   main()

quindi probabilmente non devi preoccuparti di cose come "dichiarazione anticipata". Vedete, l'interprete dovrebbe caricare tutte le funzioni e quindi avviare la funzione main (). Certo, assicurati di aver corretto anche tutte le importazioni ;-)

Vieni a pensarci bene, non ho mai sentito una cosa come "dichiarazione anticipata" in Python ... ma poi di nuovo, potrei sbagliarmi ;-)

Se la chiamata a cmp_configs è all'interno della propria definizione di funzione, si dovrebbe andare bene. Faccio un esempio.

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.

In generale, inserire il codice all'interno di funzioni (come main ()) risolverà il problema; chiama main () alla fine del file.

Mi scuso per aver rilanciato questo thread, ma c'era una strategia non discussa qui che potrebbe essere applicabile.

Usando la riflessione è possibile fare qualcosa di simile per inoltrare la dichiarazione. Ad esempio, supponiamo che tu abbia una sezione di codice simile a questa:

# 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]()

Quindi in questo modo abbiamo determinato quale funzione vogliamo chiamare prima che sia effettivamente definita, effettivamente una dichiarazione a termine. In Python l'istruzione globals()[function_name]()è lo stesso che foo()se function_name = 'foo'per le ragioni discusse in precedenza, dal momento che deve pitone occhiata ogni funzione prima di chiamare. Se uno dovesse usare il timeitmodulo per vedere come si confrontano queste due affermazioni, esse hanno lo stesso costo computazionale.

Naturalmente l'esempio qui è molto inutile, ma se si dovesse avere una struttura complessa che doveva eseguire una funzione, ma deve essere dichiarata prima (o strutturalmente ha poco senso averla dopo), si può semplicemente memorizzare una stringa e prova a chiamare la funzione più tardi.

In Python non esiste nulla di simile alla dichiarazione diretta. Devi solo assicurarti che la tua funzione sia dichiarata prima che sia necessaria. Si noti che il corpo di una funzione non viene interpretato fino a quando la funzione non viene eseguita.

Considera il seguente esempio:

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.

Puoi pensare che un corpo di una funzione sia solo un altro script che verrà interpretato una volta chiamata la funzione.

No, non credo che ci sia modo di dichiarare in avanti una funzione in Python.

Immagina di essere l'interprete Python. Quando arrivi alla linea

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

o sai cos'è cmp_configs o no. Per procedere, devi conoscere cmp_configs. Non importa se c'è ricorsione.

A volte un algoritmo è più semplice da comprendere dall'alto verso il basso, a partire dalla struttura generale e dal dettaglio nei dettagli.

Puoi farlo senza dichiarazioni a termine:

def main():
  make_omelet()
  eat()

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

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

# ...

main()

# 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()

Produzione:

Hello, world!

Non è possibile dichiarare in avanti una funzione in Python. Se hai l'esecuzione della logica prima di aver definito le funzioni, probabilmente hai comunque un problema. Metti la tua azione in unif __name__ == '__main__' a alla fine del tuo script (eseguendo una funzione che chiami "main" se non è banale) e il tuo codice sarà più modulare e sarai in grado di usarlo come modulo se ne hai bisogno per.

Inoltre, sostituisci la comprensione di tale elenco con un generatore express (ovvero, print "\n".join(str(bla) for bla in sorted(mylist, cmp=cmp_configs)))

Inoltre, non utilizzare cmp, che è deprecato. Utilizzare keye fornire una funzione di meno di.

Importa il file stesso. Supponendo che il file si chiami test.py:

import test

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

"riorganizza il mio codice in modo da non avere questo problema." Corretta. Facile da fare. Funziona sempre

Puoi sempre fornire la funzione prima del suo riferimento.

"Tuttavia, ci sono casi in cui questo è probabilmente inevitabile, ad esempio quando si implementano alcune forme di ricorsione"

Non riesco a vedere come sia possibile anche da remoto. Fornire un esempio di un luogo in cui non è possibile definire la funzione prima del suo utilizzo.

Adesso aspetta un minuto. Quando il tuo modulo raggiunge l'istruzione print nel tuo esempio, prima che cmp_configssia stato definito, che cosa ti aspetti che faccia esattamente?

Se la pubblicazione di una domanda utilizzando print sta davvero cercando di rappresentare qualcosa del genere:

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

quindi non è necessario definire cmp_configs prima di eseguire questa istruzione, basta definirla più avanti nel codice e tutto andrà bene.

Ora, se stai provando a fare riferimento cmp_configscome valore predefinito di un argomento alla lambda, allora questa è una storia diversa:

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

Ora hai bisogno di una cmp_configsvariabile definita prima di raggiungere questa linea.

[EDIT: questa parte successiva risulta non corretta, poiché il valore dell'argomento predefinito verrà assegnato quando viene compilata la funzione e tale valore verrà utilizzato anche se si modifica il valore di cmp_configs in seguito.]

Fortunatamente, essendo Python così accomodante, non importa cosa si definisce cmp_configs, quindi si può semplicemente prefigurare questa affermazione:

cmp_configs = None

E il compilatore sarà felice. Assicurati di dichiarare il reale cmp_configsprima di invocare fn.

Un modo è creare una funzione gestore. Definisci il gestore in anticipo e metti il ​​gestore sotto tutti i metodi che devi chiamare.

Quindi, quando invochi il metodo del gestore per chiamare le tue funzioni, saranno sempre disponibili.

Il gestore potrebbe sostenere una discussione nameOfMethodToCall. Quindi utilizza una serie di istruzioni if ​​per chiamare il metodo giusto.

Ciò risolverebbe il tuo problema.

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)

Sì, possiamo verificarlo.

Ingresso

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()

Produzione

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.

Come BJ Homer ha menzionato sopra i commenti sopra, Una regola generale in Python non è che la funzione dovrebbe essere definita più in alto nel codice (come in Pascal), ma che dovrebbe essere definita prima del suo utilizzo.

Spero che aiuti.