Mis propios módulos

También podemos acceder a un método o función específica específico con:

from utils2 import population_by_country
from otherutils.utils3 import Person

Encantado con los módulos, gran paso a hacer POO.

Otro dato interesante es que pueden renombrar un módulo dentro del código para cuando lo usen usar una abreviación con as

import moduloconnombrelargo as m

m.función()  //Esto es igual a poner moduloconnombrelargo.función()

Módulos propios

Los módulos en python son cualquier archivo que termine en .py

# utils.py
def get_population():
	keys = ['col','bol']
	values = [300,400]
	return keys,values

def population_by_country(data, country):
	result = list(filter(lambda item: item['Country'] == country,data))
	return result

# main.py
import utils

keys,values = utils.get_population()
print(keys,values) # ['col','bol'] [300,400]

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

country = input('Type Country => ')

result = utils.population_by_country(data, country)
print(result)  # [{'Country': 'Colombia','Population': 500}]

print(utils.A)

Como Construir Módulos.

Para construir módulos debemos tener en cuenta que se deben crear en la misma carpeta a lo cual utilizaremos import para ser llamada en el archivo a trabajar:

Tenemos un módulo que tiene los datos de la población de 3 paises de Sur America, los cualse vamos a crear en la carpeta app y daremos por nombre utils.py

def get_population():
  keys = ['Colombia', 'Peru', 'Argentina']
  values = [500, 250, 350]
  return keys, values

def population_by_countrie(data, country): 
  result = list(filter(lambda item: item['country'] == country, data))
  return result

Ahora creamos el archivo con nombre main.py, este archivo vamos a digitar los datos a buscar.

import utils

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

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

Ahora invocamos el módulo a utilizar y sus valores según lo que contiene
country = input('Digite el país: ')
result = utils.population_by_countrie(data, country)
print(result)

Producción:

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

Digite el país: Colombia
[{'country': 'Colombia', 'Population': 500}]

Digite el país: Argentina
[{'country': 'Argentina', 'Population': 350}]

para evitar errores de inputs por el usuario, si ponen los países con la primer letra mayúscula, usen capitalize, acá les va mi ejemplo:

country = input('Type country: ')
country = country.capitalize()
result = utils.population_by_country(data, country)
print(result)

Esta clase fue MAGNIFICA.
“Me atrapaste, esto si es cine”

Yo ya había implementado esto para empezar a crearme una suerte de “hoja maestra” para data science, en donde metia en mi archivo .py las funciones mas utilizadas, y la voy a ir actualizando, es una buena practica y aca les dejo como viene hasta ahora la hoja, al importar este archivo ya no tendran un sinfin de imports en el principio del notebook

import inspect
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report


def split_data(x, y, test_size, random_state=22):
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=test_size, random_state=random_state)
    return x_train, x_test, y_train, y_test


def train_predict(model, x_train, y_train, x_test, y_test):
    model.fit(x_train, y_train)
    y_pred = model.predict(x_test)
    accuracy = accuracy_score(y_test, y_pred)
    print(f'Accuracy; {accuracy}')
    return y_pred, accuracy


def get_accuracy(y_test, y_pred):
    accuracy = accuracy_score(y_test, y_pred)
    return accuracy


def plot_confusion_matrix(y_test, y_pred, classes):
    cm = confusion_matrix(y_test, y_pred)
    fig, ax = plt.subplots()
    cax = ax.matshow(cm, cmap='Blues')
    plt.title('Confusion Matrix')
    fig.colorbar(cax)
    ax.set_xticklabels([''] + classes)
    ax.set_yticklabels([''] + classes)
    plt.xlabel('Predicted')
    plt.ylabel('True')
    plt.show()


def print_results(y_test, y_pred):
    print(classification_report(y_test, y_pred))

La verdad muy buena forma de introducir el tema de POO sin hablar de POO jajaja muy sutil ❤️

Para importar de otra carpeta:

