Comprender si __name__=='__main__' en Python

En esta guía, comprenderá la funcionalidad y el significado de if __name__ == '__main__' en Python.

¿Alguna vez ha hojeado un código base de Python con diferentes módulos?

Si es así, probablemente se habrá encontrado con el condicional if __name__ == '__main__' en uno o más módulos. En los próximos minutos, desmitificaremos lo que significa el condicional anterior y veremos un ejemplo en el que puede ser útil.

Comencemos

¿Cuál es el significado de __name__ en Python?

En Python, un módulo es un archivo .py que contiene definiciones de funciones, un conjunto de expresiones a evaluar y más. Por ejemplo, si tenemos un archivo llamado hola_mundo.py, nos referiremos a él como el archivo hola_mundo.py o el módulo hola_mundo.

Cuando ejecuta un módulo de Python, el intérprete de Python establece los valores de algunas variables especiales antes de la ejecución: __name__ es una de ellas. La clave para entender el significado __name__ es comprender cómo funcionan las importaciones en Python.

📁 Descargue el código para esta sección aquí.

Diríjase a la carpeta ejemplo-1. Tenemos el archivo module1.py. La variable __name__ está en el espacio de nombres del módulo actual.

Este módulo imprime una línea seguida del valor de la variable __name__.

# ejemplo-1/modulo1.py
print("Este es el módulo1.")
print(f "La variable __name__ del módulo 1 es: {__name__}.")

Ahora, ejecutemos el módulo1 desde la línea de comandos.

$ python módulo1.py

En la salida, vemos que la variable __name__ se establece en __main__.

Este es el módulo1.
La variable __name__ del módulo 1 es: __main__.

Importar módulos en Python

Además de ejecutar un módulo de Python, a veces puede querer utilizar funcionalidad de otro módulo de Python dentro del módulo actual. Python facilita esto a través de las importaciones.

Las importaciones le permiten reutilizar la funcionalidad de otro módulo-importándola en el ámbito del módulo actual-sin tener que reescribir el código.

El archivo module2. py contiene lo siguiente. Hemos importado módulo1 within módulo2.

# ejemplo-1/modulo2.py

import modulo1 # el modulo1 esta importado

print(f "Este es el modulo2")
print(f "La variable __name__ del modulo2 es: {__name__}.")

Ejecutamos módulo2 .py y observamos la salida.

$ python módulo2.py

En la salida

• Vemos que el módulo1 se ejecuta bajo el capó cuando lo importamos dentro del módulo2, y se imprime la salida correspondiente.
• Pero esta vez, la variable __name__ no es __main__ sino módulo1.
• Como ejecutamos directamente el módulo2, la variable __name__ correspondiente al módulo es ahora __main__.

Salida

Este es el módulo1.
La variable __name__ del módulo 1 es: módulo1.
Este es el módulo2
La variable __name__ del módulo2 es: __main__.

💡 Idea clave:

- Si un módulo se ejecuta directamente, su variable __name__ es igual a __main__.

- Si un módulo se importa dentro de otro módulo, su __name__ se establece en el nombre del módulo.

Ejemplo de if __name__=='__main__' en Python

En esta sección veremos un caso práctico de uso de la condicional if __name__ == '__main__'. Definiremos una función sencilla y luego escribiremos pruebas unitarias para comprobar si la función funciona como se espera.

📁 Descargue el código y sígalo.

El código de esta sección se encuentra en la carpeta example-2.

Aquí, add.py es un archivo Python que contiene la definición de la función add_ab().La función add_ab() toma dos números cualesquiera y devuelve su suma.

# ejemplo-2/add.py

def add_ab(a,b):
 return a b

Utilizaremos el módulo unittest de Python para probar la función add_ab ().

Escribir casos de prueba para una función de Python

Observe el fragmento de código siguiente, que contiene el contenido del módulo test_add.

# example-2/test_add.py

import unittest
from add import add_ab

class TestAdd(unittest.TestCase):
 def test_add_23(self):
 self.assertEqual(add_ab(2,3), 5)
    
 def test_add_19(self):
 self.assertEqual(add_ab(1,9), 10)
    
 def test_add_1_minus7(self):
 self.assertEqual(add_ab(1,-7), -6)
 

El código anterior hace lo siguiente

• Importa el módulo incorporado unittest de Python
• Importa la función add_ab() del módulo add
• Definir la clase de prueba TestAdd y un conjunto de casos de prueba como métodos dentro de la clase de prueba

