¿Qué hace `si __nombre__ == "__main__":`?

Cuando tu script se ejecuta pasándolo como un comando al intérprete de Python,

python myscript.py

todo el código que está en el nivel de indentación 0 se ejecuta. Las funciones y clases que están definidas están, bueno, definidas, pero no se ejecuta ningún código. A diferencia de otros lenguajes, no hay main() 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 bloque. __name__ es una variable incorporada que evalúa al nombre del módulo actual. Sin embargo, si un módulo se está ejecutando directamente (como en myscript.py arriba), entonces __name__ en lugar de ello se establece en la cadena "__main__" . Por lo tanto, puedes probar si tu script se está ejecutando directamente o está siendo importado por otra cosa probando

if __name__ == "__main__":
    ...

Si ese código se importa a otro módulo, se importarán las diversas definiciones de funciones y clases, pero el main() el código no se ejecutará. Como ejemplo básico, considera 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 invoca al intérprete como

python one.py

La salida será

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

Si corres two.py en su lugar:

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, su __name__ es igual a "one" en lugar de __main__ .

La explicación más simple para la __name__ variable (imho) es la siguiente:

Crea los siguientes archivos.

# a.py
import b

y

# b.py
print "Hello World from %s!" % __name__

if __name__ == '__main__':
    print "Hello World again from %s!" % __name__

Ejecutarlas te dará esta salida:

$ python a.py
Hello World from b!

$ python b.py
Hello World from __main__!
Hello World again from __main__!

Intento responder a la pregunta principal con una explicación lo más completa posible.

Desarrollando y probando su código

Digamos que estás escribiendo un Python script diseñado para ser usado como un módulo:

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

Usted podría Pruebe el módulo añadiendo esta llamada de la función en la parte inferior:

do_important()

y ejecutándolo con algo como (en un símbolo de comando):

~$ python important.py

El problema

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

import important

En la importación, el do_important se llamaría a la función, así que probablemente comentarías tu llamada a la función en la parte inferior. Y entonces tendrás que recordar si has comentado o no tu llamada a la función de prueba. Y esta complejidad adicional significaría que probablemente lo olvides, haciendo que tu proceso de desarrollo sea más problemático.

Una mejor manera

El __name__ La variable apunta al espacio de nombres donde se encuentra 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 primario (o el REPL de un intérprete) desde el que se ejecuta todo, es "__main__" .

Así que si lo compruebas antes de ejecutar:

if __name__ == "__main__":
    do_important()

Con lo anterior, tu código sólo se ejecutará cuando lo estés ejecutando como módulo primario (o lo llames intencionadamente desde otro script).

Una forma aún mejor

Sin embargo, hay una forma Pythonica de mejorar esto.

El código Python puede correr más rápido en una función (ver el enlace para saber cómo y por qué), así que si ponemos el código que queremos ejercitar a medida que desarrollamos y probamos en una función como esta y luego hacemos nuestra comprobación de principal inmediatamente después:

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 primario, pero que también permitirá que el módulo y sus funciones y clases se importen a otros scripts sin ejecutar el main funcionan, de la manera más eficiente (si la eficiencia importa).

Este modismo también se puede encontrar (profundo) en la documentación de Python en una explicación de la __main__ módulo. Ese texto dice:

Este módulo representa el ámbito (por lo demás anónimo) en el que el el programa principal del intérprete se ejecuta - los comandos se leen ya sea de entrada estándar, desde un archivo script, o desde un prompt interactivo. Es es este entorno en el que la estrofa idiomática "condicional script" hace que se ejecute un script:

if __name__ == '__main__':
    main()

La sintaxis *args en una declaración de función permite aceptar un número arbitrario de parámetros (distintos de los nombrados explícitamente, como string , sleeptime y lock en su ejemplo):

def printStuff(*args):
    for arg in args:
        print arg

printStuff(1, 2, "Hello World")

1
2
Hello World

La sintaxis *args en una llamada de función te permite llamar con los elementos de la lista args como argumentos adicionales:

args = [4, 5, "Goodbye"]
printStuff(2, 3, *args)

2
3
4
5
Goodbye