Módulos como scripts: __name__ y __main__

if name == “main”:
run()

Se le llama: Entry point

Este if dice que si es ejecutado desde la terminal, entre al run y si es ejecutado desde otro archivo, no se ejecuta.

if __name__ == "__main__":
	run()

MÓDULOS COMO SCRIPTS: NAME y MAIN

Cuando utilizamos name == ‘main’ estamos dando dualidad a cierta función para que sea ejecutada en dos archivos distintos.

Para ello debemos tener en cuenta que su uso esta catalogado de dos maneras:

1. Se puede ejecutar el archivo como un script.
2. Importando el codding de un archivo a otro archivo python.

Para Python, es independiente cual de las dos formas estemos utilizando el código, ya que python define una variable especial llamada __name__ la cual contiene un string y cuyo resultado dependerá de la forma en como sea usada.

Como en el ejemplo, se observa que el primer archivo que denominamos main.py.

main.py

import utils

keys, values = utils.get_population()
print(keys, values)

data = [
  {
    'country': 'Colombia',
    'Population': 500
  },
  {
    'country': 'Peru',
    'Population': 250
  },
  {
    'country': 'Argentina',
    'Population': 350
  }
]

def run():
  keys, values = utils.get_population()
  print(keys, values)

  country = input('Digite el país: ')
  result = utils.population_by_countrie(data, country)
  print(result)

if __name__ == '__main__':
  run()

Cuando ejecutamos el archivo directamente como un script nuestra variable if __name__ tomara el valor de __main__

Al ser ejecutado nuestro output será el siguiente:

Producción:

Digite el país: Peru
[{'country': 'Peru', 'Population': 250}]

Con esto podemos concluir que la función __name__ == '__main__' ayuda a que python identifique de que manera se debe ejecutar e o los módulos ó script.
Material de apoyo

El profe Facundo nos habló de utilizar el entry point como una buena prática de programación. Ahora Nicolás nos explica la razón detrás de su uso. Agradecido con ambos.

• **__name__**es una variable especial en Python que contiene el nombre del módulo en el que se está ejecutando el código.
• Cuando ejecutas un archivo como un script principal en Python, el valor de __name__
  es igual a "__main__". Esto significa que el archivo se está ejecutando como un script principal y no está siendo importado por otro módulo o script.
• Por ejemplo, si tienes un archivo llamado **mi_script.py**con el siguiente código:

print(__name__)
#Output: __main__

• En cambio, si importas **mi_script.py**desde otro módulo o script, el valor de **__name__**será el nombre del módulo (en este caso, mi_script).
• Por lo tanto, cuando escribes if __name__ == "__main__":, estás diciendo “si estoy ejecutando este archivo como un script principal, ejecuta el código dentro de este bloque”.
• Esto es útil porque te permite escribir código que solo se ejecute cuando el archivo se ejecute como un script principal y no cuando se importe como un módulo.

Me quedé algo confundido con la explicación de if name == main así que salí a investigar un poco y encontré este artículo que les comparto. Ahora lo tengo más claro.

un recurso muy util sobre la misma sentencia me ayudo mucho en mis inicios con Python
https://realpython.com/if-name-main-python/

Modulos como Script

Un archivo py se corre como script al ejecutarlo en la linea de comando como:

 >> python utils.py

Y tambien puede correr desde otro archivo (main) cuando es utilizado como modulo:

import utils
>> python main.py

Sin embargo, al querer utilizar una de las funciones del main en otro archivo (example) ocurre que se ejecuta primero todo el archivo main para luego darte acceso a la funcion requerida por el archivo example. Esto es un problema ya que solo quieres utilizar la funcion sin que se ejecute todo el main. La solucion se conoce como los DATAPOINT

# indica que si el archivo es ejecutado desde la terminal se ejecute run()
# en caso de ser ejecutado desde otro archivo como modulo no se corra run()
if __name__ == '__main__':
	run()

Esto le da la dualidad a los modulos de ejecutarse tanto como script desde la terminal como tambien desde otro archivo como un modulo

El archivo main puede reestructurarse de la siguiente manera para que tome la dualidad antes mencionada:

# llamar al modulo utils
import utils

# lista de paises con su repectiva poblacion
data = [
  {
    'Country':'colombia',
    'Population':30
  },
  {
    'Country':'bolivia',
    'Population':18
  },
  {
    'Country':'mexico',
    'Population':100
  },
  {
    'Country':'nicaragua',
    'Population':7
  }
]

def run():
  # utilizar la funcion get_population
  Pais, Poblacion = utils.get_population()
  print(Pais, Poblacion)
  
  # utilizar la variable A
  print(utils.A)
  
  # obtener la poblacion de un pais especifico
  poblacion = utils.population_by_country(data, 'mexico')
  print(poblacion)
  
  # obtener el pais del cual queremos saber su poblacion de forma dinamica
  country = input('Digite el pais: ')
  poblacion_pais = utils.population_by_country(data, country)
  print(poblacion_pais) 

if __name__ == '__main__':
  run()

Las instrucciones de main quedan encerradas en una funcion llamada run() y se agrega el datapoint junto a la funcion run() para que esta corra solo cuando el archivo sea ejecutado desde la terminal.

En el archivo example pedimos que se muestre data y que se ejecute la funcion run() del archivo main de la siguiente manera:

import main

# obtener la data del archivo main
print(main.data)
main.run()

Honestamente no entendí nada de esto.

Que tal, no pude quedarme con las ganas e implementé el código de esta clase tanto en vscode y en replit, después de algunas correcciones ya no marcó errores pero las gráficas no las muestra, alguien sabe por qué? estoy sobre ubuntu con wsl será por eso? incluso instalé desde línea de código matplotlib, y como no las mostraba debugee el código y si mostraba la lista con datos del archivo csv. Se me ocurrió ir a un jupyter el de colab de google y ahí si funciona 😊 espero alguien me oriente les dejo la jupyter notebook!

por primera vez alguien explico bien para que sirve el

if __name__ == "__main__":

__ name __ ejecutado desde el propio modulo (modulo a) es igual a __ main __, pero si el (modulo a) se importa y ejecuta desde otro modulo (modulo b), __ name __ es igual al nombre del modulo importado (modulo a).
De esta manera, con el:

if __name__ == '__main__'

podemos controlar que parte del codigo queremos que se ejecute solo si es llamado desde el propio modulo.

https://www.youtube.com/watch?v=Fh3RfVKWVII

En resumen, su nombre tecnico es entry point, punto de entrada.

Y nos permite definir que el modulo pueda ser usado cuando se ejecuta desde la terminal, y previene que esa ejecucion ocurra cuando es llamado desde otro archivo como modulo, evitando así una doble ejecucion.

# Entry point
if __main__ == "_main__:
run()

Recomiendo mucho leer este pequeño post para entender mucho mejor la importancia de:

if __name__ == "__main__":
    main():

Muy muy muy muy muy necesario y útil en casi cualquier programa de python.

No entiendo porque igual me corre el programa, es decir me el modulo me lee la funcion así no la invoque

https://www.youtube.com/watch?v=wZKTUcTqekw

por si alguno como yo no pudo entender esta clase en particular

Como aportacion adicional, me gustaria que especifiquen que informacion debe ir en el main .py y que en los demas archivos.

Por que yo de priumera instancia pensaria que en MAIN se va a poner solo el codigo principal. Por ende, en el se van a llamar los modulos que que necesiten.
Pero viendo el video, hacen todo lo opuesto.
Me gustaria que aclararan esta parte.

¡Estas clases son excelentes! ¡Gracias, Nico! Empecé a estudiar con estas clases cuando aún no trabajaba en IT y, ahora que sí trabajo en esta industria, vuelvo a ellas para recuperar ideas importantes. ¡Muy agradecido! Saludos desde Buenos Aires (Argentina).

Yo no sé a vosotros, pero yo personalmente, haciendome apunte es mi OneNote, con capturas de pantalla y apuntes en cada captura, entiendo esto mucho mejor, aunque tarde 50 minutos en acabar este video de solo 8 minutos.
Genial la clase!

Me gustó esta clases, no entendía porque el if

Modulos como scripts

• Cuando un módulo de Python se ejecuta como un script independiente, se utiliza una variable especial llamada “name”.

• Se utiliza para determinar si el módulo se está ejecutando como script o se está importando como un módulo en otro script.

• Si el módulo se está ejecutando como script, el valor de “name” será “main”.

• Si el módulo se está importando en otro script, el valor de “name” será el nombre del módulo.