Para configurar pruebas unitarias para su código, primero debe definir una clase de prueba que herede de unittest.TestCase. Todos los casos de prueba deben especificarse como métodos dentro de la clase y deben comenzar por test_.

Nota: Si no nombra los métodos como test_<some-descriptive-name>, verá que las pruebas correspondientes no serán detectadas y, por lo tanto, no se ejecutarán.

Ahora probamos a ejecutar el módulo test_add desde el terminal.

$ python test_add.py

Verá que no hay salida y que ninguna de las pruebas se ha ejecutado.

¿Por qué ocurre esto?🤔

Esto se debe a que para ejecutar las pruebas unitarias, debe ejecutar unittest como módulo principal mientras ejecuta test_add .py, utilizando el siguiente comando.

$ python -m unittest test_add.py

Al ejecutar el comando verbose anterior, vemos que las tres pruebas se han ejecutado correctamente.

Salida
...
----------------------------------------------------------------------
Ejecutadas 3 pruebas en 0.000s

OK

Sin embargo, será conveniente ejecutar las pruebas cuando se ejecute el módulo test_add¿verdad? Aprendamos cómo hacerlo en la siguiente sección.

Uso de if __name__ == '__main__' para ejecutar unittest como módulo principal

Si desea ejecutar todas las pruebas unitarias cuando el módulo se ejecute directamente, puede añadir el condicional.

# example-2/test_add.py

import unittest
from add import add_ab

class TestAdd(unittest.TestCase):
 def test_add_23(self):
 self.assertEqual(add_ab(2,3), 5)
    
 def test_add_19(self):
 self.assertEqual(add_ab(1,9), 10)
    
 def test_add_1_minus7(self):
 self.assertEqual(add_ab(1,-7), -6)

# Ejecute unittest como módulo principal
if __name__ == '__main__':
 unittest.main()

El condicional en el fragmento de código anterior indica al intérprete de Python: Si este módulo se ejecuta directamente, entonces ejecuta el código que hay dentro. unittest.main( ).

Puede ejecutar el módulo test_add después de añadir las dos líneas de código anteriores.

$ python test_add.py

▶️ Ejecutando directamente el módulo test add se ejecutan ahora las tres pruebas que hemos definido.

Salida
...
----------------------------------------------------------------------
Ejecutó 3 pruebas en 0.000s

OK

La salida anterior OK indica que todas las pruebas se han ejecutado correctamente. Los tres puntos ... indican que se ejecutaron tres pruebas y que todas fueron superadas.

Ahora, cambiemos el valor de retorno esperado test_add_1_minus7 por 8. Como la función devuelve - 6 en este caso, debería haber una prueba fallida.

def prueba_añadir_1_menos7(self):
 self.assertEqual(añadir_ab(1,-7), 8)

Como se ve en la salida de abajo, obtenemos .F., de las tres pruebas, patrón una de ellas falló (la segunda prueba), y en el traceback, obtenemos un AssertionError indicando - 6 != 8.

Salida
.F.
======================================================================
FAIL: test_add_1_minus7 (__main__.TestAdd)
----------------------------------------------------------------------
Traceback (most recent call last):
 File "test_add.py", line 12, in test_add_1_minus7
 self.assertEqual(add_ab(1,-7), 8)
AssertionError: -6 != 8

----------------------------------------------------------------------
Ejecutó 3 pruebas en 0.021s

FAILED (failures=1)

Algo importante a tener en cuenta es que las pruebas no se ejecutan necesariamente en el mismo orden en que se especifican en la clase de prueba. En el ejemplo anterior, test_add_1_minus7 está definido como el tercer método en la clase de prueba, pero la prueba correspondiente se ejecutó en segundo lugar.

Resumiendo

Espero que este tutorial le haya ayudado a entender cómo funciona la condicional if __name__ == '__main__' en Python.

He aquí una rápida recapitulación de los puntos clave:

• El intérprete de Python establece la variable __name__ antes de ejecutar el script de Python.
• Cuando ejecuta un módulo directamente, el valor de __name__ es __main__.
• Cuando importa un módulo dentro de otro script de Python, el valor de __name__ es el nombre del módulo.
• Puede utilizar if __name__ == '__main__' para controlar la ejecución y qué partes del módulo se ejecutan durante las ejecuciones directa e importada, respectivamente.

A continuación, eche un vistazo a esta guía en profundidad sobre los conjuntos de Python. Feliz aprendizaje!🎉