1. import sys
2. sys.path.insert(0, ‘/the/folder/path/name-package/’)
   Poner ruta de modulo .py
3. from name-package import name-module

Esta clase está presentando fallas, se pausa demasiado y en la app ni siquiera carga.

¡IMPORTANTE!!
RECARGA DE MÓDULO

Esto me paso mientras practicaba esta clase, espero les sea de ayuda:

¿Qué pasa si después de importar un módulo, realizo un cambio en éste?

El problema que estás experimentando, donde los cambios realizados en el módulo utils.py no se reconocen después de su importación en main.py, se debe a cómo Python administra los módulos importados.

• Cuando importas un módulo en Python, el módulo se carga y se ejecuta una vez, y luego se almacena en la memoria. Los objetos definidos en ese módulo, como variables, funciones y clases, se almacenan en la memoria en ese estado específico.

• Si realizas cambios en el módulo utils.py después de importarlo en main.py, esos cambios no se reflejarán automáticamente en el módulo importado. Python utiliza una especie de caché para mejorar el rendimiento y la eficiencia de la importación de módulos.

Para que los cambios en utils.py se reflejen en main.py, debes recargar el módulo importado.

• Puedes hacerlo utilizando la función reload del módulo importlib, que es parte de la biblioteca estándar de Python. Aquí hay un ejemplo de cómo hacerlo:

import importlib

# Importa el módulo utils
import utils

# Realiza cambios en el módulo utils.py

# Recarga el módulo importado para reflejar los cambios
importlib.reload(utils)

# Ahora los cambios en utils.py deberían estar disponibles

Ten en cuenta que recargar módulos de esta manera puede ser útil durante el desarrollo, pero es importante tener cuidado al usarlo en producción, ya que puede tener efectos inesperados en la consistencia del estado de tu programa.

• ¿Qué pasa si vuelvo hacer modificaciones en el módulo importado?

La función importlib.reload recargará el módulo una vez, pero no estará “vigilando” continuamente los cambios en el módulo utils.py. Por lo tanto, si realizas un nuevo cambio en utils.py después de haber utilizado importlib.reload, ese cambio no se reflejará automáticamente en el módulo importado en main.py.

• Si deseas que los cambios se reflejen cada vez que modificas utils.py, tendrás que volver a ejecutar importlib.reload(utils) en main.py después de cada cambio en utils.py. Esto significa que tendrás que ejecutar manualmente la recarga cada vez que realices una modificación.

En resumen, la recarga con importlib.reload es una operación que debes realizar manualmente cada vez que quieras que los cambios en utils.py se reflejen en main.py. No es una recarga automática que se produzca cada vez que se realiza un cambio en utils.py.

¿En qué momento y dónde realizo la importación de importlib?

Puedes realizar la importación y la recarga del módulo en la parte donde vas a utilizar los cambios realizados en utils.py. Esto es una práctica común durante el desarrollo, ya que te permite controlar cuándo y dónde se reflejan los cambios en el módulo.

Por ejemplo, puedes hacer lo siguiente en main.py:

# Importa el módulo utils
import utils

# Realiza cambios en el módulo utils.py

# En el punto donde necesitas los cambios, realiza la recarga del módulo
import importlib
importlib.reload(utils)

# Ahora los cambios en utils.py deberían estar disponibles en este punto

De esta manera, puedes importar y recargar el módulo utils en el lugar exacto donde necesitas los cambios, lo que te brinda un mayor control sobre cuándo se aplican los cambios en tu programa.

Recuerda que, para que los cambios sean visibles, debes realizar la recarga del módulo en cada parte de tu código donde lo hayas importado y deseas utilizar los cambios.

OTRAS FORMAS (REINICIAR EL IDE)

Sí, otra forma de asegurarte de que los cambios en un módulo sean reflejados es reiniciar el IDE (entorno de desarrollo integrado) en el que estás trabajando. Al reiniciar el IDE, se volverán a cargar todos los módulos y archivos, lo que incluirá cualquier cambio realizado en utils.py.