• Esta distinción es importante porque permite que un módulo se comporte de manera diferente dependiendo de cómo se esté utilizando.
  Por ejemplo, si un módulo se está ejecutando como script, puede realizar algunas operaciones de prueba o depuración adicionales que no son necesarias si se está importando en otro script.

• Si un módulo se está importando, puede proporcionar funciones y variables útiles sin ejecutar código adicional innecesariamente.

Entonces:
La variable especial “name” en Python permite que un módulo se comporte de manera diferente dependiendo de si se está ejecutando como script o se está importando en otro script, lo que permite una mayor flexibilidad y eficiencia en la programación.

https://www.linkedin.com/pulse/qué-es-el-entry-point-en-python-juan-diego-ramirez-zuluaga/?originalSubdomain=es

Explicación de la variable main de forma muy sencilla !!

Esta clase fue clave para entender todo lo que venimos haciendo y aprendiendo para entender como se trabaja de manera correlativa e interconectada dentro del ambiente de desarrollo Python. Sobre todo cuando uno es principiante. Muy buena clase.

Buena práctica: if name == 'main’
Es común incluir un bloque de código dentro de un módulo que solo se ejecutará cuando el archivo sea ejecutado directamente y no cuando sea importado como un módulo en otro archivo.
Esto se logra utilizando la siguiente estructura:

if __name__ == '__main__':
    # Código a ejecutar cuando el archivo es ejecutado directamente

Me soprende la forma de usar los scripts de los modulos. Si que aprendi bastante. Estoy casi listo para controlar estos paquetes.

✅

al colocar "if __name__ == '__main__': run()", la finalidad de esto es que si: 1. Si importas el módulo (archivo .py) dentro de otro archivo, no se ejecute automáticamente, sino que tu puedes controlar la ejecución haciendo el llamado de las funciones (import functools ... functools.reduce() ). 2. Si ejecutas el módulo como script desde la terminal, la función(es) que estén declaradas después del "entry point", se ejecutarían también automáticamente. Esto siempre lo he visto en los otros cursos y ahora lo entiendo

# punto de inicio o punto de entrada de un programa o aplicación
# entry point
if __name__ == '__main__':
    run()

"""
Esta estructura se utiliza para asegurarse de que el código dentro del bloque if __name__ == '__main__': 
solo se ejecute cuando el archivo de Python se 
ejecuta directamente como un programa y no cuando se importa como un módulo en otro programa.
"""

Como coreccion a mi anterior aportacion, esta es la correctaahora con las buenas practicas.

main .py

import all_variations
all_variations.run() 

all_variations.py

def run():
  word = input('¿Que palabra o Frase quieres validar? ')
  variations = {
    'Original': word
  }
  variations['Mayusculas'] = word.upper()
  variations['Minusculas'] = word.lower()
  variations['Nom Prop'] = word.title()
  print(variations)
  return variations


if __name__ == '__main__':
  run() 

Gran clase!.

seguramente te estes preguntando.
que es un script?: Es un archivo que realiza una terea especifica dentro del programa que tu creas, para iniciar un programa, conectar, para finalizar, osea hace algo espeifico en el codigo
que es un modulo?: Es un archivo que se reutiliza mientras corre el programa, que se debe importar, te devuelve un resultado, tiene variables,funciones, objetos mas iterables.

Le dije a Bing que hiciese una analogía con minecraft sobre este tema, aquí el resultado:

Para tener en cuenta el __main__ es porque así es el syntax no porque el archivo se llame main, realmente el archivo puede llamarse de cualquier forma. Algo que quise probar y comparto.

Si no queremos que al importar se ejecute todo un módulo, solo lo invocado, para eso tenemos que modularizarlo, una forma es embeberlo en una función, para ejecutarlo explícitamente desde example_py.

import main

print('example =>', main.data)
main.run()

Si quiero controlar desde example_py la ejecución de main o elementos de este módulo, pero a la vez la dualidad de ejecutar main_py como script desde la terminal, usamos el entry point:

if __name__ == '__main__':
  run()

Este if o entry point le dice al main_py que si se ejecuta como script desde la terminal, lo hará con normalidad, pero si se ejecuta desde otro archivo como módulo, este no se ejecutará.

import utils

keys, values = utils.get_population()
print(keys, values)

