¿Qué hace si __name__ == “__main__”: Do en Python?

    Introducción

    Es común ver if __name__ == "__main__" en los scripts de Python que encontramos en línea, o uno de los muchos que escribimos nosotros mismos.

    ¿Por qué usamos esa declaración if cuando ejecutamos nuestros programas Python? En este artículo, explicamos la mecánica detrás de su uso, las ventajas y dónde se puede utilizar.

    El atributo __name__ y el alcance __main__

    los __name__ El atributo viene por defecto como uno de los nombres en el ámbito local actual. El intérprete de Python agrega automáticamente este valor cuando ejecutamos una secuencia de comandos de Python o importamos nuestro código como un módulo.

    Pruebe el siguiente comando en su intérprete de Python. Puede descubrir que __name__ pertenece a la lista de atributos en dir():

    dir()
    

    los __name__ en Python es una variable especial que define el nombre de la clase o el módulo actual o el script desde el que se invoca.

    Crea una nueva carpeta llamada name_scripts para que podamos escribir algunos scripts para comprender cómo funciona todo esto. En esa carpeta crea un nuevo archivo, script1.py con el siguiente código:

    print(f'The __name__ from script1 is "{__name__}"')
    

    ¡Eso es una bola curva! Esperaríamos que el nombre fuera script1, como nuestro archivo. ¿Qué significa la salida __main__ ¿media?

    De forma predeterminada, cuando se ejecuta un script, el intérprete lee el script y asigna la cadena __main__ al __name__ palabra clave.

    Se vuelve aún más interesante cuando el script anterior se importa a otro script. Considere un archivo de Python llamado script2.py con el siguiente código:

    import script1  # The print statement gets executed upon import
    
    print(f'The __name__ from script2 is "{__name__}"')
    

    Como puede ver, cuando se ejecuta el script, la salida se da como script1 que denota el nombre del guión. La declaración final impresa está en el alcance de script2 y cuando se ejecuta, la salida se imprime como: __main__.

    Ahora que entendemos cómo Python usa el __name__ scope y cuando le da un valor de “__main__”, veamos por qué verificamos su valor antes de ejecutar el código.

    if __name__ == “__main__” en acción

    Usamos la sentencia if para ejecutar bloques de código solo si nuestro programa es el programa principal ejecutado. Esto permite que nuestro programa sea ejecutable por sí mismo, pero compatible con otros módulos de Python que quieran importar alguna funcionalidad sin tener que ejecutar el código.

    Considere los siguientes programas de Python:

    un) script3.py contiene una función llamada add() que se invoca solo desde el contexto principal.

    def add(a, b):
        return a+b
    
    
    if __name__ == "__main__":
        print(add(2, 3))
    

    Aquí está la salida cuando script3.py se invoca:

    Como el script se ejecutó directamente, el __name__ la palabra clave está asignada a __main__, y el bloque de código debajo del if __name__ == "__main__" se ejecuta la condición.

    b) Esto es lo que sucede cuando este fragmento se importa desde script4.py:

    import script3
    
    print(f"{script3.__name__}")
    

    El bloque debajo if __name__ == "__main__" desde script3.py no se ejecutó, como se esperaba. Esto sucedió porque el __name__ La palabra clave ahora se asigna con el nombre del script: script3. Esto puede ser verificado por la declaración de impresión dada que imprime el valor asignado para el __name__ palabra clave.

    ¿Cómo ayuda __name__ == “__main__” en el desarrollo?

    Aquí hay algunos casos de uso para usar esa declaración if al crear su script

    • Las pruebas son una buena práctica que ayuda no solo a detectar errores, sino también a garantizar que su código se comporte según sea necesario. Los archivos de prueba tienen que importarles una función u objeto. En estos casos, normalmente no queremos que el script se ejecute como módulo principal.
    • Está creando una biblioteca, pero le gustaría incluir una demostración u otros casos especiales en tiempo de ejecución para los usuarios. Al usar esta declaración if, los módulos de Python que usan su código como biblioteca no se ven afectados.

    Creación de un archivo __main__.py para módulos

    El punto de tener el if __name__ == "__main__" bloque es obtener el fragmento de código bajo la condición de ejecutarse cuando el script está en el __main__ alcance. Sin embargo, al crear paquetes en Python, es mejor si el código se ejecutará bajo la __main__ el contexto está escrito en un archivo separado.

    Consideremos el siguiente ejemplo: un paquete para realizar cálculos. La estructura del árbol de archivos para tal escenario se puede visualizar como:

    calc                 # --> Root directory
    ├── __main__.py
    ├── script1.py
    ├── script2.py
    ├── script3.py
    ├── script4.py
    └── src              # --> Sub-directory
        ├── add.py
        └── sub.py
    

    La estructura de árbol contiene calc como el directorio raíz y un subdirectorio conocido como src. los __main__.py bajo la calc directorio contiene el siguiente contenido:

    from src.add import add
    from src.sub import sub
    
    a, b = input("Enter two numbers separated by commas: ").split(',')
    a, b = int(a), int(b)
    
    print(f"The sum is: {add(a, b)}")
    print(f"The difference is: {sub(a, b)}")
    

    los add.py contiene:

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

    Y sub.py contiene:

    def sub(a, b):
        return a-b
    

    Desde fuera del calc directorio, el script se puede ejecutar y la lógica dentro del __main__.py se ejecuta invocando:

    python3 calc
    

    Esta estructura también le da un aspecto más limpio a la ubicación del espacio de trabajo, la forma en que se organizan los directorios y el punto de entrada se define dentro de un archivo separado llamado __main__.py.

    Conclusión

    los __name__ == "__main__" ejecuta bloques de código solo cuando nuestro script Python se ejecuta directamente desde un usuario. Esto es poderoso ya que permite que nuestro código tenga un comportamiento diferente cuando se ejecuta como un programa en lugar de importarse como un módulo.

    Al escribir módulos grandes, podemos optar por el enfoque más estructurado de tener un __main__.py archivo para ejecutar un módulo. Para un script independiente, incluido el if __name__ == "__main__" es un método más simple para separar la API del programa.

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *