it-swarm-es.com

¿Qué hace si __name__ == "__main__": hazlo?

¿Qué hace el if __== "__main__":?

# Threading example
import time, thread

def myfunction(string, sleeptime, lock, *args):
    while True:
        lock.acquire()
        time.sleep(sleeptime)
        lock.release()
        time.sleep(sleeptime)

if __== "__main__":
    lock = thread.allocate_lock()
    thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
    thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
4977
Devoted

Cada vez que el intérprete de Python lee un archivo de origen, hace dos cosas:

  • establece algunas variables especiales como __name__, y luego

  • ejecuta todo el código encontrado en el archivo.

Veamos cómo funciona esto y cómo se relaciona con su pregunta sobre las comprobaciones de __name__ que siempre vemos en los scripts de Python.

Ejemplo de código

Usemos un ejemplo de código ligeramente diferente para explorar cómo funcionan las importaciones y los scripts. Supongamos que lo siguiente está en un archivo llamado foo.py.

# Suppose this is foo.py.

print("before import")
import math

print("before functionA")
def functionA():
    print("Function A")

print("before functionB")
def functionB():
    print("Function B {}".format(math.sqrt(100)))

print("before __guard")
if __== '__main__':
    functionA()
    functionB()
print("after __guard")

Variables especiales

Cuando el interpeter de Python lee un archivo fuente, primero define unas pocas variables especiales. En este caso, nos preocupa la variable __name__.

Cuando su módulo es el programa principal

Si está ejecutando su módulo (el archivo fuente) como programa principal, por ejemplo.

python foo.py

el intérprete asignará la cadena codificada "__main__" a la variable __name__, es decir,.

# It's as if the interpreter inserts this at the top
# of your module when run as the main program.
__= "__main__" 

Cuando su módulo es importado por otro

Por otro lado, suponga que algún otro módulo es el programa principal e importa su módulo. Esto significa que hay una declaración como esta en el programa principal, o en algún otro módulo que importa el programa principal:

# Suppose this is in some other main program.
import foo

En este caso, el intérprete verá el nombre de archivo de su módulo, foo.py, eliminará el .py, y asignará esa cadena a la variable __name__ de su módulo, es decir.

# It's as if the interpreter inserts this at the top
# of your module when it's imported from another module.
__= "foo"

Ejecutando el Código del Módulo

Después de configurar las variables especiales, el intérprete ejecuta todo el código del módulo, una declaración a la vez. Es posible que desee abrir otra ventana en el lateral con el ejemplo de código para que pueda seguir con esta explicación.

Siempre

  1. Imprime la cadena "before import" (sin comillas).

  2. Carga el módulo math y lo asigna a una variable llamada math. Esto es equivalente a reemplazar import math con lo siguiente (tenga en cuenta que __import__ es una función de bajo nivel en Python que toma una cadena y activa la importación real):

# Find and load a module given its string name, "math",
# then assign it to a local variable called math.
math = __import__("math")
  1. Imprime la cadena "before functionA".

  2. Ejecuta el bloque def, crea un objeto de función y luego asigna ese objeto de función a una variable llamada functionA.

  3. Imprime la cadena "before functionB".

  4. Ejecuta el segundo bloque def, crea otro objeto de función y luego lo asigna a una variable llamada functionB.

  5. Imprime la cadena "before __guard".

Solo cuando su módulo es el programa principal

  1. Si su módulo es el programa principal, verá que __name__ se configuró en "__main__" y llama a las dos funciones, imprimiendo las cadenas "Function A" y "Function B 10.0".

Sólo cuando su módulo es importado por otro

  1. ( en su lugar ) Si su módulo no es el programa principal pero fue importado por otro, entonces __name__ será "foo", no "__main__", y omitirá el cuerpo de la declaración if.

Siempre

  1. Imprimirá la cadena "after __guard" en ambas situaciones.

Resumen

En resumen, esto es lo que se imprimiría en los dos casos:

# What gets printed if foo is the main program
before import
before functionA
before functionB
before __guard
Function A
Function B 10.0
after __guard
# What gets printed if foo is imported as a regular module
before import
before functionA
before functionB
before __guard
after __guard

¿Por qué funciona de esta manera?

Naturalmente, podrías preguntarte por qué alguien querría esto. Bueno, a veces desea escribir un archivo .py que pueden ser utilizados por otros programas y módulos como un módulo y puede ejecutarse como el programa principal. Ejemplos:

  • Su módulo es una biblioteca, pero desea tener un modo de script donde ejecute algunas pruebas unitarias o una demostración.

  • Su módulo solo se usa como programa principal, pero tiene algunas pruebas unitarias, y el marco de prueba funciona al importar archivos .py como su script y ejecutar funciones de prueba especiales. No desea que intente ejecutar el script solo porque está importando el módulo.

  • Su módulo se usa principalmente como programa principal, pero también proporciona una API fácil de programador para usuarios avanzados.

Más allá de esos ejemplos, es elegante que ejecutar un script en Python solo esté configurando algunas variables mágicas e importando el script. "Ejecutar" el script es un efecto secundario de importar el módulo del script.

Comida para el pensamiento

  • Pregunta: ¿Puedo tener varios bloques de comprobación __name__? Respuesta: es extraño hacerlo, pero el lenguaje no te detendrá.

  • Supongamos que lo siguiente está en foo2.py. ¿Qué sucede si dice python foo2.py en la línea de comandos? ¿Por qué?

# Suppose this is foo2.py.

def functionA():
    print("a1")
    from foo2 import functionB
    print("a2")
    functionB()
    print("a3")

def functionB():
    print("b")

print("t1")
if __== "__main__":
    print("m1")
    functionA()
    print("m2")
print("t2")
  • Ahora, averigüe qué sucederá si elimina el __name__ check in foo3.py:
# Suppose this is foo3.py.

def functionA():
    print("a1")
    from foo3 import functionB
    print("a2")
    functionB()
    print("a3")

def functionB():
    print("b")

print("t1")
print("m1")
functionA()
print("m2")
print("t2")
  • ¿Qué hará esto cuando se utiliza como un script? Cuando se importa como un módulo?
# Suppose this is in foo4.py
__= "__main__"

def bar():
    print("bar")

print("before __guard")
if __== "__main__":
    bar()
print("after __guard")
5337
Mr Fooz

Cuando su 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 sangría 0 se ejecuta. Las funciones y clases que están definidas están bien definidas, pero no se ejecuta ninguno de sus códigos. A diferencia de otros idiomas, no hay una función main() que se ejecute automáticamente; la función main() es implícitamente todo el código en el nivel superior.

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

if __== "__main__":
    ...

Si su script 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 la cláusula if anterior no se ejecutará como la condición no se cumple 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 __== "__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 __== "__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 ejecuta 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

Por lo tanto, cuando se carga el módulo one, su __name__ es igual a "one" en lugar de "__main__".

1626
Adam Rosenfield

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

Crea los siguientes archivos.

# a.py
import b

y

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

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

Al ejecutarlos obtendrás esta salida:

$ python a.py
Hello World from b!

Como puede ver, cuando se importa un módulo, Python establece globals()['__name__'] en este módulo al nombre del módulo. Además, al importar todo el código en el módulo se está ejecutando. Como la declaración if se evalúa como False esta parte no se ejecuta.

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

Como puede ver, cuando se ejecuta un archivo, Python establece globals()['__name__'] en este archivo en "__main__". Esta vez, la instrucción if se evalúa como True y se está ejecutando.

647
pi.

¿Qué hace el if __== "__main__":?

Para delinear los conceptos básicos:

  • 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 por el que importa el módulo.

  • Entonces, el código bajo el bloque if 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 importable por otros módulos, sin ejecutar el bloque de código debajo de la importación.


¿Porqué necesitamos esto?

Desarrollar y probar su código

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

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

Usted podría probar el módulo agregando esta llamada de la función a la parte inferior:

do_important()

y ejecutarlo (en un comando 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, se llamaría a la función do_important, por lo que probablemente comentarías tu llamada a la función, do_important(), en la parte inferior.

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

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

Una mejor manera

La variable __name__ 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 primario (o una sesión interactiva de Python, es decir, la lectura, la evaluación, el ciclo de impresión o el REPL del intérprete) está ejecutando todo desde su "__main__".

Así que si chequeas antes de ejecutar:

if __== "__main__":
    do_important()

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

Una manera aún mejor

Sin embargo, hay una forma pitónica de mejorar esto.

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

Si colocamos el código que queremos ejercer a medida que desarrollamos y probamos en una función como esta y luego hacemos nuestra comprobación de '__main__' 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 __== '__main__':
    main()

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

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

import important
important.main()

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

Este módulo representa el alcance (de lo contrario anónimo) en el que se ejecuta el programa principal del intérprete: los comandos se leen ya sea desde una entrada estándar, desde un archivo de secuencia de comandos o desde una solicitud interactiva. Es este entorno en el que la stanza idiomática de "secuencia de comandos condicional" hace que se ejecute una secuencia de comandos:

if __== '__main__':
    main()
463
Aaron Hall

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

105
Harley Holcombe

¿Qué hace if __== "__main__":?

__name__ es una variable global (en Python, global realmente significa en el nivel de módulo ) que existe en todos los espacios de nombres. Normalmente es el nombre del módulo (como un tipo str).

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

python mycode.py

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

Por lo tanto, incluyendo las líneas finales

if __== '__main__':
    main()
  • al final de su script mycode.py,
  • cuando es el módulo principal de punto de entrada que se ejecuta mediante un proceso de Python,

hará que se ejecute la función main definida de forma única de su script.

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

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

Hay muchas tomas diferentes aquí sobre la mecánica del código en cuestión, el "Cómo", pero para mí nada de esto tuvo sentido hasta que entendí el "Por qué". Esto debería ser especialmente útil para los nuevos programadores.

Toma el archivo "ab.py":

def a():
    print('A function in ab file');
a()

Y un segundo archivo "xy.py":

import ab
def main():
    print('main function: this is where the action is')
def x():
    print ('peripheral task: might be useful in other projects')
x()
if __== "__main__":
    main()

¿Qué está haciendo realmente este código?

Cuando ejecutas xy.py, import ab. La declaración de importación ejecuta el módulo inmediatamente después de la importación, por lo que las operaciones de ab se ejecutan antes del resto de xy. Una vez terminado con ab, continúa con xy.

El intérprete realiza un seguimiento de qué secuencias de comandos se ejecutan con __name__. Cuando ejecuta un script, no importa cómo lo haya nombrado, el intérprete lo llama "__main__", lo que lo convierte en el script maestro o "de inicio" al que se vuelve después de ejecutar un script externo.

A cualquier otro script que se llame desde este script "__main__" se le asigna su nombre de archivo como __name__ (por ejemplo, __== "ab.py"). Por lo tanto, la línea if __== "__main__": es la prueba del intérprete para determinar si está interpretando/analizando la secuencia de comandos "inicial" que se ejecutó inicialmente, o si se está viendo temporalmente en otra secuencia de comandos (externa). Esto le da al programador flexibilidad para que el script se comporte de manera diferente si se ejecuta directamente o se llama externamente.

Revisemos el código anterior para entender lo que está sucediendo, enfocándonos primero en las líneas sin sangría y en el orden en que aparecen en los scripts. Recuerde que los bloques de función - o def - no hacen nada por sí mismos hasta que son llamados. Lo que el intérprete podría decir si murmurara a sí mismo:

  • Abra xy.py como el archivo 'home'; llámelo "__main__" en la variable __name__.
  • Importe y abra el archivo con el __== "ab.py".
  • Oh, una función. Recordaré eso.
  • Ok, función a(); Acabo de aprender eso. Imprimiendo 'una función en un archivo ab'.
  • Fin del documento; De vuelta a "__main__"!
  • Oh, una función. Recordaré eso.
  • Otro.
  • Función x(); ok, imprimiendo 'tarea periférica: podría ser útil en otros proyectos'.
  • ¿Qué es esto? Una declaración de if Bueno, la condición se ha cumplido (la variable __name__ se ha establecido en "__main__"), así que entraré en la función main() e imprimiré 'función principal: aquí es donde está la acción'.

Las dos líneas inferiores indican: "Si este es el script "__main__" o 'home', ejecute la función llamada main()". Es por eso que verá un def main(): block up top, que contiene el flujo principal de la funcionalidad del script.

¿Por qué implementar esto?

¿Recuerdas lo que dije antes sobre las declaraciones de importación? Cuando importa un módulo, no solo lo "reconoce" y espera instrucciones adicionales, en realidad ejecuta todas las operaciones ejecutables contenidas en el script. Por lo tanto, poner la fuente de su script en la función main() lo pone en cuarentena de manera efectiva, poniéndolo en aislamiento para que no se ejecute inmediatamente cuando sea importado por otro script.

Una vez más, habrá excepciones, pero la práctica común es que main() no suele recibir llamadas externas. Entonces, tal vez se esté preguntando una cosa más: si no estamos llamando a main(), ¿por qué estamos llamando al script? Esto se debe a que muchas personas estructuran sus scripts con funciones independientes que están diseñadas para ejecutarse de manera independiente del resto del código del archivo. Luego son llamados en otro lugar en el cuerpo del script. Lo que me lleva a esto:

Pero el código funciona sin él.

Sí, eso es correcto. Estas funciones separadas can se pueden llamar desde un script en línea que no está contenido dentro de una función main(). Si está acostumbrado (como yo, en mis primeras etapas de aprendizaje de la programación) a crear scripts en línea que hagan exactamente lo que necesita, e intentará averiguarlo nuevamente si alguna vez necesita esa operación nuevamente. Bueno, no estás acostumbrado a este tipo de estructura interna de tu código, porque es más complicado de construir y no es tan intuitivo de leer.

Pero ese es un script que probablemente no puede tener sus funciones llamadas externamente, porque si lo hiciera, inmediatamente comenzaría a calcular y asignar variables. Y lo más probable es que si está intentando reutilizar una función, su nuevo script esté lo suficientemente relacionado con el anterior de que habrá variables en conflicto.

Al dividir las funciones independientes, puede reutilizar su trabajo anterior llamándolos a otro script. Por ejemplo, "example.py" podría importar "xy.py" y llamar a x(), haciendo uso de la función 'x' de "xy.py". (Tal vez esté en mayúscula la tercera palabra de una cadena de texto dada; creando una matriz NumPy a partir de una lista de números y cuadrándolos; o desvirtuando una superficie 3D. Las posibilidades son ilimitadas).

(Dejando aparte, esta pregunta contiene una respuesta de @kindall que finalmente me ayudó a entender - el por qué, no el cómo. Desafortunadamente, se ha marcado como un duplicado de este , que creo que es un error.)

60
joechoj

Cuando hay ciertas declaraciones en nuestro módulo (M.py) queremos que se ejecute cuando se ejecute como principal (no importado), podemos colocar esas declaraciones (casos de prueba, declaraciones impresas) bajo este bloque if.

De manera predeterminada (cuando el módulo se ejecuta como principal, no se importa), la variable __name__ se establece en "__main__", y cuando se importa, la variable __name__ obtendrá un valor diferente, probablemente el nombre del módulo ('M'). Esto es útil para ejecutar diferentes variantes de módulos juntos, y para separar sus declaraciones de entrada y salida específicas y también si hay casos de prueba.

En resumen , use este bloque 'if __== "main"' para evitar que (cierto) código se ejecute cuando se importa el módulo.

45
Nabeel Ahmed

En pocas palabras, __name__ es una variable definida para cada script que define si el script se ejecuta como el módulo principal o si se ejecuta como un módulo importado.

Así que si tenemos dos guiones;

#script1.py
print "Script 1's name: {}".format(__name__)

y

#script2.py
import script1
print "Script 2's name: {}".format(__name__)

La salida de la ejecución de script1 es

Script 1's name: __main__

Y la salida de la ejecución de script2 es:

Script1's name is script1
Script 2's name: __main__

Como puede ver, __name__ nos dice qué código es el módulo 'principal'. Esto es genial, porque simplemente puede escribir código y no tiene que preocuparse por problemas estructurales como en C/C++, donde, si un archivo no implementa una función 'principal', no se puede compilar como un ejecutable y si lo hace no se puede utilizar como una biblioteca.

Digamos que escribes un script de Python que hace algo grandioso e implementas una gran cantidad de funciones que son útiles para otros propósitos. Si quiero usarlos, solo puedo importar su script y usarlos sin ejecutar su programa (dado que su código solo se ejecuta dentro del contexto if __== "__main__":). Mientras que en C/C++, tendría que dividir esas piezas en un módulo separado que luego incluya el archivo. Imagina la situación a continuación;

 Complicated importing in C

Las flechas son enlaces de importación. Para cada tres módulos que intentan incluir el código de los módulos anteriores, hay seis archivos (nueve, contando los archivos de implementación) y cinco enlaces. Esto hace que sea difícil incluir otro código en un proyecto de C a menos que se compile específicamente como una biblioteca. Ahora imagínalo para Python:

 Elegant importing in Python

Escribe un módulo, y si alguien quiere usar su código, simplemente lo importa y la variable __name__ puede ayudar a separar la parte ejecutable del programa de la parte de la biblioteca.

35
redbandit

Veamos la respuesta de una manera más abstracta:

Supongamos que tenemos este código en x.py:

...
<Block A>
if __== '__main__':
    <Block B>
...

Los bloques A y B se ejecutan cuando ejecutamos "x.py".

Pero solo se ejecuta el bloque A (y no B) cuando estamos ejecutando otro módulo, "y.py" por ejemplo, en el que se importa xy y el código se ejecuta desde allí (como cuando una función en "x.py" es llamado desde y.py).

35
Alisa

Cuando ejecutas Python interactivamente, a la variable local __name__ se le asigna un valor de __main__. Del mismo modo, cuando ejecuta un módulo de Python desde la línea de comandos, en lugar de importarlo a otro módulo, a su atributo __name__ se le asigna un valor de __main__, en lugar del nombre real del módulo. De esta manera, los módulos pueden ver su propio valor de __name__ para determinar por sí mismos cómo se están utilizando, ya sea como soporte para otro programa o como la aplicación principal ejecutada desde la línea de comandos. Por lo tanto, el siguiente idioma es bastante común en los módulos de Python:

if __== '__main__':
    # Do something appropriate here, like calling a
    # main() function defined elsewhere in this module.
    main()
else:
    # Do nothing. This module has been imported by another
    # module that wants to make use of the functions,
    # classes and other useful bits it has defined.
32
Zain

Considerar:

if __== "__main__":
    main()

Comprueba si el atributo __name__ del script Python es "__main__". En otras palabras, si se ejecuta el programa, el atributo será __main__, por lo que el programa se ejecutará (en este caso, la función main()).

Sin embargo, si un módulo usa su secuencia de comandos de Python, se ejecutará cualquier código fuera de la instrucción if, por lo que if \__== "\__main__" se usa solo para verificar si el programa se usa como un módulo y, por lo tanto, decide si ejecutar el código.

29
Larry

Antes de explicar algo sobre if __== '__main__' es importante entender qué es __name__ y qué hace.

¿Qué es __name__?

__name__ es un DunderAlias ​​ - puede considerarse como una variable global (accesible desde módulos) y funciona de manera similar a global .

Es una cadena (global como se mencionó anteriormente) como se indica por type(__name__) (produciendo <class 'str'>), y es un estándar incorporado para ambas versiones Python 3 y Python 2 .

Donde:

No solo se puede utilizar en scripts, sino que también se puede encontrar tanto en el intérprete como en los módulos/paquetes.

Intérprete:

>>> print(__name__)
__main__
>>>

Script:

test_file.py:

print(__name__)

Resultando en __main__

Módulo o paquete:

somefile.py:

def somefunction():
    print(__name__)

test_file.py:

import somefile
somefile.somefunction()

Resultando en somefile

Observe que cuando se usa en un paquete o módulo, __name__ toma el nombre del archivo. La ruta del módulo real o la ruta del paquete no se proporciona, pero tiene su propio código DunderAlias ​​__file__, que permite esto.

Debería ver que, donde __name__, donde está el archivo principal (o programa) always devolverá __main__, y si es un módulo/paquete, o cualquier cosa que se esté ejecutando en algún otro script de Python, devolverá el Nombre del archivo desde donde se originó.

Práctica:

Ser una variable significa que su valor puede ser sobrescrito ("puede" no significa "debería"), sobrescribir el valor de __name__ resultará en una falta de legibilidad. Así que no lo hagas, por ninguna razón. Si necesitas una variable define una nueva variable.

Siempre se asume que el valor de __name__ es __main__ o el nombre del archivo. Una vez más, cambiar este valor predeterminado causará más confusión de que funcionará bien, causando problemas más adelante.

ejemplo:

>>> __= 'Horrify' # Change default from __main__
>>> if __== 'Horrify': print(__name__)
...
>>> else: print('Not Horrify')
...
Horrify
>>>

En general, se considera una buena práctica incluir el if __== '__main__' en los scripts.

Ahora para responder if __== '__main__':

Ahora sabemos que el comportamiento de __name__ las cosas se aclaran:

Una if es una declaración de control de flujo que contiene el bloque de código que se ejecutará si el valor dado es verdadero. Hemos visto que __name__ puede tomar __main__ o el nombre del archivo desde el que se ha importado.

Esto significa que si __name__ es igual a __main__, entonces el archivo debe ser el archivo principal y en realidad debe estar ejecutándose (o es el intérprete), no un módulo o paquete importado al script.

Si de hecho __name__ toma el valor de __main__ entonces cualquier cosa en ese bloque de código se ejecutará.

Esto nos dice que si el archivo en ejecución es el archivo principal (o si está ejecutando directamente desde el intérprete), esa condición debe ejecutarse. Si es un paquete, entonces no debería, y el valor no será __main__.

Módulos:

__name__ también se puede usar en módulos para definir el nombre de un módulo

Variantes:

También es posible hacer otras cosas, menos comunes pero útiles con __name__, algunas que mostraré aquí:

Ejecutando solo si el archivo es un módulo o paquete:

if __!= '__main__':
    # Do some useful things 

Ejecutando una condición si el archivo es el principal y otro si no lo es:

if __== '__main__':
    # Execute something
else:
    # Do some useful things

También puede usarlo para proporcionar funciones/utilidades de ayuda ejecutables en paquetes y módulos sin el uso elaborado de las bibliotecas.

También permite que los módulos se ejecuten desde la línea de comandos como scripts principales, lo que también puede ser muy útil.

25
Simon

Creo que es mejor romper la respuesta en profundidad y con palabras simples:

__name__: Cada módulo en Python tiene un atributo especial llamado __name__. Es una variable incorporada que devuelve el nombre del módulo.

__main__: Al igual que otros lenguajes de programación, Python también tiene un punto de entrada de ejecución, es decir, principal. '__main__' es el nombre del ámbito en el que se ejecuta el código de nivel superior . Básicamente, tiene dos formas de usar un módulo de Python: ejecutarlo directamente como un script o importarlo. Cuando un módulo se ejecuta como un script, su __name__ se establece en __main__.

Por lo tanto, el valor del atributo __name__ se establece en __main__ cuando el módulo se ejecuta como el programa principal. De lo contrario, el valor de __name__ se establece para contener el nombre del módulo.

21
Inconnu

Es especial para cuando se llama a un archivo Python desde la línea de comandos. Esto se suele utilizar para llamar a una función "main ()" o para ejecutar otro código de inicio apropiado, como el manejo de argumentos de la línea de comandos, por ejemplo.

Se podría escribir de varias maneras. Otro es:

def some_function_for_instance_main():
    dosomething()


__== '__main__' and some_function_for_instance_main()

No estoy diciendo que debas usar esto en el código de producción, pero sirve para ilustrar que no hay nada "mágico" sobre if __== '__main__'. Es una buena convención para invocar una función principal en archivos Python.

20
Prof. Falken

Hay una serie de variables que el sistema (intérprete de Python) proporciona para los archivos de origen (módulos). Puede obtener sus valores en cualquier momento que desee, por lo tanto, permítanos concentrarnos en el_NAME_variable/attribute:

Cuando Python carga un archivo de código fuente, ejecuta todo el código que se encuentra en él. (Tenga en cuenta que no llama a todos los métodos y funciones definidos en el archivo, pero sí los define).

Sin embargo, antes de que el intérprete ejecute el archivo de código fuente, define algunas variables especiales para ese archivo;_NAME_es una de esas variables especiales que Python define automáticamente para cada archivo de código fuente.

Si Python está cargando este archivo de código fuente como el programa principal (es decir, el archivo que ejecuta), establece la variable especial_NAME_para que este archivo tenga un valor "__main__" .

Si se está importando de otro módulo,_NAME_se establecerá en el nombre de ese módulo.

Entonces, en tu ejemplo en parte:

if __== "__main__":
   lock = thread.allocate_lock()
   thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
   thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

significa que el bloque de código:

lock = thread.allocate_lock()
thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))

