Nota

¡Ayúdanos a traducir la documentación oficial de Python al Español! Puedes encontrar más información en Como contribuir. Ayuda a acercar Python a más personas de habla hispana.

__main__ — Entorno de código de nivel máximo


En Python, el nombre especial __main__ es utilizado para dos constructos importantes:

  1. el nombre del entorno de máximo nivel del programa, que puede ser verificado usando la expresión __name__=='__main__'; y

  2. el archivo __main__.py en paquetes de Python.

Ambos de estos mecanismos están relacionados con módulos de Python; como los usuarios interactúan con ellos y como ellos interactúan entre sí. Están explicados en detalle más abajo. Si estás empezando con los módulos de Python, mira la sección tutorial Módulos para una introducción.

__name__ == '__main__'

Cuando un módulo o paquete de Python es importado, __name__ es asignado al nombre del módulo. Normalmente, este es el nombre del archivo de Python sin la extensión .py:

>>> import configparser
>>> configparser.__name__
'configparser'

Si el archivo es parte de un paquete, __name__ también incluirá la ruta del paquete padre:

>>> from concurrent.futures import process
>>> process.__name__
'concurrent.futures.process'

Sin embargo, si el módulo es ejecutado en el entorno de código de máximo nivel, su __name__ se le asigna el valor del string '__main__'.

¿Qué es el «entorno de código de máximo nivel»?

__main__ es el nombre del entorno en el cual se ejecuta el código de máximo nivel. «Código de máximo nivel» es el primer módulo de Python especificado por el usuario que empieza a ejecutarse. Es «de máximo nivel» porque importa todos los demás módulos que necesita el programa. A veces «código de máximo nivel» es llamado un punto de entrada a la aplicación.

El entorno de código de máximo nivel puede ser:

  • el ámbito de un intérprete interactivo:

    >>> __name__
    '__main__'
    
  • el módulo de Python pasado al intérprete de Python como un argumento de archivo:

    $ python3 helloworld.py
    Hello, world!
    
  • el módulo o paquete de Python pasado al interprete de Python con el argumento -m:

    $ python3 -m tarfile
    usage: tarfile.py [-h] [-v] (...)
    
  • Código de Python leído por el interprete desde input estándar:

    $ echo "import this" | python3
    The Zen of Python, by Tim Peters
    
    Beautiful is better than ugly.
    Explicit is better than implicit.
    ...
    
  • Código de Python pasado al intérprete Python con el argumento -c:

    $ python3 -c "import this"
    The Zen of Python, by Tim Peters
    
    Beautiful is better than ugly.
    Explicit is better than implicit.
    ...
    

En cada una de estas situaciones, al __name__ del módulo de máximo nivel se le asigna el valor '__main__'.

En consecuencia, un módulo puede descubrir si se está ejecutando o no en el ámbito principal al verificar su propio __name__, lo cual permite un vocablo común para ejecutar código condicionalmente cuando el módulo no es inicializado desde una declaración de importado:

if __name__ == '__main__':
    # Execute when the module is not initialized from an import statement.
    ...

Ver también

Para una vista más detallada de como __name__ es asignado en todas las situaciones, ver la sección tutorial Módulos.

Uso Idiomático

Some modules contain code that is intended for script use only, like parsing command-line arguments or fetching data from standard input. If a module like this was imported from a different module, for example to unit test it, the script code would unintentionally execute as well.

Aquí es donde es útil usar el código de bloque if __name__=='__main__'. El código dentro desde bloque no se ejecutará a menos que el módulo se ejecute en el entorno de máximo nivel.

Poner cuantas menos declaraciones posible en el bloque debajo de if __name__=='__main__' puede mejorar la claridad y validez del código. Mas a menudo, la función llamada main encapsula el comportamiento principal del programa:

# echo.py

import shlex
import sys

def echo(phrase: str) -> None:
   """A dummy wrapper around print."""
   # for demonstration purposes, you can imagine that there is some
   # valuable and reusable logic inside this function
   print(phrase)

def main() -> int:
    """Echo the input arguments to standard output"""
    phrase = shlex.join(sys.argv)
    echo(phrase)
    return 0

if __name__ == '__main__':
    sys.exit(main())  # next section explains the use of sys.exit

Note que si el módulo no encapsulase el código dentro de la función main pero en vez lo pusiese directo dentro del bloque if __name__=='__main__', la variable phrase sería global al módulo entero. Esto está propenso a generar errores ya que otras funciones dentro del módulo pudiesen estar usando involuntariamente la variable global en lugar de un nombre local. Una función main resuelve este problema.

Usar una función main tiene el beneficio añadido de que la función echo está aislada y es importable en otros sitios. Cuando echo.py es importado, las funciones echo y main serán definidas, pero ninguna de ellas será llamada porque __name!='__main__'.

Consideraciones de empaquetado

Las funciones main se utilizan a menudo para crear líneas de comando al especificarlas como puntos de entrada para scripts de terminal. Cuando esto se hace, pip inserta la llamada de la función a un script plantilla, donde el valor retornado de main se pasa a sys.exit(). Por ejemplo:

sys.exit(main())

Dado que la llamada a main está dentro de sys.exit(), la expectativa es que tu función devolverá un valor aceptable como una entrada a sys.exit(); típicamente, un int o None (que se retorna implícitamente si tu función no tiene una declaración de retorno).

Al seguir pro-activamente esta convención nosotros mismo, nuestro módulo tendrá el mismo comportamiento cuando se ejecuta directamente (es decir, python3 echo.py) que si luego lo empaquetamos como un punto de entrada de script de terminal en un paquete instalable mediante pip.

