É possível declarar adiante uma função no Python?

É possível declarar adiante uma função no Python? Quero classificar uma lista usando minha própria cmpfunção antes de ser declarada.

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

Organizei meu código para colocar a definição de cmp_configsmétodo após a invocação. Falha com este erro:

NameError: name 'cmp_configs' is not defined

Existe alguma maneira de "declarar" o cmp_configsmétodo antes de ser usado? Isso faria meu código parecer mais limpo?

Suponho que algumas pessoas ficarão tentadas a me dizer que eu deveria reorganizar meu código para não ter esse problema. No entanto, há casos em que isso provavelmente é inevitável, por exemplo, ao implementar algumas formas de recursão. Se você não gostar deste exemplo, suponha que eu tenha um caso em que é realmente necessário encaminhar declarar uma função.

Considere este caso em que uma função de declaração direta seria necessária no Python:

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

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

Onde end_conditione end_resultforam definidos anteriormente.

A única solução é reorganizar o código e sempre colocar definições antes das invocações?

Se você não deseja definir uma função antes que ela seja usada, e defini-la depois é impossível, que tal defini-la em outro módulo?

Tecnicamente, você ainda o define primeiro, mas é limpo.

Você pode criar uma recursão como a seguinte:

def foo():
    bar()

def bar():
    foo()

As funções do Python são anônimas, assim como os valores são anônimos, mas podem ser vinculados a um nome.

No código acima, foo()não chama uma função com o nome foo, chama uma função que por acaso está vinculada ao nome foono momento em que a chamada é feita. É possível redefinir fooem outro lugar e barchamaria a nova função.

Seu problema não pode ser resolvido porque é como pedir uma variável que não foi declarada.

O que você pode fazer é envolver a invocação em uma função própria.

De modo a

foo()

def foo():
    print "Hi!"

vai quebrar, mas

def bar():
    foo()

def foo():
    print "Hi!"

bar()

estará funcionando corretamente.

A regra geral em nãoPython é que a função deva ser definida mais alto no código (como em ), mas que ela deve ser definida antes de seu uso.Pascal

Espero que ajude.

Se você iniciar seu script com o seguinte:

if __name__=="__main__":
   main()

então você provavelmente não precisa se preocupar com coisas como "declaração direta". Veja bem, o intérprete carregaria todas as suas funções e depois iniciaria a função principal (). Obviamente, verifique também se todas as importações estão corretas ;-)

Venha para pensar sobre isso, eu nunca ouvi algo como "declaração direta" em python ... mas, novamente, eu posso estar errado ;-)

Se a chamada para cmp_configs estiver dentro de sua própria definição de função, você deve estar bem. Eu vou dar um exemplo.

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.

Em geral, colocar seu código dentro de funções (como main ()) resolverá seu problema; basta chamar main () no final do arquivo.

Peço desculpas por reviver esse tópico, mas houve uma estratégia não discutida aqui que pode ser aplicável.

Usando a reflexão, é possível fazer algo semelhante ao encaminhamento de declaração. Por exemplo, digamos que você tenha uma seção de código parecida com esta:

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

Portanto, dessa maneira, determinamos qual função queremos chamar antes que ela seja realmente definida, efetivamente uma declaração direta. Em python a declaração globals()[function_name]()é o mesmo que foo()se function_name = 'foo'pelas razões discutidas acima, uma vez python deve pesquisar cada função antes de chamá-lo. Se alguém usar o timeitmódulo para ver como essas duas instruções se comparam, elas têm exatamente o mesmo custo computacional.

É claro que o exemplo aqui é muito inútil, mas se alguém tiver uma estrutura complexa que precisa executar uma função, mas deve ser declarada antes (ou estruturalmente faz pouco sentido tê-la depois), pode-se simplesmente armazenar uma string e tente chamar a função mais tarde.

Não existe tal coisa em python como declaração direta. Você só precisa garantir que sua função seja declarada antes de ser necessária. Observe que o corpo de uma função não é interpretado até que a função seja executada.

Considere o seguinte exemplo:

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.

Você pode pensar que o corpo de uma função é apenas outro script que será interpretado quando você chamar a função.

Não, não acredito que exista uma maneira de declarar uma função no Python.

Imagine que você é o intérprete Python. Quando você chega na linha

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

ou você sabe o que é cmp_configs ou não. Para continuar, você precisa conhecer o cmp_configs. Não importa se há recursão.

Às vezes, um algoritmo é mais fácil de entender de cima para baixo, começando com a estrutura geral e detalhando os detalhes.

Você pode fazer isso sem declarações avançadas:

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

Resultado:

Hello, world!

Você não pode declarar adiante uma função no Python. Se você tem lógica executando antes de definir funções, provavelmente há algum problema. Coloque sua ação em umif __name__ == '__main__' no final do seu script (executando uma função denominada "main" se não for trivial) e seu código será mais modular e você poderá usá-lo como um módulo, se precisar. para.

Além disso, substitua a compreensão dessa lista por um gerador expresso (ou seja, print "\n".join(str(bla) for bla in sorted(mylist, cmp=cmp_configs)))

Além disso, não use cmp, que está obsoleto. Use keye forneça uma função menor que.

Importe o próprio arquivo. Supondo que o arquivo seja chamado test.py:

import test

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

"apenas reorganize meu código para não ter esse problema." Corrigir. Fácil de fazer. Sempre funciona.

Você sempre pode fornecer a função antes de sua referência.

"No entanto, há casos em que isso provavelmente é inevitável, por exemplo, ao implementar algumas formas de recursão"

Não vejo como isso é remotamente possível. Por favor, forneça um exemplo de um local onde você não pode definir a função antes de usá-la.

Agora espere um minuto. Quando seu módulo alcança a declaração de impressão em seu exemplo, antes de cmp_configsser definido, o que exatamente você espera que ele faça?

Se a postagem de uma pergunta usando print estiver realmente tentando representar algo como isto:

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

então não há nenhum requisito para definir cmp_configsantes de executar esta instrução, apenas defina-a posteriormente no código e tudo ficará bem.

Agora, se você está tentando fazer referência cmp_configscomo valor padrão de um argumento ao lambda, então esta é uma história diferente:

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

Agora você precisa de uma cmp_configsvariável definida antes de chegar a essa linha.

[EDIT - esta próxima parte não está correta, pois o valor padrão do argumento será atribuído quando a função for compilada e esse valor será usado mesmo se você alterar o valor de cmp_configs posteriormente.]

Felizmente, o Python é tão complacente quanto o tipo, não se importa com o que você define cmp_configs, então você pode apenas prefaciar esta declaração:

cmp_configs = None

E o compilador ficará feliz. Apenas certifique-se de declarar o real cmp_configsantes de invocar fn.

Uma maneira é criar uma função de manipulador. Defina o manipulador desde o início e coloque-o abaixo de todos os métodos que você precisa chamar.

Então, quando você chamar o método manipulador para chamar suas funções, elas sempre estarão disponíveis.

O manipulador pode ter uma discussão nameOfMethodToCall. Em seguida, usa várias instruções if para chamar o método certo.

Isso resolveria seu 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)

Sim, podemos verificar isso.

Entrada

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

Resultado

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.

Como BJ Homer mencionou nos comentários acima, uma regra geral no Python não é que a função deva ser definida mais alto no código (como no Pascal), mas que ela deve ser definida antes de seu uso.

Espero que ajude.