Comprender si __name__ == ‘__main__’ en Python

En esta guía, comprenderá la funcionalidad y la importancia de si __nombre__ == ‘__principal__’ en Python.

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

Si es así, probablemente te habrías encontrado con if __name__ == ‘__main__’ condicional 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.

¡Empecemos!

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

En Python, un módulo es un .py archivo que contiene definiciones de funciones, un conjunto de expresiones para evaluar, etc. Por ejemplo, si tenemos un archivo llamado hola_mundo.py, lo llamamos archivo hola_mundo.py o hello_world módulo.

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 uno de ellos. La clave para entender el significado. __name__ es entender cómo funcionan las importaciones en Python.

📁 Descarga el código de esta sección aquí.

ir al archivo example-1. tenemos el archivo module1.py. los __name__ La variable está en el espacio de nombres del módulo actual.

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

# example-1/module1.py
print("This is module1.")
print(f"The __name__ variable of module 1 is: {__name__}.")

ahora vamos a correr module1 desde la línea de comandos.

$ python module1.py

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

This is module1.
The __name__ variable of module 1 is: __main__.

Importación de módulos en Python

Además de ejecutar un módulo de Python, a veces desea utilizar la funcionalidad de otro módulo de Python dentro del módulo actual. Python hace esto fácil con importaciones.

Las importaciones le permiten reutilizar la funcionalidad de otro módulo, importándola al alcance del módulo actual, sin tener que volver a escribir el código.

los module2.py archivo contiene lo siguiente. importamos module1 al interior. module2.

# example-1/module2.py

import module1 # module1 is imported

print(f"This is module2")
print(f"The __name__ variable of module2 is: {__name__}.")

Correremos module2.py y mira la salida.

$ python module2.py

En la salida a continuación:

• Vemos eso module1 se ejecuta bajo el capó cuando lo importamos dentro module2y se imprime la salida correspondiente.
• Pero esta vez la variable __name__ no es __main__ sino module1.
• porque corrimos module2 directamente, la variable __name__ correspondiente al módulo ahora es __main__.

Output

This is module1.
The __name__ variable of module 1 is: module1.
This is module2
The __name__ variable of module2 is: __main__.

💡 idea clave:

– Si un módulo se ejecuta directamente, su variable __name__ se establece en igual __principal__.

– Si un módulo se importa a otro módulo, su __nombre__ se establece en el Nombre del módulo.

Ejemplo de if __name__==’__main__’ en Python

En la sección, veremos un caso de uso práctico del condicional if __name__ == ‘__main__’. Definiremos una función simple y luego escribiremos pruebas unitarias para verificar si la función funciona como se esperaba.

📁 Descarga el código y síguelo.

El código de esta sección está en el example-2 carpetas.

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

# example-2/add.py

def add_ab(a,b):
    return a + b

Usaremos Phyton unittest módulo para probar la función add_ab().

Escribir casos de prueba para una función de Python

Mire el fragmento de código a continuación, que contiene el contenido de la test_add módulo.

# 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 integrados de Python Examen de la unidad módulo
• Función de importación add_ab() de add módulo
• Define 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 con test_.

Notar: Si no nombra los métodos como test_<some-descriptive-name&gt;verás que las pruebas correspondientes no serán detectadas y por lo tanto no serán ejecutadas.

Ahora intentemos ejecutar el test_add módulo de terminales.

$ python test_add.py

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

¿Por qué es este el caso?🤔

De hecho, para ejecutar las pruebas unitarias, debe ejecutar unittest como módulo principal durante el tiempo de ejecución test_add.pyusando el siguiente comando.

$ python -m unittest test_add.py

Al ejecutar el comando detallado anteriormente, vemos que las tres pruebas se han ejecutado con éxito.

Output
...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

Sin embargo, será conveniente ejecutar las pruebas cuando este módulo test_add se ejecuta, si? Aprendamos cómo hacerlo en la siguiente sección.

Usando if __name__ == ‘__main__’ para ejecutar unittest como módulo principal

Si desea ejecutar todas las pruebas unitarias cuando el módulo se ejecuta directamente, puede agregar 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)

# Run unittest as the main module
if __name__ == '__main__':
        unittest.main()

La condición en el fragmento de código anterior le dice al intérprete de Python: si este módulo se ejecuta directamente, ejecute el código que contiene. unittest.main().

Puedes ejecutar el test_add módulo después de agregar las dos líneas de código anteriores.

$ python test_add.py

▶️ Ejecutar el módulo de prueba adicional ahora ejecuta las tres pruebas que definimos.

Output
...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

El resultado OK anterior indica que todas las pruebas se ejecutaron correctamente. Los tres puntos… indican que se realizaron tres pruebas y todas pasaron.

Ahora cambiemos el valor de retorno esperado test_add_1_minus7 a 8. Dado que la función devuelve -6 en este caso, debe haber una prueba que falle.

def test_add_1_minus7(self):
        self.assertEqual(add_ab(1,-7), 8)

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

Output
.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

----------------------------------------------------------------------
Ran 3 tests in 0.021s

FAILED (failures=1)

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

Resumen

Espero que este tutorial te haya ayudado a comprender cómo funciona el condicional if __name__ == ‘__main__’ en Python.

Aquí hay un breve resumen de las principales conclusiones:

• El intérprete de Python define el __Apellido__ variable antes de ejecutar el script de Python.
• Cuando ejecuta un módulo directamente, el valor de __Apellido__ es __principal__.
• Cuando importa un módulo a otro script de Python, el valor del __Apellido__ es el nombre del módulo.
• Puedes usar si __nombre__ == ‘__principal__’ para controlar la ejecución y qué partes del módulo se ejecutan durante las ejecuciones directas e importadas, respectivamente.

Luego, consulte esta guía detallada sobre los conjuntos de Python. ¡Feliz aprendizaje!🎉