Ejecutar scripts Python con `if name == 'main'`

Resumen

¿Qué es y cómo funciona la variable `name` en Python?

Python cuenta con una característica poderosa que permite ejecutar código de manera directa usando la variable __name__. Este enfoque es invaluable para desarrolladores, facilitando la modularidad, la ejecución de pruebas y la depuración eficiente del código. La acción de establecer if __name__ == "__main__": nos permite ejecutar directamente el código que se encuentra dentro de este bloque cuando el archivo es ejecutado como un script principal.

¿Por qué es útil usar `name == "main"`?

Aquí te explico las tres ventajas principales que ofrece esta característica:

Modularidad: Permite reutilizar el código fácilmente. Puedes definir funciones o clases que podrán ser importadas por otros módulos sin ejecutar el código de testeo o ejemplos incluidos en el script.
Ejecución de pruebas y depuración: Facilita probar partes del código de manera aislada y directamente desde la línea de comandos.
Automatización de funciones: Cualquier operación o cálculo que se encuentre dentro del bloque if __name__ == "__main__": se ejecuta automáticamente al correr el archivo, generando resultados inmediatos.

if __name__ == "__main__":
    # Código que queremos ejecutar de manera directa
    res1 = sumar(3, 4)
    print(f"Suma: {res1}")

¿Cómo crear un script Python con operaciones matemáticas básicas?

Antes de ejecutar un script, necesitamos crear funciones matemáticas básicas. En este caso, las funciones cubrirán suma, resta, multiplicación y división. El siguiente paso te guiará en su implementación.

Define tus funciones de cálculo

Aquí te muestro cómo deben verse las funciones en tu código:

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

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

def multiplicar(a, b):
    return a * b

def dividir(a, b):
    if b == 0:
        raise ValueError("El divisor no puede ser cero.")
    return a / b

¿Cómo ejecutar las operaciones automáticamente?

El siguiente bloque se utilizará dentro de nuestro script para llevar a cabo las operaciones matemáticas y mostrar los resultados automáticamente cuando el archivo se ejecute.

if __name__ == "__main__":
    print("Estas son las operaciones:")
    
    # Ejemplo de uso con suma
    res1 = sumar(3, 4)
    print(f"Suma: {res1}")
    
    # Ejemplo de uso con división
    res2 = dividir(10, 7)
    print(f"División: {res2}")

Ejecuta y modifica tu script en la terminal

Para ver cómo funciona este sistema de ejecución directo, puedes emplear la terminal. Aquí te explico cómo realizarlo:

Accede al directorio: Navega hacia la carpeta donde está guardado tu script.
Usa el intérprete de Python: Ejecuta tu script usando Python 3 como sigue:
```
python3 calculadora.py
```

Esto imprimirá de manera automática los resultados de las operaciones definidas bajo el bloque if __name__ == "__main__":.

Siguientes pasos: Gestión de empleados

Como parte de tus prácticas, te sugerimos desarrollar un nuevo script que gestione empleados. Implementa dos funciones: una para agregar empleados y otra para eliminarlos. Ejecuta estas funciones utilizando if __name__ == "__main__":, lo que permitirá que visualices los resultados en la terminal.

Este método no solo agilizará tus procesos de desarrollo, sino que también mejorará tu flujo de trabajo haciendo que tu tiempo en el mundo del código sea mucho más eficiente y productivo. ¡Adelante con tus proyectos!

Juan Diego Cabrera Remírez

student•

Para entender el if __name__ == "__man__"

Es necesario tener 2 archivos.

En el primer archivo tengo esto.

en el segundo archivo tengo esto.

Al final del archivo dos. Especifico que si __name__ no es igual a __main__ Entonces muestre solo los datos de la persona.

Pero que si es __main__ Entonces puede despedir a la persona.

NOTA: Cuando se ejecuta el archivo 2 desde el archivo 1. el archivo 1 es __main__ Pero el archivo dos NO.