En particular, ten cuidado al devolver cadenas de texto con tu función main. sys.exit() interpretará un argumento de cadena de texto como un mensaje de fallo, entonces tu programa tendrá un código de salida de 1, indicando fallo, y la cadena de texto será escrita a sys.stderr. El ejemplo echo.py de antes muestra como usar la convención sys.exit(main()).

Ver también

Python Packaging User Guide contiene una colección de tutoriales y referencias sobre como distribuir e instalar paquetes de Python con herramientas modernas.

__main__.py en paquetes de Python

Si no estás familiarizado con paquetes de Python, ver la sección Paquetes del tutorial. Comúnmente, el archivo __main__.py es utilizado para proveer una interfaz de línea de comando para un paquete. Considera el siguiente paquete hipotético, «bandclass»:

bandclass
  ├── __init__.py
  ├── __main__.py
  └── student.py

__main__.py será ejecutado cuando el paquete sea invocado directamente desde la línea de comandos usando el indicador -m. Por ejemplo:

$ python3 -m bandclass

Este comando causará que __main__.py se ejecute. El como se use este mecanismo dependerá de la naturaleza del paquete que estás escribiendo, pero en este caso hipotético, puede tener sentido permitir que el profesor busque estudiantes:

# bandclass/__main__.py

import sys
from .student import search_students

student_name = sys.argv[2] if len(sys.argv) >= 2 else ''
print(f'Found student: {search_students(student_name)}')

Note that from .student import search_students is an example of a relative import. This import style can be used when referencing modules within a package. For more details, see Referencias internas en paquetes in the Módulos section of the tutorial.

Uso Idiomático

Los contenidos de __main__.py no están típicamente acotados dentro de bloques if __name__=='__main__'. En cambio, esos archivos se mantienen cortos, funciones para ejecutar desde otros módulos. A esos otros módulos se les puede fácilmente realizar pruebas unitarias y son apropiadamente re-utilizables.

Si se usa, un bloque if __name__=='__main__' seguirá funcionando como se espera para un archivo __main__.py dentro de un paquete, porque su atributo __name__ incluirá la ruta del paquete si es importado:

>>> import asyncio.__main__
>>> asyncio.__main__.__name__
'asyncio.__main__'

This won’t work for __main__.py files in the root directory of a .zip file though. Hence, for consistency, minimal __main__.py like the venv one mentioned below are preferred.

Ver también

En venv puedes conseguir un ejemplo de un paquete con un __main__.py minimalista en la librería estándar. No contiene un bloque if __name__=='__main__'. Lo puedes invocar con python3 -m venv [directorio].

Ver runpy para más detalles sobre el indicador -m para el interprete ejecutable.

Ver zipapp para más información sobre como ejecutar aplicaciones empaquetadas como archivos .zip. En este caso Python busca un archivo __main__.py en el directorio raíz del archivo comprimido.

import __main__

Independientemente de con cual módulo se ha iniciado un programa de Python, otros módulos que están siendo ejecutados dentro del mismo programa pueden importar el ámbito del entorno de máximo nivel (namespace) al importar el módulo __main__. Esto no importa un archivo __main__.py pero en su lugar cualquier módulo que recibió el nombre especial '__main__'.

Acá hay un módulo ejemplo que consume el nombre de espacio __main__:

# namely.py

import __main__

def did_user_define_their_name():
    return 'my_name' in dir(__main__)

def print_user_name():
    if not did_user_define_their_name():
        raise ValueError('Define the variable `my_name`!')

    if '__file__' in dir(__main__):
        print(__main__.my_name, "found in file", __main__.__file__)
    else:
        print(__main__.my_name)

Ejemplo del uso de este módulo puede ser:

# start.py

import sys

from namely import print_user_name

# my_name = "Dinsdale"

def main():
    try:
        print_user_name()
    except ValueError as ve:
        return str(ve)

if __name__ == "__main__":
    sys.exit(main())

Si ahora iniciamos nuestro programa el resultado sería así:

$ python3 start.py
Define the variable `my_name`!

El código de salida del programa sería 1, indicando un error. Des-comentando la línea con my_name = "Dinsdale" arregla el programa y ahora sale con un código de estado 0, indicando éxito:

$ python3 start.py
Dinsdale found in file /path/to/start.py

Note que importar __main__ no causa ningún problema de involuntariamente ejecutar código de máximo nivel que ha sido pensado para uso por scripts que es puesto en el bloque if __name__=="__main__" del módulo start. ¿Por qué funciona esto?

Python inserta un módulo __main__ vacío en sys.modules al inicio del intérprete, y lo puebla ejecutando código de máximo nivel. En nuestro ejemplo este es el módulo start que corre línea a línea e importa namely. A su vez, namely importa __main__ (que es en verdad start). ¡Es un ciclo de importado! Afortunadamente, como el módulo parcialmente poblado __main__ está presente en sys.modules, Python pasa eso a namely. Ver Special considerations for __main__ en la referencia del sistema para información detallada de como funciona.

El REPL Python es otro ejemplo de un «entorno de máximo nivel», por lo tanto, cualquier cosa definida en el REPL se hace parte del ámbito __main__:

>>> import namely
>>> namely.did_user_define_their_name()
False
>>> namely.print_user_name()
Traceback (most recent call last):
...
ValueError: Define the variable `my_name`!
>>> my_name = 'Jabberwocky'
>>> namely.did_user_define_their_name()
True
>>> namely.print_user_name()
Jabberwocky

Note que en este caso el ámbito __main__ no contiene un atributo __file__ ya que es interactivo.

El ámbito __main__ es utilizado en la implementación de pdb y rlcompleter.