Declarações de encaminhamento em Python para evitar erros de nome para funções definidas posteriormente

Em Python, tentar chamar uma função antes de ela ter sido definida pode resultar em um NameError. Embora a reorganização do código possa parecer a única solução, existem abordagens alternativas.

Um método é declarar antecipadamente uma função agrupando sua invocação em uma função separada. Isso permite que a função seja chamada antes de ser definida sem acionar um NameError.

Por exemplo, o código a seguir falhará:

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

Porque a função cmp_configs ainda não foi definida. Para declará-lo adiante, podemos agrupar a invocação:

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

forward_declare_cmp_configs()

def cmp_configs():
    ...

Agora, a função forward_declare_cmp_configs() pode ser chamada antes que cmp_configs() seja definido, e o código original será executado sem erros.

Outro cenário onde a declaração direta é útil é em funções recursivas. Por exemplo, o código a seguir falharia:

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

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

Para declarar encaminhar as chamadas recursivas, podemos usar uma abordagem de função aninhada:

def spam_outer():
    def spam_inner():
        if end_condition():
            return end_result()
        else:
            return eggs()

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

    return spam_inner()

spam_outer()()

Lembre-se, embora declarações futuras possam ser úteis, a regra geral em Python é definir uma função antes de seu primeiro uso.