Pero si ejecuto directamente el archivo 2. Entonces SI pasa a ser __main__

Alexis Dorado Muñoz

student•

Gracias por tu aporte!

William Alfredo Bermudez Leal

student•

Genial, con esto me queda más claro

Edwin Daniel Méndez Amaya

student•

#Lista de diccionarios
employees = []

def add_employee(name: str) -> dict:
    '''
    Crea un diccionario con un único ítem(name) y lo agrega a la lista de empleados
    '''
    tupla = [('name', name)]
    dict_employee = {key: value for (key,value) in tupla}
    employees.append(dict_employee)
    return dict_employee

def delete_employee(name: str):
    '''
    Busca el nombre(name) entre los diccionarios de la lista de empleados y elimina al empleado de la lista
    '''
    for dicti in employees:
        if dicti.get('name') == name:
            employees.remove(dicti)


if __name__ == '__main__':
    print(employees)
    add_employee('David')
    print(employees)
    add_employee('Carlos')
    print(employees)
    delete_employee('David')
    print(employees)

```#Lista de diccionariosemployees = \[]
def add\_employee(name: str) -> dict:    '''    Crea un diccionario con un único ítem(name) y lo agrega a la lista de empleados    '''    tupla = \[('name', name)]    dict\_employee = {key: value for (key,value) in tupla}    employees.append(dict\_employee)    return dict\_employee
def delete\_employee(name: str):    '''    Busca el nombre(name) entre los diccionarios de la lista de empleados y elimina al empleado de la lista    '''    for dicti in employees:        if dicti.get('name') == name:            employees.remove(dicti)

if \_\_name\_\_ == '\_\_main\_\_':    print(employees)    add\_employee('David')    print(employees)    add\_employee('Carlos')    print(employees)    delete\_employee('David')    print(employees)

Alexis Dorado Muñoz

student•

Gracias por tu aporte!

Mario Alexander Vargas Celis

student•

El bloque if \_\_name\_\_ == "\_\_main\_\_": en Python se usa para que una sección específica de código solo se ejecute cuando el archivo es ejecutado directamente, y no cuando es importado como módulo en otro archivo. Este es un patrón común en Python, especialmente para escribir scripts y bibliotecas que puedan ser reutilizados y probados.

### ¿Cómo funciona if \_\_name\_\_ == "\_\_main\_\_":?

Cuando se ejecuta un archivo Python, el intérprete asigna el valor especial "\_\_main\_\_" a la variable \_\_name\_\_ si el archivo se ejecuta directamente. Sin embargo, si el archivo es importado como un módulo en otro archivo, \_\_name\_\_ toma el valor del nombre del archivo, sin ejecutar el bloque que depende de "\_\_main\_\_".

### Estructura del Bloque if \_\_name\_\_ == "\_\_main\_\_":


\# archivo.py



def funcion\_principal():

&#x20;   print("Esta es la función principal del módulo.")



\# Ejecutar solo si es el archivo principal

if \_\_name\_\_ == "\_\_main\_\_":

&#x20;   print("El archivo se ejecuta directamente.")

&#x20;   funcion\_principal()

### Ejemplo de uso práctico

Supongamos que tienes un archivo, calculadora.py, que define algunas funciones matemáticas:


\# calculadora.py



def sumar(a, b):

&#x20;   return a + b



def restar(a, b):

&#x20;   return a - b



def multiplicar(a, b):

&#x20;   return a \* b



def dividir(a, b):

&#x20;   return a / b



if \_\_name\_\_ == "\_\_main\_\_":

&#x20;   print("Ejecutando pruebas...")

&#x20;   print(sumar(5, 3))         # Salida: 8

&#x20;   print(restar(5, 3))        # Salida: 2

&#x20;   print(multiplicar(5, 3))   # Salida: 15

&#x20;   print(dividir(5, 3))       # Salida: 1.666...

### Ejecución del Bloque

1. **Ejecución directa**: Si corres calculadora.py directamente (python calculadora.py), se imprimirá el mensaje "Ejecutando pruebas..." y el resultado de cada función.

2. **Importación como módulo**: Si importas calculadora.py en otro archivo, digamos main.py:

```python

# main.py

import calculadora

resultado = calculadora.sumar(10, 5)

print(resultado) # Salida: 15

```

En este caso, calculadora.py **no** ejecutará el bloque dentro de if \_\_name\_\_ == "\_\_main\_\_":, evitando la impresión del mensaje de prueba y otros cálculos no deseados.

### Ventajas de if \_\_name\_\_ == "\_\_main\_\_":

1. **Evita ejecución no deseada**: Permite ejecutar código solo cuando se ejecuta el archivo principal y evita la ejecución de pruebas o funciones adicionales cuando el archivo es importado.

2. **Modularidad**: Facilita el uso de módulos en diferentes proyectos sin cambios adicionales.

3. **Pruebas rápidas**: Permite agregar pruebas simples o mensajes para verificar el comportamiento del código en desarrollo, manteniéndolo separado de la funcionalidad principal.

En general, if \_\_name\_\_ == "\_\_main\_\_": ayuda a mantener el código organizado y reutilizable, al tiempo que permite pruebas internas sin interferir cuando el código se importa en otros archivos.

Brandon Fonseca

student•

Uuf excelente aporte. Ahora lo comprendo mejor.

alejandro sobrevilla

student•

'''
Implemetar un archivo gestion_empleados.py que contenga
    1.Funciona para agregar y eliminar empleados de una lista

    2. Un bloque 'if __name__' == "main" que permita probar el
    funcionamiento del script ejecuatado directamente
'''

employeers = [
    {'name': 'Carlos', 'role': 'admin'},
    {'name': 'Juan', 'role': 'employee'},
    {'name': 'Jose', 'role': 'employee'},
    {'name': 'Ana', 'role': 'employee'}
]


def delete_employeer(employeers: list[dict], name_employeer: str):
    for employeer in employeers:
        if (employeer["name"] == name_employeer):
            employeers.remove(employeer)
            return True
    return False


def add_amployeer(employeers: list[dict], name: str, role: str):
    employeers.append({"name": name,"role": role})

if __name__ == "__main__":
    print(delete_employeer(employeers, "Juan"))
    print(employeers)
    add_amployeer(employeers, "Antonio", "admin")
    print(employeers)

Ivan Leonel Ales

student•

Creo que esta clase corta es la mejor que hicieron. Acuérdense que pueden divertirse un poquito mientras hacen el codigo :)

Juan Jose Rodriguez De Gouveia

student•

para entender bien esto de la variable __name__ hay que tener en cuenta que:

todos los archivos .py son módulos y que estos pueden ser ejecutados directamente o importados en otro archivo.
cuando un archivo .py se ejecuta directamente, __name__ tiene el valor "__main__".
cuando un archivo .py se importa en otro archivo, __name__ tiene el valor del nombre del archivo.

Por lo tanto, si un archivo .py se ejecuta directamente, __name__ tendrá el valor "__main__", pero si se importa en otro archivo, __name__ tendrá el valor del nombre del archivo.

Por lo tanto, el if __name__ == "__main__": es una forma de crear un punto de entrada para ejecutar la lógica de nuestro proyecto.

Si ejecutas el siguiente código te darás cuenta de lo que te menciono, veras que si ejecutamos el archivo main.py veremos que en su ejecución veremos el print la variable __name__ del archivo modulo.py y que este tiene por nombre modulo y no __main__

main.py

import modulo

if __name__ == "__main__":
    print("Hola soy el archivo main")

modulo.py

print(__name__)

if __name__ == "__main__":
  print("Hola soy el archivo modulo")

brandon pardo

student•

<u>Buenas tardes, por que se coloca Python 3</u>

Andres David Caicedo Marquez

student•

Es solo un standard segun el python que hayas descargado a mi me funciona, (py)

Kevin I. Villar

student•

from typing import List, Dict

# Lista global de empleados
empleados: List[Dict[str, str | int | float]] = []


def agregar_empleado(nombre: str, edad: int, salario: float) -> None:
    """
    Agrega un empleado a la lista global de empleados.
    """
    nuevo_empleado = {
        "nombre": nombre,
        "edad": edad,
        "salario": salario
    }
    empleados.append(nuevo_empleado)
    print(f"✅ Empleado agregado: {nombre}")


def eliminar_empleado(nombre: str) -> None:
    """
    Elimina un empleado de la lista por su nombre.
    Si no existe, muestra un mensaje de advertencia.
    """
    global empleados
    for empleado in empleados:
        if empleado["nombre"].lower() == nombre.lower():
            empleados.remove(empleado)
            print(f"🗑️ Empleado eliminado: {nombre}")
            break
    else:
        print(f"⚠️ No se encontró ningún empleado con el nombre '{nombre}'.")


def mostrar_empleados() -> None:
    """
    Muestra la lista actual de empleados.
    """
    if not empleados:
        print("📋 No hay empleados registrados.")
    else:
        print("\n👥 Lista de empleados:")
        for emp in empleados:
            print(f" - {emp['nombre']}, Edad: {emp['edad']}, Salario: ${emp['salario']:.2f}")


# Bloque principal de prueba
if __name__ == "__main__":
    print("=== SISTEMA DE GESTIÓN DE EMPLEADOS ===\n")

    # Agregar empleados
    agregar_empleado("Ana", 28, 2500.0)
    agregar_empleado("Luis", 35, 3200.5)
    agregar_empleado("Carla", 30, 2900.0)

    # Mostrar lista
    mostrar_empleados()

    # Eliminar un empleado
    eliminar_empleado("Luis")

    # Mostrar lista actualizada
    mostrar_empleados()

    # Intentar eliminar un empleado inexistente
    eliminar_empleado("Pedro")

Diego Arango

student•

def add_employee(employee_list: list[dict], new_employee: dict) -> list[dict]:
    """
    Agrega un nuevo empleado a la lista de empleados sin modificar la lista original.
    
    Parámetros:
        employee_list (list[dict]): Lista de empleados existentes, cada empleado es un diccionario.
        new_employee (dict): Nuevo empleado que se desea agregar a la lista.

    Retorna:
        list[dict]: Una nueva lista que contiene a los empleados originales más el nuevo empleado.
    """
    return [employee for employee in employee_list] + [new_employee]
  

def delete_employee(employee_list: list[dict], name: str) -> list[dict]:
    """
    Elimina de la lista todos los empleados cuyo nombre coincida con el valor dado.
    
    Parámetros:
        employee_list (list[dict]): Lista de empleados existentes.
        name (str): Nombre del empleado a eliminar.

    Retorna:
        list[dict]: Una nueva lista con todos los empleados excepto el que coincide con el nombre.
    """
    return [employee for employee in employee_list if employee.get("name") != name]
    

# Lista inicial de empleados
list_of_employees = [
    {"name": "David", "age": 42, "salary": 4500},
    {"name": "Leo", "age": 39, "salary": 3500},
    {"name": "Sofia", "age": 32, "salary": 5500}  
]

# Nuevo empleado que se desea agregar
new_employee = {
    "name": "Diego",
    "age": 42,
    "salary": 7500
}

if __name__ == "__main__":

    # Se agrega un nuevo empleado a la lista (sin modificar la original)
    updated_list = add_employee(list_of_employees, new_employee)
    print("Lista después de agregar un nuevo empleado:")
    print(updated_list)

    # Se elimina un empleado (David) de la lista actualizada
    updated_list2 = delete_employee(updated_list, "David")
    print("\nLista después de eliminar a David:")
    print(updated_list2)

Platzi Team

student•

empleados = [{'nombre': 'Jose', 'edad': 25, 'identificacion': 'ID001', 'cargo': 'Analista'}
             , {'nombre': 'Maria', 'edad': 30, 'identificacion': 'ID002', 'cargo': 'Gerente'}
             , {'nombre': 'Luis', 'edad': 28, 'identificacion': 'ID003', 'cargo': 'Desarrollador'}]
def agregar_empleado(nombre, edad, identificacion, cargo):
    empleados.append({'nombre': nombre, 'edad': edad, 'identificacion': identificacion, 'cargo': cargo})
    print(f'Empleado {nombre} agregado.')

def eliminar_empleado(identificacion):
    global empleados
    empleados = [emp for emp in empleados if emp['identificacion'] != identificacion]
    print(f'Empleado con ID {identificacion} eliminado.')

if __name__ == "__main__":
    agregar_empleado("Juan", 30, "ID004", "Desarrollador")
    agregar_empleado("Ana", 25, "ID005", "Diseñadora")
    eliminar_empleado("ID004")
    print(empleados)

Juan Diego

student•

Cuando se dice que "el archivo es ejecutado como un script principal", significa que el código dentro de ese archivo se ejecuta directamente cuando se llama a su nombre en la terminal o se ejecuta desde un entorno de desarrollo. Esto se logra usando la condición if __name__ == '__main__'. Este mecanismo permite que el archivo actúe como un módulo que puede ser importado sin ejecutar su contenido, a menos que sea el archivo principal que se está ejecutando. Esto es útil para modularidad y pruebas.

Omar Adrian Cuk

student•

El uso de if __name__ == '__main__' permite que el código dentro de este bloque solo se ejecute cuando el script se ejecuta directamente, no cuando se importa como un módulo en otro archivo. Si llamas a funciones fuera de este bloque, se ejecutan cada vez que el script se carga, lo que puede no ser deseable si solo quieres probar funciones o reutilizar código en otros scripts. Esto mejora la modularidad y la reutilización del código.

Sebastian Cerquera carvajal

student•

Mi respuesta al reto:

#Implementar un archivo gestion_empleados.py que contenga:
#1. Funciones para agregar y eliminar empleados en una lista
#2. Un bloque if __name__ == '__main__'; que permita probar el funcionamiento del scrip ejecutandolo directamente

employees = []

def add_employee(employee):
    employees.append(employee)

def remove_employee(employee):
    employees.remove(employee)


if __name__ == '__main__':
    add_employee('Carlos')
    add_employee('Maria')

    print('Empleados activos: ', employees)

    remove_employee('Carlos')
    print('Empleado eliminado')
    print('Empleados activos: ', employees)

Alvaro Rafael Guete Puello

student•

¿Cómo afecta el uso de __name__ al importar módulos entre archivos en un proyecto de Python?

Diego Alfonso Montenegro Bravo

student•

def agregar_empleado(lista_empleados, nombre):
    """Agrega un empleado a la lista si no está repetido."""
    if nombre not in lista_empleados:
        lista_empleados.append(nombre)
        print(f"Empleado '{nombre}' agregado.")
    else:
        print(f"El empleado '{nombre}' ya está en la lista.")

def eliminar_empleado(lista_empleados, nombre):
    """Elimina un empleado si existe en la lista."""
    if nombre in lista_empleados:
        lista_empleados.remove(nombre)
        print(f"Empleado '{nombre}' eliminado.")
    else:
        print(f"El empleado '{nombre}' no se encuentra en la lista.")

if __name__ == "__main__":
    empleados = []

    print("Probando funciones:")
    agregar_empleado(empleados, "Carlos")
    agregar_empleado(empleados, "María")
    agregar_empleado(empleados, "Carlos")  # Intento duplicado
    print("Lista actual:", empleados)

    eliminar_empleado(empleados, "Carlos")
    eliminar_empleado(empleados, "Pedro")  # No está en la lista
    print("Lista final:", empleados)
```def agregar\_empleado(lista\_empleados, nombre):    """Agrega un empleado a la lista si no está repetido."""    if nombre not in lista\_empleados:        lista\_empleados.append(nombre)        print(f"Empleado '{nombre}' agregado.")    else:        print(f"El empleado '{nombre}' ya está en la lista.")
def eliminar\_empleado(lista\_empleados, nombre):    """Elimina un empleado si existe en la lista."""    if nombre in lista\_empleados:        lista\_empleados.remove(nombre)        print(f"Empleado '{nombre}' eliminado.")    else:        print(f"El empleado '{nombre}' no se encuentra en la lista.")
if \_\_name\_\_ == "\_\_main\_\_":    empleados = \[]
    print("Probando funciones:")    agregar\_empleado(empleados, "Carlos")    agregar\_empleado(empleados, "María")    agregar\_empleado(empleados, "Carlos")  # Intento duplicado    print("Lista actual:", empleados)
    eliminar\_empleado(empleados, "Carlos")    eliminar\_empleado(empleados, "Pedro")  # No está en la lista    print("Lista final:", empleados)