se ejecutará solo cuando ejecutes el módulo directamente; el bloque de código no se ejecutará si otro módulo lo está llamando/importando porque el valor de_NAME_no será igual a " main " en esa instancia en particular.

Espero que esto ayude.

19
codewizard

if __== "__main__": es básicamente el entorno de script de nivel superior, y especifica el intérprete que ('Tengo la prioridad más alta para ejecutarse primero').

'__main__' es el nombre del ámbito en el que se ejecuta el código de nivel superior. El __name__ de un módulo se establece igual a '__main__' cuando se lee desde una entrada estándar, un script o desde un mensaje interactivo.

if __== "__main__":
    # Execute only if run as a script
    main()
16
The Gr8 Adakron

La razón por

if __== "__main__":
    main()

es principalmente evitar el bloqueo de importación problemas que surgirían de tener el código importado directamente . Desea ejecutar main() si su archivo fue invocado directamente (ese es el caso __== "__main__"), pero si su código fue importado, entonces el importador debe ingresar su código desde el verdadero módulo principal para evitar problemas de bloqueo de importación.

Un efecto secundario es que inicia sesión automáticamente en una metodología que admite varios puntos de entrada. Puede ejecutar su programa usando main() como punto de entrada, pero no tiene que . Mientras que setup.py espera main(), otras herramientas usan puntos de entrada alternativos. Por ejemplo, para ejecutar su archivo como un proceso gunicorn, debe definir una función app() en lugar de una main(). Al igual que con setup.py, gunicorn importa tu código para que no desees hacer nada mientras se importa (debido al problema de bloqueo de importación).

