Можно ли объявить функцию в Python?

Если вы не хотите определять функцию до ее использования, а определение ее после невозможно, как насчет определения ее в каком-то другом модуле?

Технически вы все равно сначала определяете его, но он чистый.

Вы можете создать рекурсию, подобную следующей:

def foo():
    bar()

def bar():
    foo()

Функции Python анонимны, как и значения, но их можно привязать к имени.

В приведенном выше коде foo() не вызывает функцию с именем foo, он вызывает функцию, которая оказывается привязанной к имени foo в точке выполнения вызова. Можно переопределить foo в другом месте, и тогда bar вызовет новую функцию.

Ваша проблема не может быть решена, потому что это все равно что попросить переменную, которая не была объявлена.

Что вы можете сделать, так это обернуть вызов в отдельную функцию.

Так что

foo()

def foo():
    print "Hi!"

сломается, но

def bar():
    foo()

def foo():
    print "Hi!"

bar()

будет работать правильно.

Общее правило в Python - не, что функция должна быть определена выше в коде (как в Pascal), а то, что она должна быть определена перед ее использованием.

Надеюсь, это поможет.

Если вы запустите свой скрипт следующим образом:

if __name__=="__main__":
   main()

тогда вам, вероятно, не придется беспокоиться о таких вещах, как «предварительное объявление». Видите ли, интерпретатор загрузит все ваши функции, а затем запустит вашу функцию main (). Конечно, убедитесь, что у вас также есть правильный импорт ;-)

Если подумать, я никогда не слышал такой вещи, как "предварительное объявление" в python ... но опять же, я могу ошибаться ;-)

Если вызов cmp_configs находится внутри определения его собственной функции, все должно быть в порядке. Приведу пример.

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.

В общем, размещение кода внутри функций (таких как main ()) решит вашу проблему; просто вызовите main () в конце файла.

В Python нет такой вещи, как форвардное объявление. Вам просто нужно убедиться, что ваша функция объявлена ​​до того, как она понадобится. Обратите внимание, что тело функции не интерпретируется, пока функция не будет выполнена.

Рассмотрим следующий пример:

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.

Вы можете думать, что тело функции - это просто еще один скрипт, который будет интерпретирован после того, как вы вызовете функцию.

Прошу прощения за возобновление этой ветки, но здесь не обсуждалась стратегия, которая может быть применима.

Используя отражение, можно сделать что-то вроде прямого объявления. Например, допустим, у вас есть фрагмент кода, который выглядит так:

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

Таким образом, мы определили, какую функцию мы хотим вызвать, до того, как она будет определена на самом деле, что фактически является предварительным объявлением. В python оператор globals()[function_name]() совпадает с foo(), если function_name = 'foo' по причинам, описанным выше, поскольку python должен искать каждую функцию перед ее вызовом. Если бы можно было использовать модуль timeit, чтобы увидеть, как эти два оператора сравниваются, у них были бы точно такие же вычислительные затраты.

Конечно, приведенный здесь пример очень бесполезен, но если бы у кого-то была сложная структура, которая необходима для выполнения функции, но должна быть объявлена ​​раньше (или структурно не имеет смысла иметь ее после), можно просто сохранить строку и попробуйте вызвать функцию позже.

Иногда алгоритм легче всего понять сверху вниз, начиная с общей структуры и заканчивая деталями.

Вы можете сделать это без предварительных объявлений:

def main():
  make_omelet()
  eat()

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

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

# ...

main()

Нет, я не верю, что есть способ объявить функцию в Python.

Представьте, что вы интерпретатор Python. Когда вы доберетесь до линии

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

либо вы знаете, что такое cmp_configs, либо нет. Чтобы продолжить, вы должны знать cmp_configs. Неважно, есть ли рекурсия.

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

Выход:

Hello, world!

Импортируйте сам файл. Предполагая, что файл называется test.py:

import test

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

Вы не можете напрямую объявить функцию в Python. Если у вас есть логика, выполняющаяся до того, как вы определили функции, у вас, вероятно, все равно есть проблема. Поместите свое действие в if __name__ == '__main__' в конце вашего скрипта (выполнив функцию, которую вы называете "main", если она нетривиальная), и ваш код будет более модульным, и вы сможете использовать его как модуль, если когда-нибудь нужно.

Кроме того, замените это понимание списка выражением генератора (т.е. print "\n".join(str(bla) for bla in sorted(mylist, cmp=cmp_configs)))

Также не используйте cmp, который устарел. Используйте key и укажите функцию «меньше чем».

«просто реорганизуйте мой код, чтобы у меня не было этой проблемы». Верный. Легко сделать. Всегда работает.

Вы всегда можете указать функцию до ссылки.

«Однако бывают случаи, когда это, вероятно, неизбежно, например, при реализации некоторых форм рекурсии»