data = [
  {
    'Country': 'Colombia',
    'Population':50
  },
 {
    'Country': 'Bolivia',
    'Population':30
  },
  {
    'Country': 'USA',
    'Population':300
  },

]

def run():

  country = input('Type Country => ')
  result = utils.population_by_country(data, country)
  print(result)

if __name__ == '__main__':
  run()

Me sale este error cuando ejecuto en la terminal y no sé como solucionarlo =S

/home/runner/Python102/venv/bin/python: line 3: exec: : not found

En caso de que el usuario ingrese el nombre del país en minúsculas, o en mayúsculas, etc.

<country = input("Type country ---> ")
country = country.capitalize()

result = utils.population_by_country(data, country)

print(result)> 

Ejecutar archivos .py tanto como modulos y como scripts

codigo del archivo main del primer ejemplo

import utils

def run():
    keys, values = utils.get_population()
    print (keys, values)

    country = input("Enter a country: ")

    result = utils.population_by_country(data, country)
    print(result)

data = [
    {
    'Country': 'Colombia',
    'Population': 300
    },
    {
    'Country': 'Mexico',
    'Population': 500
    },
    {
    'Country': 'Bolivia',
    'Population': 150
    }
]

Existen varios errores comunes que pueden ocurrir al trabajar con módulos y scripts en Python, algunos son:

1. Errores de importación: Esto ocurre cuando se intenta importar un módulo que no existe o que no está en la ruta de búsqueda de módulos de Python. También puede ocurrir si se utiliza un nombre de módulo incorrecto o si hay un error de sintaxis en el archivo de módulo.

2. Errores de nombre: Esto ocurre cuando se utiliza un nombre de variable, función o clase que no ha sido definido (no existe) o que no está disponible en el alcance actual. También puede ocurrir si se utiliza un nombre de módulo incorrecto o si hay un error de sintaxis en el archivo de script o módulo.

3. Errores de lógica: Esto ocurre cuando el código Python no funciona como se espera debido a un error en la lógica del programa. Estos errores pueden ser difíciles de encontrar y solucionar, y pueden requerir una revisión cuidadosa del código y una depuración paso a paso.

4. Errores de sintaxis: (lo mas comun del mundo) Esto ocurre cuando se escribe un código que no sigue la sintaxis correcta de Python. Estos errores pueden ser causados por errores de tipeo, falta de paréntesis o comillas, o por cualquier otro tipo de error de sintaxis.

• Errores de indentación: Esto ocurre cuando no se utilizan correctamente los espacios y las tabulaciones en el código Python. Python utiliza la indentación para indicar la estructura del código, por lo que un error de indentación puede causar errores de sintaxis o comportamiento inesperado en el código.

La clave esta en la ejecución

Un script en Python es simplemente un archivo que contiene código Python. Un script puede ser tan simple como una sola línea de código o tan complejo como un programa completo con varias funciones y módulos. Para ejecutar un script de Python, simplemente se debe ejecutar el intérprete de Python y pasar el nombre del archivo de script como argumento. Por ejemplo, si el archivo de script se llama “mi_script.py”, se puede ejecutar en la línea de comandos:

python mi_script.py
# (ejecuta el archivo directamente con el contenido que tenga, se simple como un print() o todo un algoritmo) 

Esto ejecutará el código en el archivo de script y mostrará cualquier salida que produzca.

En Python, un módulo es un archivo que contiene definiciones de variables, funciones y clases que se pueden utilizar en otros programas de Python. Los módulos se utilizan para organizar el código en pequeñas unidades lógicas y para evitar conflictos de nombres de variables y funciones. Para utilizar un módulo en un programa Python, primero debe importarse utilizando la instrucción import. Luego, se pueden utilizar las funciones y variables del módulo escribiendo el nombre del módulo seguido de un punto y el nombre de la función o variable. Por ejemplo:

import math
variable_1 = math.sqrt(25)

modules

main

# Importamos el modulo
import utils

data = [
  {
    "Country": "Colombia",
    "Population": 500
  },
  {
    "Country": "Bolivia",
    "Population": 400
  }
]

def run():
  keys, values = utils.get_population()
  print(keys, values)
  country = input("Type Country => ")
  result = utils.population_by_country(data, country)
  print(result)

# Módulos como scripts: __name__ y __main__
# Entry point
'''
Este if le dice al main.py, que si el archivo es ejecutado desde la terminal, ejecute el metodo run, pero si es ejecutado desde otro archivo, el metodo run no se ejecutaria.
'''