14
personal_cloud

He estado leyendo mucho a lo largo de las respuestas en esta página. Diría que, si lo sabes, seguro que entenderás esas respuestas, de lo contrario, todavía estás confundido.

Para ser breve, necesitas conocer varios puntos:

  1. La acción import a realmente ejecuta todo lo que se puede ejecutar en "a"

  2. Debido al punto 1, es posible que no desee que todo se ejecute en "a" al importarlo

  3. Para resolver el problema en el punto 2, Python le permite poner una verificación de condición

  4. __name__ es una variable implícita en todos los módulos .py; cuando se importa a.py, el valor de __name__ de un módulo de.py se establece en su nombre de archivo "a"; cuando a.py se ejecuta directamente usando "python a.py", lo que significa que a.py es el punto de entrada, entonces el valor de __name__ del módulo a.py se establece en una cadena __main__

  5. Según el mecanismo en el que Python establece la variable __name__ para cada módulo, ¿sabe cómo lograr el punto 3? La respuesta es bastante fácil, ¿verdad? Poner una condición if: if __== "__main__": ...; incluso puedes poner si __== "a" dependiendo de tu necesidad funcional

¡Lo importante en lo que Python es especial es en el punto 4! El resto es solo lógica básica.

13
jack

Considerar:

print __name__