Sin embargo, reiniciar el IDE puede ser un proceso más drástico que la recarga manual de un módulo utilizando importlib.reload. Al reiniciar, también perderás cualquier estado de ejecución actual y tendrás que volver a abrir los archivos y volver a ejecutar el código que estabas probando. Por lo tanto, si solo necesitas actualizar un módulo específico y no quieres afectar todo el estado de tu IDE, la recarga manual del módulo es una opción más controlada y eficiente.

Una de las Mejores clases… Que gran utilidad son los modulos!

recuerda que modular tu programa siempre es una buena idea, porque pueden haber errores ( nunca faltaran) y es bueno que tengas separado el codigo para atacar directamente el problema y no revisar el codigo durante horas para encontrar un error.😊

Al momento de crear nuestros métodos es buena practica asignarles un Doctring informando la funcionalidad, tipos de datos que recibe y los valores que retorna:

def population_by_country(data, country):
    """Function to look up country in a list of dictionaries

    Args:
        data (lis): list of dictionaries
        country (string): matching country

    Returns:
        Dict: Country
    """
    result = list(filter(lambda item: item["Country"] == country, data))
    return result

En Visual Studio Code la extensión Python docstring generator, permite generar el docstring de forma automatica

Link: https://github.com/NilsJPWerner/autoDocstring

Para conocer el docstring de un metodo desde el archivo main podemos utilizar la función help():

print(help(utils.population_by_country))

Hola, para los que estamos trabajando con Google Colab y queramos hacerlo parecido acá dejo un enlace a un video que hice para compartir los modulos entre los libros de Google Colab:
Enlace al video https://www.youtube.com/watch?v=jzOx_1XH9uw
👍

Hola, deseando que te encuentres bien. si eres curioso dos cosas durante el min 5:00 en adelante.

1. no usamos la palabra from para importar un modulo sino que directamente usamos import, y esto porque?.
   la razon es porque vamos a importar elementos especificos de un directorio.
   recuerda que los modulos siempre van a estar dentro de una carpeta(repositorio) que es necesario acceder para poder hacer uso de sus componentes.
   entonces from es solo una clausula de especificacion a el uso de un modulo.
2. Todo lo que escribas en python es un objeto, esto que significa?
   si tu tienes un objeto que puedes hacer con el?
   manipularlo, dañarlo, tirarlo, obviarlo, pero el hecho es que tu sabes que existe y que puedes hacer uso del mismo.
   y la pregunta que debes hacerte, que no es un objeto?
   la respuesta es: cualquier cosa que tu no puedas manipular por ejemplo, una concepto, algo abstracto.
   entonces, en PYTHON tu puedes manipular desde el dato mas basico hasta el dato mas complejo, como tambien las funciones.

Tal vez alguien más se preguntó :

¿cuál es la diferencia al usar import module vs from module import function?

la respuesta está en la memoria que utiliza, es más eficiente hacer el llamado con from module que llamando completamente todo el module, puesto que este segundo requiere mayor esfuerzo al llamado.

Si quedaste con muchas dudas sobre esta clase, te comparto una que te puede ayudar a entender los conceptos basicos de la programacion orientada a objetos:
https://platzi.com/cursos/poo-python/

Modulos en python

• Son archivos que contienen código Python que se puede reutilizar en otros programas.
• Estos archivos suelen contener funciones, clases y variables que se pueden importar a otros programas para utilizarlas en ellos.
• La ventaja de utilizar módulos es que permite separar el código en partes más pequeñas y organizadas, lo que facilita la lectura y mantenimiento del código.
• Los módulos pueden ser compartidos y utilizados por otros programadores, lo que puede ahorrar tiempo y esfuerzo en la programación.
• Entonces, los módulos en Python son archivos que contienen código que se puede importar y utilizar en otros programas para ahorrar tiempo y mantener un código organizado.

Me acuerdo que en el anterior curso de Python que dió Facundo, comenzó de lleno con el modulo main desde la primera clase, pero no explicaba a fondo qué era . Me gusta más la forma de enseñar de Nicolas por qué siento que explicó paso a paso hasta llegar a los módulos y explicar de dónde salen y como podemos hacerlos. Genial. 💚

Hice algo interesante!, utilicé

country = input('Put a Country -> ').capitalize()

para que me acepte palabras ya sean mayúsculas o minusculas

Una Buena Practica que muy probablemente veremos mas adelante sera definir el nombre de las funciones con set y get.

Ejemplo
def set_population():
keys = [“col”,“ven”]
values = [“10”,“20”]
def get_population():
return keys, values

Así entonces es como se van creando las apis?

18/11/2023

“ðə ˈmiːdiə kəd nɒt bi ˈləʊdɪd, ˈaɪðə bɪˈkəz ðə ˈsɜːvər ɔː ˈnɛtwɜːk feɪld ɔː bɪˈkəz ðə ˈfɔːmæt s nɒt səˈpɔːtɪd.”

MÓDULOS en PYTHON en 9 minutos: import, from, as, namespace, math, random y más

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

Adore la parte de crear mis propios modulos y como importarlos de otro archivo al nuestro. Esto es muy util en la carrera como programador.

✅

Crear tus propios módulos en Python es una práctica común cuando deseas organizar y reutilizar tu propio código en diferentes proyectos o partes de un proyecto más grande. Aquí tienes los pasos para crear y utilizar tus propios módulos:

1. Crea un Archivo Python: Comienza creando un archivo Python (con extensión .py) que contendrá las funciones, clases o variables que deseas reutilizar. Por ejemplo, crea un archivo llamado mi_modulo.py.

2. Define Funciones o Variables: Dentro de tu archivo mi_modulo.py, define las funciones, clases o variables que deseas incluir en tu módulo. Por ejemplo:

   # mi_modulo.py
   
   def saludar(nombre):
       return f"Hola, {nombre}!"
   
   def calcular_cuadrado(numero):
       return numero ** 2
   
   mi_variable = 42
   
   

3. Guarda el Archivo: Asegúrate de guardar el archivo después de definir tus funciones y variables.

4. Usa tu Módulo: Ahora puedes importar y usar tu módulo en otros programas Python. Para hacerlo, simplemente utiliza la palabra clave import seguida del nombre del archivo sin la extensión .py. Por ejemplo:

   import mi_modulo
   
   print(mi_modulo.saludar("Juan"))  # Output: Hola, Juan!
   print(mi_modulo.calcular_cuadrado(5))  # Output: 25
   print(mi_modulo.mi_variable)  # Output: 42
   
   

   Si necesitas usar solo una parte específica de tu módulo, puedes importar solo eso:

   from mi_modulo import calcular_cuadrado
   
   print(calcular_cuadrado(7))  # Output: 49
   
   

5. Alias de Módulo: También puedes asignar un alias al módulo para facilitar su uso:

   import mi_modulo as mm
   
   print(mm.saludar("María"))  # Output: Hola, María!
   
   

6. Ubicación del Módulo: Asegúrate de que el archivo mi_modulo.py esté en una ubicación accesible desde el programa que lo importa. Puedes colocar el módulo en el mismo directorio que el programa que lo utiliza o en un directorio incluido en la ruta de búsqueda de Python.

Creando y utilizando tus propios módulos, puedes organizar tu código de manera más efectiva, promover la reutilización y facilitar el mantenimiento de tus proyectos.

Les paso el pequeño modulo que hice.
Ayuda a evaluar una palabra o Frase y hace una diccionarion con la version original, Mayusculas, Minusculas y como Nombre Propio
Algo sensilo pero es trrabajo honesto. Ja, ja.
👇👇👇👇👇👇

main. py 👇

import all_variations

word = input('¿Que palabra o Frase quieres validar? ')
print(all_variations.all_variations(word))

all_variations.py 👇

