Declaraciones directas en Python para evitar errores de nombre en funciones definidas más tarde

En Python, intentar llamar a una función antes de que se haya definido puede resultar en un error de nombre. Si bien la reorganización del código puede parecer la única solución, existen enfoques alternativos.

Un método consiste en declarar hacia adelante una función envolviendo su invocación dentro de una función separada. Esto permite llamar a la función antes de definirla sin activar un NameError.

Por ejemplo, el siguiente código fallará:

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

Porque la función cmp_configs aún no se ha definido. Para declararlo hacia adelante, podemos ajustar la invocación:

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

Ahora, la función forward_declare_cmp_configs() se puede llamar antes de que se defina cmp_configs(), y el código original se ejecutará sin errores.

Otro escenario donde la declaración directa es útil es en funciones recursivas. Por ejemplo, el siguiente código fallaría:

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

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

Para reenviar las llamadas recursivas, podemos usar un enfoque de función anidada:

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

Recuerde, si bien las declaraciones directas pueden ser útiles, la regla general en Python es definir una función antes de su primer uso.