La salida para lo anterior es __main__.

if __== "__main__":
  print "direct method"

La declaración anterior es verdadera e imprime "método directo" . Supongamos que si importaron esta clase en otra clase no se imprime "método directo" porque, al importar, establecerá __equal to "first model name".

13
Janarthanan Ramu

Puede hacer que el archivo sea utilizable como script así como como módulo importable.

fibo.py (un módulo llamado fibo)

# Other modules can IMPORT this MODULE to use the function fib
def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

# This allows the file to be used as a SCRIPT
if __== "__main__":
    import sys
    fib(int(sys.argv[1]))

Referencia: https://docs.python.org/3.5/tutorial/modules.html

12
sam

Esta respuesta es para los programadores de Java que aprenden Python. Cada archivo Java típicamente contiene una clase pública. Puedes usar esa clase de dos maneras:

  1. Llama a la clase desde otros archivos. Solo tienes que importarlo en el programa de llamadas.

  2. Ejecutar la clase independiente, para fines de prueba.

Para este último caso, la clase debe contener un método public static void main (). En Python, este propósito se cumple con la etiqueta globalmente definida '__main__'.

7
Raja

Si este archivo .py es importado por otros archivos .py, el código debajo de "la declaración if" no se ejecutará.

Si este .py es ejecutado por python this_py.py bajo Shell, o haga doble clic en Windows. se ejecutará el código debajo de "la sentencia if".