def all_variations(word):
  variations = {
    'Original': word
  }
  variations['Mayusculas'] = word.upper()
  variations['Minusculas'] = word.lower()
  variations['Nom Prop'] = word.title()
  return variations

Y este fue el Output. Pero varia dependiendo del INPUT que indiques.

{
  'Original': 'Hello World', 
  'Mayusculas': 'HELLO WORLD', 
  'Minusculas': 'hello world', 
  'Nom Prop': 'Hello World'
} 

Muy interesante esto de los módulos, me costó entender.
Lo que me pregunto cómo se procede cuando tenemos gran cantidad de datos en diferentes formatos para que Python logre filtrarlos?

Comparto el mismo ejercicio pero con la variante de hacer la búsqueda basada en la población. Si la población no existe nos devuelve un mensaje.

Archivo Utils:

def consultar_poblacion (lista,filtro):
result = list(filter(lambda item : item[‘poblacion’] == filtro, lista))
return result

Archivo Main:

import utlis

lista = [
{
‘país’: ‘Panamá’,
‘población’: 300
},
{
‘pais’: ‘Mexico’,
‘poblacion’: 1000
}
]

poblacion = int(input('Introduce la poblacion -> '))

resultado = utlis.consultar_poblacion(lista,poblacion)

if len(resultado) > 0:
print(resultado)
else:
print (‘No existe país con esa población’)

asi no importa si typeas con minuscula al principio

country = input('type country => ')
country = country.capitalize()

Excelente clase me gusta cómo se empieza a ver más limpio el código.

Para reportar que el vídeo numero 27 donde se habla de “Mis propios módulos” no carga desde ningún navegador ni dispositivo. Intenté desde mi celular y computadora y todos los vídeos cargan menos ese.

# Cualquier archivo .py puede ser un modulo
# Nombrar con nombres dicientes los modulos o cualquier cosa
# Normalmente los archivos con utilidades tienen solo funciones

import utils

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

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

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

El main de la clase:

import utils

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


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

country = input("Enter a country: ")

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

El utils de la clase:

def get_population():
    keys = ['col', 'bol']
    values = [300, 400]
    return keys, values

def population_by_country(data, country):
    result = list(filter(lambda item: item['Country'] == country, data))
    return result

Utils File

import utils

data = [
    {
    "Country": "Chile",
    "Population": 17
    },
    {
    "Country": "Mexico",
    "Population": 35
    },
    {
    "Country": "Brazil",
    "Population": 45
    }
]

country = input("Type country: ")

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

user_result = f'Population of {country} is: ' + str(result[0]["Population"])
print(type(user_result))
print(user_result)

Main File

def population_by_country(data, country):
    result = list(filter(lambda item: item["Country"] == country, data))
    return result

Ejemplos, importar el módulo math y usar la función sum de la siguiente manera en el archivo main .py

import math

result = math.sum(3, 4)
print(result)

En este caso, math es el nombre del módulo, sum es el nombre de la función dentro del módulo y result es la variable que almacena el resultado de la llamada a la función. (estab dentro de la misma carpeta)

En los archivos de recurso: el “utils” es distinto al que se hizo en esta clase.

Cualquier archivo en python ya se considera un módulo

utils

# Mis propios módulos
'''
Los modulos en Python son cualquier archivo con extension .py
Dentro de un modulo nosotros podemos definir Funciones, Clases o Variables
'''

def get_population():
  keys = ["col", "bol"]
  values = [300, 400]
  return keys, values

def population_by_country(data, country):
  result = list(filter(lambda item: item["Country"] == country, data))
  return result

main

# Importamos el modulo
import utils

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

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

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

Mod, donde tengo una función que devuelve una lista con la población de los países y otra que devuelve la información de un país en especifico que le pasemos como parámetro.

def getPopulation( data):
    population = [i["Population"] for i in data]
    return population    