Не понимаю, как это возможно хотя бы отдаленно. Приведите пример места, где вы не можете определить функцию до ее использования.

Подожди минутку. Когда ваш модуль достигает оператора печати в вашем примере до того, как cmp_configs был определен, что именно вы ожидаете от него?

Если ваша публикация вопроса с использованием print действительно пытается изобразить что-то вроде этого:

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

тогда нет необходимости определять cmp_configs перед выполнением этого оператора, просто определите его позже в коде, и все будет хорошо.

Теперь, если вы пытаетесь ссылаться на cmp_configs как на значение аргумента лямбда по умолчанию, то это другая история:

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

Теперь вам нужно определить переменную cmp_configs, прежде чем вы дойдете до этой строки.

[РЕДАКТИРОВАТЬ - эта следующая часть оказывается неверной, поскольку значение аргумента по умолчанию будет присвоено при компиляции функции, и это значение будет использоваться, даже если вы измените значение cmp_configs позже.]

К счастью, Python, будучи настолько адаптивным к типам, не заботится о том, что вы определяете как cmp_configs, поэтому вы можете просто начать с этого оператора:

cmp_configs = None

И компилятор будет доволен. Просто не забудьте объявить реальный cmp_configs, прежде чем вызывать fn.

TL; DR: Python не нуждается в форвардных объявлениях. Просто поместите вызовы функций в определения функций def, и все будет в порядке.

def foo(count):
    print("foo "+str(count))
    if(count>0):
        bar(count-1)

def bar(count):
    print("bar "+str(count))
    if(count>0):
        foo(count-1)

foo(3)
print("Finished.")

рекурсивная функция definitions, отлично дает:

foo 3
bar 2
foo 1
bar 0
Finished.

Тем не мение,

bug(13)

def bug(count):
    print("bug never runs "+str(count))

print("Does not print this.")

прерывает вызов верхнего уровня функции, которая еще не была определена, и дает:

Traceback (most recent call last):
  File "./test1.py", line 1, in <module>
    bug(13)
NameError: name 'bug' is not defined

Python - это интерпретируемый язык, как и Lisp. В нем нет проверки типов, только вызовы функций времени выполнения, которые завершаются успешно, если имя функции было привязано, и терпят неудачу, если оно не привязано.

Важно то, что определение функции def не выполняет какие-либо вызовы функций внутри своих строк, оно просто объявляет, из чего будет состоять тело функции. Опять же, он даже не проверяет типы. Итак, мы можем сделать это:

def uncalled():
    wild_eyed_undefined_function()
    print("I'm not invoked!")

print("Only run this one line.")

и он работает отлично (!), с выводом

Only run this one line.

Ключевым моментом является разница между определениями и вызовами.

Интерпретатор выполняет все, что поступает на верхнем уровне, что означает, что он пытается его вызвать. Если его нет внутри определения.
У вашего кода возникли проблемы, потому что вы пытались вызвать функцию, в данном случае на верхнем уровне, до того, как она была привязана.

Решение состоит в том, чтобы поместить вызовы функций не верхнего уровня в определение функции, а затем вызвать эту функцию гораздо позже.

Дело о if __ main __ - это идиома, основанная на этом принципе, но вы должны понимать почему, а не просто слепо следовать ей.

Конечно, есть гораздо более сложные темы, касающиеся лямбда-функций и динамического повторного связывания имен функций, но это не то, о чем просил OP. Кроме того, они могут быть решены с использованием тех же принципов: (1) defs определяют функцию, они не вызывают свои строки; (2) возникают проблемы, когда вы вызываете несвязанный символ функции.

Python не поддерживает форвардные объявления, но обычным обходным путем для этого является использование следующего условия в конце вашего скрипта / кода:

if __name__ == '__main__': main()

При этом он сначала прочитает весь файл, а затем оценит условие и вызовет функцию main (), которая сможет вызвать любую объявленную вперед функцию, поскольку она уже сначала прочитала весь файл. Это условие использует специальную переменную __name__, которая возвращает значение __main__ всякий раз, когда мы запускаем код Python из текущего файла (когда код был импортирован как модуль, тогда __name__ возвращает имя модуля).

Один из способов - создать функцию-обработчик. Определите обработчик заранее и поместите обработчик под всеми методами, которые вам нужно вызвать.

Затем, когда вы вызываете метод обработчика для вызова ваших функций, они всегда будут доступны.

Обработчик может принимать аргумент nameOfMethodToCall. Затем использует набор операторов if для вызова нужного метода.

Это решит вашу проблему.

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)

Да, мы можем это проверить.

Вход

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

Выход

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.

Как упоминал Б.Дж. Гомер над комментариями выше, общее правило в Python заключается не в том, что функция должна быть определена выше в коде (как в Паскале), а в том, что она должна быть определена перед ее использованием.

Надеюсь, это поможет.