Czy można zadeklarować dalej funkcję w Pythonie?

Czy można zadeklarować dalej funkcję w Pythonie? Chcę posortować listę za pomocą własnej cmpfunkcji, zanim zostanie zadeklarowana.

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

Zorganizowałem swój kod, aby wstawić definicję cmp_configsmetody po wywołaniu. Błąd tego błędu:

NameError: name 'cmp_configs' is not defined

Czy jest jakiś sposób na „zadeklarowanie” cmp_configsmetody przed jej użyciem? Czy dzięki temu mój kod będzie wyglądał na czystszy?

Zakładam, że niektórzy ludzie będą mieli ochotę powiedzieć mi, że powinienem po prostu zreorganizować swój kod, aby nie miałem tego problemu. Są jednak przypadki, w których jest to prawdopodobnie nieuniknione, na przykład przy wdrażaniu niektórych form rekurencji. Jeśli nie podoba ci się ten przykład, załóż, że mam przypadek, w którym naprawdę konieczne jest przekazanie dalej zadeklarowanej funkcji.

Rozważ ten przypadek, w którym w Pythonie konieczne byłoby przekazywanie funkcji do przodu:

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

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

Gdzie end_conditioni end_resultzostały wcześniej zdefiniowane.

Czy jedynym rozwiązaniem jest reorganizacja kodu i zawsze umieszczanie definicji przed wywołaniami?

Jeśli nie chcesz definiować funkcji przed jej użyciem, a późniejsze jej zdefiniowanie jest niemożliwe, co z definiowaniem jej w innym module?

Technicznie nadal definiujesz go jako pierwszy, ale jest czysty.

Możesz utworzyć rekurencję w następujący sposób:

def foo():
    bar()

def bar():
    foo()

Funkcje Pythona są anonimowe, podobnie jak wartości są anonimowe, ale można je przypisać do nazwy.

W powyższym kodzie foo()nie wywołuje funkcji o nazwie foo, wywołuje funkcję powiązaną z nazwą foow momencie wywołania. Można zdefiniować foogdzie indziej, a barnastępnie wywołać nową funkcję.

Twój problem nie może zostać rozwiązany, ponieważ przypomina prośbę o uzyskanie zmiennej, która nie została zadeklarowana.

Co możesz zrobić, to owinąć wywołanie we własną funkcję.

Po to aby

foo()

def foo():
    print "Hi!"

pęknie, ale

def bar():
    foo()

def foo():
    print "Hi!"

bar()

będzie działać poprawnie.

Ogólna zasada niePython polega na tym, że funkcja powinna być zdefiniowana wyżej w kodzie (jak w ), ale że należy ją zdefiniować przed użyciem.Pascal

Mam nadzieję, że to pomaga.

Jeśli uruchomisz skrypt w następujący sposób:

if __name__=="__main__":
   main()

wtedy prawdopodobnie nie musisz się martwić takimi sprawami jak „deklaracja przekazania”. Widzisz, interpreter ładuje wszystkie twoje funkcje, a następnie uruchamia twoją funkcję main (). Oczywiście upewnij się, że wszystkie importy również są poprawne ;-)

Pomyśl o tym, nigdy nie słyszałem czegoś takiego jak „deklaracja przekazania” w pythonie ... ale z drugiej strony, mogę się mylić ;-)

Jeśli wywołanie cmp_configs mieści się w jego własnej definicji funkcji, wszystko powinno być w porządku. Dam przykład.

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.

Zasadniczo umieszczenie kodu w funkcjach (takich jak main ()) rozwiąże problem; wystarczy wywołać main () na końcu pliku.

Przepraszam za ożywienie tego wątku, ale nie była tutaj omawiana strategia, która może mieć zastosowanie.

Za pomocą refleksji można zrobić coś podobnego do przekazania deklaracji. Załóżmy na przykład, że masz sekcję kodu, która wygląda następująco:

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

W ten sposób ustaliliśmy, jaką funkcję chcemy wywołać, zanim zostanie ona faktycznie zdefiniowana, w efekcie deklaracja przekazania. W python oświadczenie globals()[function_name]()jest taka sama, jak foo()gdyby function_name = 'foo'z powodów omówionych powyżej, ponieważ Python musi odnośnika każdą funkcję przed nazywając ją. Gdyby użyć timeitmodułu, aby zobaczyć porównanie tych dwóch instrukcji, mają one dokładnie taki sam koszt obliczeniowy.

Oczywiście przykład tutaj jest bardzo bezużyteczny, ale jeśli ktoś miałby mieć złożoną strukturę, która wymagałaby wykonania funkcji, ale musiałaby zostać zadeklarowana wcześniej (lub strukturalnie nie ma sensu mieć jej później), można po prostu zapisać ciąg znaków i spróbuj wywołać tę funkcję później.

W pythonie nie ma czegoś takiego jak deklaracja przesyłania dalej. Musisz tylko upewnić się, że twoja funkcja jest zadeklarowana, zanim będzie potrzebna. Zauważ, że treść funkcji nie jest interpretowana, dopóki funkcja nie zostanie wykonana.

Rozważ następujący przykład:

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.

Możesz pomyśleć, że ciało funkcji jest tylko kolejnym skryptem, który zostanie zinterpretowany po wywołaniu funkcji.

Nie, nie sądzę, aby w Pythonie można było zadeklarować dalej funkcję.

Wyobraź sobie, że jesteś interpretatorem języka Python. Kiedy dojdziesz do linii

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

albo wiesz, co to jest cmp_configs, albo nie. Aby kontynuować, musisz znać cmp_configs. Nie ma znaczenia, czy nastąpi rekurencja.

Czasami algorytm jest najłatwiejszy do zrozumienia z góry na dół, zaczynając od ogólnej struktury i przechodząc do szczegółów.

Możesz to zrobić bez deklaracji przesyłania dalej:

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

Wynik:

Hello, world!

Nie można zadeklarować do przodu funkcji w Pythonie. Jeśli masz logikę wykonywaną przed zdefiniowaniem funkcji, prawdopodobnie i tak masz problem. Umieść swoją akcję if __name__ == '__main__'na końcu skryptu (wykonując funkcję, którą nazwiesz „main”, jeśli nie jest trywialna), a twój kod będzie bardziej modułowy i będziesz mógł użyć go jako modułu, jeśli kiedykolwiek będziesz potrzebować do.

Zastąp też tę listę zrozumieniem generatora ekspresowego (tj. print "\n".join(str(bla) for bla in sorted(mylist, cmp=cmp_configs)))

Nie używaj również cmp, co jest przestarzałe. Użyj keyi podaj mniej niż funkcję.

Zaimportuj sam plik. Zakładając, że plik nazywa się test.py:

import test

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

„po prostu zreorganizuj mój kod, aby nie miałem tego problemu”. Poprawny. Proste do zrobienia. Zawsze działa.

Zawsze możesz podać funkcję przed jej odwołaniem.

„Są jednak przypadki, w których jest to prawdopodobnie nieuniknione, na przykład podczas wdrażania niektórych form rekurencji”

Nie widzę, jak to jest nawet możliwe. Podaj przykład miejsca, w którym nie można zdefiniować funkcji przed jej użyciem.

Teraz poczekaj chwilę. Kiedy Twój moduł osiągnie instrukcję print w twoim przykładzie, zanim cmp_configszostał zdefiniowany, czego dokładnie oczekujesz?

Jeśli Twoje pytanie za pomocą print naprawdę próbuje przedstawić coś takiego:

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

wtedy nie ma wymogu zdefiniowania cmp_configsprzed wykonaniem tej instrukcji, wystarczy zdefiniować ją później w kodzie i wszystko będzie dobrze.

Teraz, jeśli próbujesz odwołać się cmp_configsdo domyślnej wartości argumentu do lambda, to jest inna historia:

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

Teraz potrzebujesz cmp_configszdefiniowanej zmiennej, zanim dojdziesz do tej linii.

[EDYCJA - ta kolejna część okazuje się niepoprawna, ponieważ domyślna wartość argumentu zostanie przypisana podczas kompilacji funkcji, a ta wartość zostanie wykorzystana, nawet jeśli później zmienisz wartość cmp_configs.]

Na szczęście Python, który jest tak dostosowany do typów, nie przejmuje się tym , co definiujesz jako cmp_configs, więc możesz po prostu przedłożyć to zdanie:

cmp_configs = None

A kompilator będzie szczęśliwy. Pamiętaj tylko, aby zadeklarować prawdziwe, cmp_configszanim zaczniesz wzywać fn.

Jednym ze sposobów jest utworzenie funkcji modułu obsługi. Zdefiniuj moduł obsługi na wczesnym etapie i umieść moduł obsługi pod wszystkimi metodami, które musisz wywołać.

Następnie po wywołaniu metody modułu obsługi w celu wywołania funkcji będą one zawsze dostępne.

Przewodnik może wziąć argument nameOfMethodToCall. Następnie używa zestawu instrukcji if do wywołania właściwej metody.

To rozwiązałoby problem.

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)

Tak, możemy to sprawdzić.

Wejście

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

Wynik

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.

Jak wspomniano powyżej BJ Homer, ogólną zasadą w Pythonie nie jest to, że funkcja powinna być zdefiniowana wyżej w kodzie (jak w Pascalu), ale że należy ją zdefiniować przed użyciem.

Mam nadzieję, że to pomaga.