def request_country_info(data, country):
    result = list(filter(lambda x: x['Name'] == country, data))
    
    for key, value in result[0].items():
        print(f"{key}: {value}")
        
    return result

En el main importamos el modulo y creamos una lista con la data que necesitamos para que mod funcione.

import mod

countries = [ 
    {"Name": "United States", "Population": 328, "Capital": "Washington, D.C."},    
    {"Name": "Canada", "Population": 38, "Capital": "Ottawa"},    
    {"Name": "United Kingdom", "Population": 67, "Capital": "London"},    
    {"Name": "France", "Population": 67, "Capital": "Paris"},    
    {"Name": "Germany", "Population": 83, "Capital": "Berlin"},
    {"Name": "Italy", "Population": 60, "Capital": "Rome"}
]
        

def main():
    print(mod.getPopulation(countries)) 
    
    pais = str(input("Ingresa un pais: "))
    mod.request_country_info(countries, pais)
    
if __name__ == "__main__":
    main()

voy por aqui

Muy buena clase!

cool no hay que ponerle export como en js

Volviendo desde la clase 40 para repasar estos conceptos y afrontar bien los retos.

Presten atencion! super importante esto!

main py

import utils

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)

utils py

def obtener_poblacion():
    llaves=["col","bol"]
    valores=[300,400]
    return llaves,valores

A="Hola"

def poblacion_por_pais(data,pais):
    result=list(filter(lambda x:x["country"]==pais,data))
    return result
    

Yo la lista ‘data’ la hice con información diferente. En el input mandaba a pedir la estatura. La lista me aparecía vacía hasta que recordé entonces que el input te entrega un string, por lo que antes debía ponerle ‘float’

• Para trabajar con tus propios módulos en Python, primero debes crear un archivo de Python que contenga el código que quieres reutilizar. Luego, puedes importar este archivo como cualquier otro módulo.

• Por ejemplo, supongamos que tienes un archivo llamado mis_funciones.py que contiene algunas funciones útiles que quieres reutilizar en varios programas. El archivo mis_funciones.py podría tener este aspecto:

def saludar(nombre):
    print(f"Hola, {nombre}")

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

• Para usar este módulo en otro programa, primero debes importarlo. Puedes hacerlo con la declaración import:

import mis_funciones

mis_funciones.saludar("Juan")
resultado = mis_funciones.sumar(1, 2)
print(resultado)

• También puedes importar solo algunas de las funciones de tu módulo usando la declaración from y import. Por ejemplo:

from mis_funciones import saludar

saludar("Juan")

Nuestro Propios Modulos

En una misma carpeta creamos dos archivos: main que es el archivo principal y utils que contendra todas las funciones que vamos a utilizar ambos arhcivos con extension py. Ahora desde main podemos utilizar todas las funciones del archivo utils al importarlo como un modulo.
Archivo utils

#-------- modulo ---------

#funcion para obtener la poblacion de un pais
def get_population():
  keys = ['colombia', 'bolivia', 'mexico', 'nicaragua']
  values = [30, 18, 100, 7]
  return keys, values

# Variable
A = 'hola'

# obtener la poblacion basados en un pais
def population_by_country(data, country):
  result = list(filter(lambda item: item['Country'] == country, data))
  return result

Archivo main

# llamar al modulo utils
import utils

# utilizar la funcion get_population
Pais, Poblacion = utils.get_population()
print(Pais, Poblacion)
--> ['colombia', 'bolivia', 'mexico', 'nicaragua'] 
		[30, 18, 100, 7]

# utilizar la variable A
print(utils.A)
--> hola

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

# obtener la poblacion de un pais especifico
poblacion = utils.population_by_country(data, 'mexico')
print(poblacion)
--> [{'Country': 'mexico', 'Population': 100}]

# 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)
--> Digite el pais: nicaragua
		[{'Country': 'nicaragua', 'Population': 7}]

• Por fin entiendo el concepto de módulos, se me hizo larga la clase pero lo entendí muy bien

Genial entonces ahora las funciones van separadas!