Python: El Guardián `if __name__ == "__main__":` que te salva

Recuerdo una vez, hace años, yo recién empezaba con Python. Tenía un script pequeño que hacía algunas validaciones de datos y, si todo estaba bien, los subía a una API. Nada del otro mundo. El problema vino cuando quise usar una función de ese script en otro archivo, importándolo.

De hecho, importé el módulo y, de repente, ¡bam! El script original se ejecutó completo, validando y subiendo datos sin que yo lo pidiera. El terror. Me costó entender por qué pasaba eso. Fue ahí, con ese bug inesperado a las 2 AM, que entendí la magia del if __name__ == "__main__":.

¿Qué diablos hace esa línea?

Es simple: es un guardián. En Python, cuando ejecutas un archivo como script principal (por ejemplo, python mi_script.py), la variable especial __name__ toma el valor de la cadena "__main__".

Pero ojo que si ese mismo archivo es importado como un módulo en otro script (por ejemplo, import mi_script), entonces __name__ toma el nombre del módulo, en este caso "mi_script".

¿Se entiende la diferencia? Todo el código que está fuera de funciones o clases se ejecuta apenas se importa un módulo. Si tienes llamadas a funciones o procesos complejos a nivel global, se van a correr.

El ejemplo vale más que mil palabras

Imagina este archivo, llamémoslo operaciones.py:

# operaciones.py

def saludar():
    print("¡Hola desde operaciones.py!")

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

print(f"Esto se imprime siempre que se carga el módulo. __name__ es: {__name__}")

if __name__ == "__main__":
    saludar()
    resultado = sumar(5, 3)
    print(f"Si soy el script principal, la suma es: {resultado}")

Si ejecutas python operaciones.py:

• Verás el mensaje "Esto se imprime siempre..." (porque es código de nivel superior).
• Verás "¡Hola desde operaciones.py!" y "Si soy el script principal..." (porque __name__ es "__main__").

Pero si tienes otro archivo, digamos app.py, que importa operaciones.py:

# app.py

import operaciones

print("Estoy en app.py")

# Puedo usar las funciones de operaciones.py
# operaciones.saludar()
# mi_suma = operaciones.sumar(10, 2)
# print(f"Suma desde app.py: {mi_suma}")

Al ejecutar python app.py:

• Solo verás el mensaje "Esto se imprime siempre..." (de operaciones.py, porque el módulo se cargó).
• Luego, verás "Estoy en app.py".
• Pero no verás los mensajes de saludar() o sumar() que estaban dentro del if __name__ == "__main__": en operaciones.py. ¿Por qué? Porque cuando operaciones.py fue importado, su __name__ era "operaciones", no "__main__".

¿Cuándo usarlo y cuándo no?

En mi caso, lo uso casi siempre. Me gusta que mis módulos sean reutilizables sin efectos secundarios inesperados. Evita la sobreingeniería de tener que reestructurar todo un script si más adelante quieres importar una función de él.

El if __name__ == "__main__": te permite tener código que define el comportamiento cuando el script se ejecuta directamente, sin que ese código se entrometa si otro módulo solo quiere importar tus funciones. Es una solución simple que funciona de maravilla.

¿Cuándo no vale la pena? Si tu script es realmente trivial, un archivo de una o dos funciones que sabes que nunca vas a importar, igual sirve dejarlo sin el guardián. Pero la verdad, por la costumbre, ya lo pongo casi por default. Es un pequeño hábito que te ahorra grandes dolores de cabeza a futuro.