Por lo general, se escribe para la prueba.

5
pah8J

Crear un archivo, a.py :

print(__name__) # It will print out __main__

__name__ siempre es igual a __main__ cuando ese archivo es ejecutar directamente mostrando que este es el archivo principal.

Cree otro archivo, b.py , en el mismo directorio:

import a  # Prints a

Ejecutarlo. Imprimirá a , es decir, el nombre del archivo que se importa .

Entonces, para mostrar dos comportamientos diferentes del mismo archivo , este es un truco comúnmente utilizado:

# Code to be run when imported into another python file

if __== '__main__':
    # Code to be run only when run directly
4
TheVishal

si nombre == ' main ':

Vemos si __== '__main__': muy a menudo.

Comprueba si un módulo se está importando o no.

En otras palabras, el código dentro del bloque if se ejecutará solo cuando el código se ejecute directamente. Aquí directly significa not imported.

Veamos qué hace usando un código simple que imprime el nombre del módulo:

# test.py
def test():
   print('test module name=%s' %(__name__))

if __== '__main__':
   print('call test()')
   test()

Si ejecutamos el código directamente a través de python test.py, el nombre del módulo es __main__:

call test()
test module name=__main__
3
Ali Hallaji

Todas las respuestas han explicado bastante la funcionalidad. Pero daré un ejemplo de su uso que podría ayudar a aclarar el concepto aún más.

Supongamos que tiene dos archivos Python, a.py y b.py. Ahora, a.py importa b.py. Ejecutamos el archivo a.py, donde primero se ejecuta el código "importar b.py". Antes de que se ejecute el resto del código a.py, el código en el archivo b.py debe ejecutarse completamente.

En el código b.py hay un código que es exclusivo de ese archivo b.py y no queremos que se ejecute ningún otro archivo (que no sea el archivo b.py) que haya importado el archivo b.py.

Así que eso es lo que comprueba esta línea de código. Si es el archivo principal (es decir, b.py) el que ejecuta el código, que en este caso no lo es (a.py es el archivo principal que se ejecuta), entonces solo se ejecuta el código.

3
preetika mondal

Simplemente es el punto de entrada para ejecutar el archivo como la función main en el lenguaje de programaciónC.

2
Mohammed Awney