Diego Alfonso Montenegro Bravo

student•

def agregar_empleado(lista_empleados, nombre): """Agrega un empleado a la lista si no está repetido.""" if nombre not in lista_empleados: lista_empleados.append(nombre) print(f"Empleado '{nombre}' agregado.") else: print(f"El empleado '{nombre}' ya está en la lista.") def eliminar_empleado(lista_empleados, nombre): """Elimina un empleado si existe en la lista.""" if nombre in lista_empleados: lista_empleados.remove(nombre) print(f"Empleado '{nombre}' eliminado.") else: print(f"El empleado '{nombre}' no se encuentra en la lista.") if __name__ == "__main__": empleados = [] print("Probando funciones:") agregar_empleado(empleados, "Carlos") agregar_empleado(empleados, "María") agregar_empleado(empleados, "Carlos") # Intento duplicado print("Lista actual:", empleados) eliminar_empleado(empleados, "Carlos") eliminar_empleado(empleados, "Pedro") # No está en la lista print("Lista final:", empleados)

Danny Alejandro fernandez gallego

student•

user = []


def add_user(user_1):
    user.append(user_1)
    return f"Usuarios agregados: {user}"

def del_user(user_2):
    user.remove(user_2)
    return f"Usuarios nuevos: {user}"

if __name__ == "__main__":
   print("Usuarios: ")
   print(add_user("Jose"))
   print(add_user("Daniela"))
   print(add_user("Pedro"))
   print(del_user("Jose"))