if __name__ == '__main__':
  run()

example

import main

print(main.data)
# main.run()

Definitivamente la mejor explicación de porqué y para qué se usa el entry point, el cual es el if que se configuró al final del archivo main,py

El código dentro de la sentencia “if name == ‘main’:” es una verificación que se realiza en Python para determinar si un archivo está siendo ejecutado directamente o si es importado como un módulo en otro script.

Si un archivo se ejecuta directamente, su nombre será igual a “main”, por lo que el código dentro de la sentencia “if name == ‘main’:” se ejecutará.

Si, por otro lado, un archivo es importado como un módulo en otro script, su nombre será el nombre del archivo en lugar de “main”, por lo que el código dentro de la sentencia “if name == ‘main’:” no se ejecutará.

main py

import utils
data=[
    {
        "country":"colombia",
        "poblacion":300
    },
    {
        "country":"peru",
        "poblacion":200
    }
]
def run():
    llaves,valores=utils.obtener_poblacion()
    print(llaves)
    print(valores)
    print(llaves,valores)

    letra=utils.A
    print(letra)

    data=[
        {
            "country":"colombia",
            "poblacion":300
        },
        {
            "country":"peru",
            "poblacion":200
        }
    ]
    pais=input("Ingrese el pais que desea buscar")
    datos_peru=utils.poblacion_por_pais(data,pais)
    print(datos_peru)

if __name__ == "__main__":
    run()
    
'''
Este if dice que si es ejecutado desde la terminal, 
entre al run y si es ejecutado 
desde otro archivo, no se ejecuta.
'''

example py

import main

#main.run() r
#Esto queda anulado con el if, no se podra correr desde otros
#modulos o archivos
#print("example",main.data)
#aparte de darme la data, se ejecuta todo el main 
print(main.data)

¡Excelente! Nunca había escuchado de esta posibilidad, que parece, sin embargo, tan necesaria.

En Python, se puede usar “main” para determinar si un script está siendo ejecutado directamente o si está siendo importado como un módulo en otro script. Esto se hace mediante el uso de la declaración if name == “main”: en el script principal. El código dentro de esta declaración sólo se ejecutará si el script se está ejecutando directamente, pero no si está siendo importado como un módulo en otro script.

Por ejemplo, si tenemos un script llamado “script1” que contiene el siguiente código:

def func1():
    print("This is function 1.")

if __name__ == "__main__":
    print("This is the main script.")
    func1()

Si ejecutamos el script directamente, veremos la salida: “This is the main script.” y “This is function 1.” pero si importamos este script en otro script y llamamos a la funcion func1() veremos solo “This is function 1.”

Es una buena práctica usar if name == “main”: en tus scripts para asegurarte de que el código sólo se ejecute cuando se desea ejecutar el script como un todo y no solo una parte del mismo.

¿Cómo hizo para cambiar app/example.py rapidamente a app/main.py?

import utils

data= [
    {
      'Country':'Colombia',
      'Population':500
    },
    {
      'Country':'Bolivia',
      'Population':300
    }
  ]

def run(): 
  keys,values = utils.get_population()
  print(keys, values)
    
  country = input('Type Country => ')
  
  result = utils.population_by_country(data,country)
  print(result)
# ejecuta desde la termina
if __name__ == '__main__':
  run()

import main

print(main.data)
main.run()
#print('example => ',main.data)

• En Python, el nombre especial main es utilizado para dos constructos importantes:

el nombre del entorno de máximo nivel del programa, que puede ser verificado usando la expresión __name__=='__main__'; y

el archivo __main__.py en paquetes de Python.

• Ambos de estos mecanismos están relacionados con módulos de Python; como los usuarios interactúan con ellos y como ellos interactúan entre sí. Están explicados en detalle más abajo. Si estás empezando con los módulos de Python, mira la sección tutorial Módulos para una introducción.

```
name == 'main’
Cuando un módulo o paquete de Python es importado, name es asignado al nombre del módulo. Normalmente, este es el nombre del archivo de Python sin la extensión .py:

En esta clase me quedo super claro esa linea de codigo que encontraba en muchos archivos de python. Ahora entiendo su funcionalidad!

Por fin entendí claramente el funcionamiento del Entry Point