¿Qué hace if __name__ == “__main__”: hacer en Python?

¿Qué hace esto, y por qué se debe incluir el if ¿declaración?

if __name__ == "__main__":
    print("Hello, World!")

---

_{Si está tratando de cerrar una pregunta en la que alguien debería estar usando esta expresión y no lo está, considere cerrarla como un duplicado de ¿Por qué Python ejecuta mi módulo cuando lo importo y cómo lo detengo? en cambio. Para preguntas en las que alguien simplemente no ha llamado a ninguna función, o espera incorrectamente una función llamada main para ser usado como un punto de entrada automáticamente, use ¿Por qué no se ejecuta la función main() cuando inicio un script de Python? ¿Dónde comienza a ejecutarse el script?.}

Cuando su secuencia de comandos se ejecuta pasándola como un comando al intérprete de Python,

python myscript.py

todo el código que está en el nivel de sangría 0 se ejecuta. Las funciones y clases que están definidas están, bueno, definidas, pero ninguno de sus códigos se ejecuta. A diferencia de otros idiomas, no hay main() función que se ejecuta automáticamente – la main() La función es implícitamente todo el código en el nivel superior.

En este caso, el código de nivel superior es un if bloquear. __name__ es una variable integrada que se evalúa como el nombre del módulo actual. Sin embargo, si un módulo se ejecuta directamente (como en myscript.py arriba), entonces __name__ en su lugar se establece en la cadena "__main__". Por lo tanto, puede probar si su script se está ejecutando directamente o si lo está importando otra cosa probando

if __name__ == "__main__":
    ...

Si su secuencia de comandos se está importando a otro módulo, se importarán sus diversas funciones y definiciones de clase y se ejecutará su código de nivel superior, pero el código en el cuerpo de entonces del if la cláusula anterior no se ejecutará ya que no se cumple la condición. Como ejemplo básico, considere los siguientes dos scripts:

# file one.py
def func():
    print("func() in one.py")

print("top-level in one.py")

if __name__ == "__main__":
    print("one.py is being run directly")
else:
    print("one.py is being imported into another module")

# file two.py
import one

print("top-level in two.py")
one.func()

if __name__ == "__main__":
    print("two.py is being run directly")
else:
    print("two.py is being imported into another module")

Ahora, si invocas al intérprete como

python one.py

La salida será

top-level in one.py
one.py is being run directly

Si tu corres two.py en cambio:

python two.py

Usted obtiene

top-level in one.py
one.py is being imported into another module
top-level in two.py
func() in one.py
two.py is being run directly

Así, cuando el módulo one se carga, es __name__ es igual "one" en vez de "__main__".

Lo que hace el if __name__ == "__main__": ¿hacer?

Para resumir lo básico:

• La variable global, __name__en el módulo que es el punto de entrada a su programa, es '__main__'. De lo contrario, es el nombre con el que importa el módulo.

• Por lo tanto, codifique bajo el if El bloque solo se ejecutará si el módulo es el punto de entrada a su programa.

• Permite que el código en el módulo sea importado por otros módulos, sin ejecutar el bloque de código debajo de la importación.

---

¿Porqué necesitamos esto?

Desarrollo y prueba de su código

Digamos que está escribiendo un script de Python diseñado para usarse como un módulo:

def do_important():
    """This function does something very important"""

Tú pudo pruebe el módulo agregando esta llamada de la función al final:

do_important()

y ejecutarlo (en un símbolo del sistema) con algo como:

~$ python important.py

El problema

Sin embargo, si desea importar el módulo a otro script:

import important

En la importación, el do_important se llamaría a la función, por lo que probablemente comentaría su llamada a la función, do_important()en el fondo.

# do_important() # I must remember to uncomment to execute this!

Y luego tendrá que recordar si ha comentado o no su llamada de función de prueba. Y esta complejidad adicional significaría que es probable que lo olvide, haciendo que su proceso de desarrollo sea más problemático.

Una mejor manera

los __name__ La variable apunta al espacio de nombres dondequiera que se encuentre el intérprete de Python en este momento.

Dentro de un módulo importado, es el nombre de ese módulo.

Pero dentro del módulo principal (o una sesión interactiva de Python, es decir, Read, Eval, Print Loop o REPL del intérprete) está ejecutando todo, desde su "__main__".

Entonces, si verifica antes de ejecutar:

if __name__ == "__main__":
    do_important()

Con lo anterior, su código solo se ejecutará cuando lo esté ejecutando como el módulo principal (o lo llame intencionalmente desde otro script).

Una manera aún mejor

Sin embargo, hay una forma Pythonic de mejorar esto.

¿Qué pasa si queremos ejecutar este proceso comercial desde fuera del módulo?

Si ponemos el código que queremos ejercitar mientras desarrollamos y probamos en una función como esta y luego hacemos nuestra verificación de '__main__' inmediatamente despues:

def main():
    """business logic for when running this module as the primary one!"""
    setup()
    foo = do_important()
    bar = do_even_more_important(foo)
    for baz in bar:
        do_super_important(baz)
    teardown()

# Here's our payoff idiom!
if __name__ == '__main__':
    main()

Ahora tenemos una función final para el final de nuestro módulo que se ejecutará si ejecutamos el módulo como módulo principal.

Permitirá que el módulo y sus funciones y clases se importen a otros scripts sin ejecutar el main función, y también permitirá que el módulo (y sus funciones y clases) se llame cuando se ejecuta desde un diferente '__main__' módulo, es decir

import important
important.main()

Esta expresión también se puede encontrar en la documentación de Python en una explicación de la __main__ módulo. Ese texto dice:

Este módulo representa el ámbito (de otro modo anónimo) en el que se ejecuta el programa principal del intérprete: los comandos se leen desde la entrada estándar, desde un archivo de script o desde un indicador interactivo. Es este entorno en el que la estrofa idiomática de “script condicional” hace que se ejecute un script:

if __name__ == '__main__':
    main()

if __name__ == "__main__" es la parte que se ejecuta cuando el script se ejecuta desde (digamos) la línea de comando usando un comando como python myscript.py.

Que hace if __name__ == "__main__": ¿hacer?

__name__ es una variable global (en Python, global en realidad significa en el nivel de módulo) que existe en todos los espacios de nombres. Suele ser el nombre del módulo (como str escribe).

Sin embargo, como único caso especial, en cualquier proceso de Python que ejecute, como en mycode.py:

python mycode.py

al espacio de nombres global anónimo se le asigna el valor de '__main__' a su __name__.

Así, incluyendo las lineas finales

if __name__ == '__main__':
    main()

• al final de su secuencia de comandos mycode.py,
• cuando es el módulo principal de punto de entrada que ejecuta un proceso de Python,

hará que su secuencia de comandos esté definida de forma única main función a ejecutar.

Otro beneficio de usar esta construcción: también puede importar su código como un módulo en otro script y luego ejecutar la función principal cuando su programa lo decida:

import mycode
# ... any amount of other code
mycode.main()