Gabriel Ariza

student•

Aqui dejo el reto de la clase con decoradores :D

class Employee:
   def __init__(self, name, age):
      self.name = name
      self.age = age

class Management_System:
   def __init__(self):
      self.employees = []

   # Decorador para ver las modificaciones en el sistema
   def system_access(func):
      def wrapper(self, employee: Employee):
         print("\nIniciado cambios en el sistema...")
         func(self, employee)
         print("Finalizando cambios en el sistema...")
      return wrapper

   @system_access
   def add_employee(self, employee: Employee):
      self.employees.append(employee)
      print(f"* El empleado {employee.name} ah sido añadido.")

   @system_access
   def delete_employee(self, employee: Employee):
      if employee in self.employees:
         self.employees.remove(employee)
         print(f"* El empleado {employee.name} ah sido eliminado.")
      else:
         print(f"* El empleado {employee.name} no esta en la base de datos.")
   
   def show_employees(self):
      print(f"\nLista de empleados")
      for employee in self.employees:
         print(f"- Nombre: {employee.name}, Edad: {employee.age}.")

   

if __name__ == '__main__':
   print(f"Sistema de manejo de empleados")
   empleado1 = Employee("Susano", 1000)
   empleado2 = Employee("Gojira", 420)  
   empleado3 = Employee("Juan", 69)
   sistema = Management_System()
   sistema.add_employee(empleado1)
   sistema.add_employee(empleado3)
   sistema.show_employees()
   sistema.delete_employee(empleado3)
   sistema.add_employee(empleado2)
   sistema.show_employees()