Reto: graficando la población de un país

Hola compañeros, para aquellos que les aparezca el siguiente error:

KeyError: ‘Country’

En mi caso lo solucione cambiando la palabra ‘Country’ por la palabra ‘Country/Territory’ en la función population_by_country del modulo de utils,py:

def population_by_country(data, country):
result = list(filter(lambda item: item[‘Country/Territory’] == country, data))

Esto porque en el archivo data.csv que descargue, el nombre de la columna Country no aparece como Country, sino como, Country/Territory.

Espero les sirva
![](

Como aporte sugiero no esperar hasta el final del curso para plantear retos asi, seria bueno insertarlos antes asi el mismo es mas interactivo.

Es sorprendente el poder que tienen pandas con matplotlib y si a eso le sumamos seaborn pues:

Salen graficos hermosos y en pocas líneas de código

Gente hoy estuve haciendo la gráfica me costó tuve que buscar info en mil sitios y hasta puse a prueba mis reading jaja, Aquí les dejo mi código y una mini guía para estilizar la gráfica espero que les sirva:

• La gráfica:

• Info:

• Descripción del código:

• Código:

import matplotlib.pyplot as plt

def generate_bar_chart(labels, values, país):
  plt.rcParams['font.sans-serif'] = ['Lato']
  plt.rcParams['font.weight'] = "medium"
  fig, ax = plt.subplots()
  ax.bar(labels, values, width=0.6, color='#86bf91')
  ax.spines['right'].set_visible(False)
  ax.spines['top'].set_visible(False)
  ax.spines['left'].set_visible(False)
  ax.spines['bottom'].set_visible(False)
  plt.tick_params(left = False, bottom = False)
  ax.tick_params(axis='both')
  plt.xticks(fontsize='8.5', weight='bold', color='#7e807e')
  plt.yticks(fontsize='8.5', weight='bold', color='#7e807e')
  ax.set_xlabel("Años de censo", labelpad=18, size=10, fontfamily="sans", weight="bold")
  ax.xaxis.set_label_coords(x=-0.004, y=-0.087, transform=ax.transAxes)
  ax.set_ylabel("Población (Millones)", labelpad=18, size=10, fontfamily="sans", weight="bold")
  ax.yaxis.set_label_coords(x=-0.09, y=0.81, transform=ax.transAxes)
  plt.suptitle("Desde el año 1970 al año 2022", size=10, fontfamily="sans", color="#5f615f", weight="bold",
            horizontalalignment = 'left',
             x=0.038,
             y=0.94,
             transform=fig.transFigure)
  plt.title("Población de " + país, size=17, weight='bold', fontfamily="serif", color='#598561',
            horizontalalignment = 'left',
             x=0.038,
             y=0.96,
             transform=fig.transFigure)
  vals = ax.get_yticks()
  for tick in vals:
      ax.axhline(y=tick, linestyle='dashed', alpha=0.4, color='#c3c9c5', zorder=1)
  plt.show() 

Yo lo hice de esta manera:

from csv import reader
import matplotlib.pyplot as plt

with open('data.csv','r') as data:
    reader1 = reader(data)
    header = next(reader1)
    data1=[]
    for line in reader1:
        codict=dict()
        for i,j in zip(header,line):
            if 'Country' in i or 'Population' in i :
                codict[i]=j
        data1.append(codict)

def graficar(data,name):
    result= list(filter(lambda item:item['Country']==name,data))[0]
    labels=list(result.keys())[1:-1]
    values=list(map(int,list(result.values())[1:-1]))
    fig, ax = plt.subplots()
    ax.bar(labels, values)
    plt.show()

graficar(data1,'Bolivia')

Así lo hice you

import App


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


def delete_columns(country_data):
  new_country_data = dict(
    filter(
      lambda item: 'Population' in item[0] and 'Percentage' not in item[0],
      country_data[0].items()))
  return new_country_data


def format_key(data):
  new_data = data.copy()
  new_data = {k[0:4]: v for k, v in new_data.items()}
  return new_data


def run(data):
  #country = input("Escriba el paìs: ")
  country = "Colombia"
  country_data = filter_by_country(data, country)
  population_data = delete_columns(country_data)
  population_data = format_key(population_data)


if __name__ == '__main__':
  run(App.data)

me paso que tube muchos errores a la hora de escribir los modulos y se me fue mucho tiempo encontrando los errores pero cuando le coji en tiro como que ya estaba mas facil.

animo compañeros la mayoria de errores son de escritura y asignacion de valores. con el debugger los encuantran mas facil

me da gracia que se nos pide que del csv leamos solo los año y al momento de el hacerlo los crea a mano 😂

Mi solución es similar a la presentada en el curso, sin embargo, comparto mi código para extraer automáticamente las columnas de población de los países, registrando los años y valores correspondientes en un nuevo diccionario, en lugar de hacerlo de forma manual como sucedió en el ejemplo:

Esta bien saber esto pero hoy en dia con pandas y jupyter esto es innnecesario

esta muy mal planteado este reto, es como las evaluaciones en las que practicas un tema y resulta otro totalmente diferente jajajajaja

Yo busqué las coincidencias en los campos y lo usé para filtrar los valores

def filter_list(data):
    new_dict = {}
    country = input('Seleccione un país: ' ).capitalize()
    #Obtengo la lista del pais
    list = [x for x in data if x['Country/Territory'] == country]
    #Al ser una lista de diccionarios tomo su primer y unico valor 
    for key, value in list[0].items():
        #Busco si la llave termina en 'ation' de 'Population'
        if key[-5:] == 'ation':
            #De ser así tomo los primeros 4 digitos como clave con su respectivo valor
            new_dict[key[0:4]] = value
            
    return new_dict


if __name__ == '__main__':
    data = read('./data.csv')    
    dict = filter_list(data)
    print (dict)

Entiendo que la clase no trata sobre la librería de pandas, pero si alguno tiene inquietud de como se soluciona el reto de las columnas con utilizando esta librería, queda de la siguiente manera:

import pandas as pd
import matplotlib.pyplot as plt

#Extraigo los datos y los guardo en la variable df
df = pd.read_csv('./Modulos/data.csv')
df.head()

#cambio los nombres de las columnas  muy parecido a como lo resuelve el profesor 
df = df.rename(columns={
    df.columns[5]: '2022', 
    df.columns[6]:'2020',
    df.columns[7]:'2015',
    df.columns[8]:'2010',
    df.columns[9]:'2000',
    df.columns[10]:'1990',
    df.columns[11]:'1980',
    df.columns[12]:'1970'
    })
df.head()

Hola, dejo mi aporte con la descripción del reto. En el caso de que les pasa lo que a mi me pasa, que empiezo a desarrollar y tengo que constantemente revisar el reto para ver si estoy en la dirección correcta

Reto:
De todo el csv de paises y poblaciones, seleccionar un pais, y de ese pais solamente mostrar las columnas o campos relacionados con poblacion/population y descartar las demás.
Nuestro objetivo es ver una gráfica del crecimiento poblacional de ese pais, asi que queremos tener los valores enlistados como año:población

hola, hice 3 funciones,

1. una para leer la fila del pais,
2. otra para crear el diccionario que tenga en las keys los años y en los valores el numero que este en el csv
3. para graficar un bar chart.

Y al final use el output de la 1 en la 2 y el output de la 2 en la 3.

Saludos!

import csv
import re
import matplotlib.pyplot as plt


def read_country(path,country):
 with open(path,'r') as file:
  csv_file = csv.reader(file,delimiter=',')
  header = next(csv_file)
  for row in csv_file:
    if row[2] == country:
      new_row = zip(header,row)
      new_dictionary = {key:value for key, value in new_row}
 return header,new_dictionary

def dictionary_population(path,country):
 header, data = read_country(path,country)  
 new_dictionary = {}  
 for i in range(len(header)):
  matches = re.findall(r'\d{4,4}',header[i])
  if matches != []:
    new_dictionary = new_dictionary|{matches[0]:int(value) for key,value in data.items() if matches[0] in key}
 return new_dictionary

def generate_bar_chart(labels,values):
  fig, ax = plt.subplots()
  ax.bar(labels,values)
  plt.show()

if __name__ == '__main__':
 path = './app/data.csv'
 country = input('Escriba el nombre de un pais: ')
 country_dict = dictionary_population(path, country)
 generate_bar_chart(country_dict.keys(),country_dict.values())

Hola!

Les comparto el código del proyecto:

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(country_dict):
  population_dict = {
    "2022": int(country_dict["2022 Population"]),
    "2020": int(country_dict["2020 Population"]),
    "2015": int(country_dict["2015 Population"]),
    "2010": int(country_dict["2010 Population"]),
    "2000": int(country_dict["2000 Population"]),
    "1990": int(country_dict["1990 Population"]),
    "1980": int(country_dict["1980 Population"]),
    "1970": int(country_dict["1970 Population"]),
  }
  
  labels = population_dict.keys()
  values = population_dict.values()
  return labels, values

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

main

# Importamos el modulo
import utils
import read_csv
import charts

def run():
  data = read_csv.read_csv('./app/world_population.csv')
  country = input("Type Country => ")
  
  result = utils.population_by_country(data, country)

  if len(result) > 0:
    country = result[0]
    labels, values = utils.get_population(country)
    charts.generate_bar_chart(labels, values)
  
  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()

Como lo hice espero sea de su comprensión, cree una lista donde quiero los elementos que deseo ver en data

import csv
import matplotlib.pyplot as plt
def read_csv(path):
    with open(path, 'r+') as csvfile:
        reader =  csv.reader(csvfile, delimiter=',')
       #obtiene la primera fila
        header = next(reader)
        data = []
        #Lista con elemento creados
        poblacion=['2022 Population', '2020 Population', '2015 Population', '2010 Population', '2000 Population', '1990 Population', '1980 Population', '1970 Population']

        for row in reader:
            iterable =zip(header, row)#Se tienen  un array de tuplas
            country_dict ={ key: value for key, value in iterable if key in poblacion}
            data.append(country_dict)
            
        return data
def barra(labels, values):
    fig, ax = plt.subplots()
    ax.bar(labels, values)
    plt.show()

if __name__ == '__main__':
    data= read_csv('./Comprehensions, Funciones y Manejo de Errores/APP/data.csv')
    labels= data[0].keys()
    values= data[0].values()
    barra(labels, values)

![](

Les dejo mi solución:

import app.read_csv as csvhelper
import matplotlib.pyplot as plt
import re

def convert_country_to_years_dict(country: dict):
    country_copy = country.copy()

    for key in country:
        regex = "[0-9]{4} Population"

        if re.match(regex, key) != None:
            year = key.split(" ")[0]
            country_copy[year] = country[key]
                         
        del country_copy[key]

    return country_copy

def generate_population_country_chart(country_name: str):
    path = "/Users/luism.DESKTOP-QIO804S/OneDrive/Escritorio/python/platzi-curso-2-backend/app/data.csv"
    countries = csvhelper.read_csv(path)

    country_name = country_name.lower()
    try:
        country = next( country for country in countries if country["Country/Territory"].lower() == country_name )
    except Exception as error:
        exit()
    
    years_dict = convert_country_to_years_dict(country)
    sorted_years_dict = { k: years_dict[k] for k in sorted(years_dict) }
    labels, values = list(sorted_years_dict.keys()), list(sorted_years_dict.values())


    flig, ax = plt.subplots()
    ax.bar(labels, values)
    plt.show()



generate_population_country_chart("El Salvador")

Hola gente, les quería compartir mi resolución del reto, yo hice que el código le pregunte al usuario:

¿deseas saber la población de un país? 
País => "Aquí el usuario ingresa el país que  quiera"

.

el código busca de entre todos los países el que ingresó el usuario y muestra la gráfica para dicho país

.
Aquí les dejo el código por si a alguien le interesa y en los comentarios voy a explicar el módulo de la gráfica parte por parte por si alguien necesita info para estilizar su gráfica:
.

• Módulo principal:
  .

import finder
import chart
import ordenador

if __name__ == '__main__':
  country = input('¿deseas saber la poclación de ún país? \nPaís => ')
  data = finder.read_csv('./data.csv', country)
  years = sorted(data.keys())
  population = ordenador.ordener(data.values())
  chart.generate_bar_chart(years, population, country)

.

• Módulo que transforma el excel a diccionarios y guarda el diccionario del país que pidió el usuario:
  .

import csv

def read_csv(path, my_country):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    header = next(reader)
    data = []
    for row in reader:
      iterable = zip(header, row)
      country_dict = {key[0:4]: value for key, value in iterable if key[0]=='1' or key[0]=='2' or key[0:3]=='Cou'}
      if country_dict['Coun']==my_country:
        del country_dict['Coun']
        data = country_dict
    
    return data 

.

• Módulo que ordena el diccionario de 1970 a 2022 (es que el otro módulo retorna el diccionario de 2022 a 1970) y abrevia las poblaciones (que están en millones):
  .

def ordener(temp_population):
  population = [0, 1, 2, 3, 4, 5, 6, 7]
  y = 0
  for i in temp_population:
    x = 7 - y
    i = float(i)
    i = str(i * 0.000001)
    population[x] = i[0:5] + ' M'
    y = y + 1
  return(population)

.

• Y el Módulo que más me costó de todos, el que crea la gráfica, se me hizo muy dificil encontrar info para estilizar la gráfica y aparte es poco intuitivo, pero finalmente lo logré, código:
  .

import matplotlib.pyplot as plt

def generate_bar_chart(labels, values, país):
  plt.rcParams['font.sans-serif'] = ['Lato']
  plt.rcParams['font.weight'] = "medium"
  fig, ax = plt.subplots()
  ax.bar(labels, values, width=0.6, color='#86bf91')
  ax.spines['right'].set_visible(False)
  ax.spines['top'].set_visible(False)
  ax.spines['left'].set_visible(False)
  ax.spines['bottom'].set_visible(False)
  plt.tick_params(left = False, bottom = False)
  ax.tick_params(axis='both')
  plt.xticks(fontsize='8.5', weight='bold', color='#7e807e')
  plt.yticks(fontsize='8.5', weight='bold', color='#7e807e')
  ax.set_xlabel("Años de censo", labelpad=18, size=10, fontfamily="sans", weight="bold")
  ax.xaxis.set_label_coords(x=-0.004, y=-0.087, transform=ax.transAxes)
  ax.set_ylabel("Población (Millones)", labelpad=18, size=10, fontfamily="sans", weight="bold")
  ax.yaxis.set_label_coords(x=-0.09, y=0.81, transform=ax.transAxes)
  plt.suptitle("Desde el año 1970 al año 2022", size=10, fontfamily="sans", color="#5f615f", weight="bold",
            horizontalalignment = 'left',
             x=0.038,
             y=0.94,
             transform=fig.transFigure)
  plt.title("Población de " + país, size=17, weight='bold', fontfamily="serif", color='#598561',
            horizontalalignment = 'left',
             x=0.038,
             y=0.96,
             transform=fig.transFigure)
  vals = ax.get_yticks()
  for tick in vals:
      ax.axhline(y=tick, linestyle='dashed', alpha=0.4, color='#c3c9c5', zorder=1)
  plt.show()

import csv
def read_csv(path):
    with open(path,'r') as csvfile:
        reader=csv.reader(csvfile,delimiter=',')
        header=next(reader)
        data=[]
        for row in reader:
            iterable=zip(header,row)

            country_dict={key:value for key,value in iterable}
            data.append(country_dict)
        return data

data=read_csv('./data.csv')
year_population=['1970','1980','1990','2000','2010','2015','2020','2022']
new_data=[f'{i} Population' for i in year_population]
header=[i for i in data[0]]
print(header)
#print(data_plot)
print(new_data)
print(len(data))
#for j in range(len(data)):
country=list(filter(lambda x:x['Country']=='Colombia',data))
data_plot=[ i for i in country][0]

label={key:value for key,value in data_plot.items()}
values=[label[new_data[i]] for i in range(len(new_data))]

import matplotlib.pyplot as plt

def generate_bar_chart(labels, values):
  fig, ax = plt.subplots()
  ax.bar(labels, values)
  plt.show()


generate_bar_chart(new_data, values)

Yo lo resolví mediante el indexing, separé del dictionary de los años aprovechando que estaban juntos e hice una list aparte, luego separé los elemento por sus keys y sus values respectivos y combiné las lists con la función zip()

def country_selected (country, data):
  search_country = list(filter(lambda element: element['Country/Territory'] == country, data))
  
  keys = list(search_country[0].keys())[5:13]
  values = list(search_country[0].values())[5:13]

  keys_final = list(map(lambda x: x[0:4], keys))
  values_final = list(map(lambda x: float(x), values))
  
  result = dict(zip(keys_final, values_final)) 
  return result

MI aporte:

import pandas as pd
import matplotlib.pyplot as plt

def world_population(country):
    df = pd.read_csv('world_population.csv')    
    df2 = df[df['Country/Territory'] == country].iloc[:,5:13]
    return df2

data = world_population('Colombia')

def barchart(x, y):
    
    fig, ax = plt.subplots()
    ax.bar(x, y)
    plt.show

if __name__ == '__main__':
    barchart(data.columns, data.values[0])

Hola
Veo que hay muchas formas de hacerlo, es genial ver tantas y diversas. Yo tuve que dar muchas vueltas para resolver el reto, al final lo logré. Así que también quiero compartir mi solución 😃

import csv
import matplotlib.pyplot as plt

def population_by_country(path):
    # Lectura del .csv
    country = {}
    with open(path, 'r') as leer_csv:
        leer = csv.reader(leer_csv, delimiter=',')
        header = next(leer)
        # Extaer el país que necesito
        for fila in leer:
            if 'Colombia' in fila:
                data = [i for i in fila]
        country = {head : pop for (head, pop) in zip(header, data)}
        print(country)
        # Crear diccionario header = año (solo con las columnas que neesito)
        years = {year:int(population) for (year, population) in country.items() if 'Population' in year and 'Percentage' not in year}
        print(years)
        # Generar listas a partir del diccionario
        labels = list(years)
        values = [i for i in years.values()]
   
    return labels, values
    
l,v = population_by_country('./ejercicios_clases/diccionario/world_population.csv')

# Generar chart
def generate_chart():
    fig, ax = plt.subplots()
    ax.bar(l, v)
    plt.show()

if __name__ == '__main__':
    data = population_by_country('./ejercicios_clases/diccionario/world_population.csv')
    generate_chart()

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns


df = pd.read_csv('/home/coderdav/personalprojects/python-intermediate/app/data.csv')
data = df[df['Country/Territory'] == 'Bolivia'].iloc[:,5:13]
sns.barplot(data = data, orient='h')
plt.rcParams['figure.figsize'] = (5,4)
plt.xticks(rotation = 45)
plt.show()

Hola a todos(as). Estuve teniendo el error: KeyError: 'Country’
Lo que me funciono fue borrar el archivo que ya tenia agregado y colocar “Country/Territory” en mi función y luego volver a agregar el archivo original. Intente hacerlo modificando el archivo directamente pero el error seguia apareciendo por eso tuve que eliminarlo, espero les sirva.

Mi solución.

import csv
import matplotlib.pyplot as plt


def get_country_data(country, path):
    country_data = []

    with open(path, 'r') as csv_file:
        reader = csv.reader(csv_file)
        header_row = list(next(reader))
        countries_data = [dict(zip(header_row, row)) for row in reader]
        country_data = list(filter(lambda row: row['Country/Territory'] == country, countries_data))
    
    return country_data


def generate_bar_char(labels, values):
    fig, ax = plt.subplots()
    ax.bar(labels, values)
    plt.show()


def run():
    path = './world_population.csv'
    country = input('Country: ')
    country_data = get_country_data(country, path)
    if len(country_data) > 0:
        country_data = {key[0:4]: int(value) for key, value in country_data[0].items() if 'Population' in key and 'World' not in key}
        generate_bar_char(country_data.keys(), country_data.values())
    print(country_data)


if __name__ == '__main__':
    run()

Así lo hice antes de ver el video. Cree diferentes funciones

• Una función para hacer una gráfica de barras

• Una función para abrir y leer el CSV

• Una función para que guardemos solo la información del país que queramos

• Una función para obtener la población de los diferentes años del país que queramos.

import csv
import matplotlib.pyplot as plt


def bar_chart(labels, values):
  fig, axs = plt.subplots()
  axs.bar(labels, values)
  plt.show()
  

def openCSV(csvurl):
    with open(csvurl, "r") as csvfile:
        reader = csv.reader(csvfile, delimiter=",") #En reader tnemos toda la info de los paises
        #print(list(reader))

        headers = next(reader) #Obtenemos nuestros títulos
        poblacion_paises = []
        
        for fila in reader:
            iterable = zip(headers, fila) #Lo hacemos zip para pasarlo a un diccionario, la fila es lo que va cambiando
            #print(list(iterable))
            
            countries_dict = {clave:valor for (clave, valor) in iterable} #En cada iteación crea un nuevo dict
            poblacion_paises.append(countries_dict)
    return poblacion_paises
            

def data_por_pais(poblacion, country): 
    data = list(filter(lambda dict: dict["Country/Territory"] == country, poblacion))    
    return data


def poblacion_por_anio(poblacion_pais):
    #En este diccionario guardamos la población de los diferente años del país
    poblacion = {anio:poblacion for (anio, poblacion) in poblacion_pais[0].items() if "Population" in anio}
    del poblacion["World Population Percentage"]
    return poblacion        

def run():
    poblacion_paises = openCSV("./world_population.csv")
    
    mexico_data = data_por_pais(poblacion_paises, "Mexico")
    print(mexico_data)
    
    poblacion_anual_mex = poblacion_por_anio(mexico_data)
    print(poblacion_anual_mex)
    bar_chart(poblacion_anual_mex.keys(), poblacion_anual_mex.values())             


if __name__ == '__main__':
    run()

Solución un poco ineficiente, hice todo en el archivo de la clase pasada

import matplotlib.pyplot as plt # Sinónimo
import csv
import utils

def read_csv(path):
  with open(path, 'r') as csvfile:
    # delimiter es lo que separa los datos
    reader = csv.reader(csvfile, delimiter=',')
    header = next(reader)
    popul_keys = [header[i] for i in range(5, 13)]
    labels = [header[i][0:4] for i in range(5, 13)]
    data = []
    for row in reader:
      iterable = zip(header, row)
      country_dict = {key:value for key,value in iterable}
      data.append(country_dict)
    return data, popul_keys, labels

def generate_bar_chart(labels, values):
  fig, ax = plt.subplots()
  ax.bar(labels, values)
  plt.show()

def generate_pie_chart(labels, values):
  fig, ax = plt.subplots()
  ax.pie(values, labels=labels)
  ax.axis('equal')
  plt.show()

if __name__ == '__main__':
  data, popul_keys, labels = read_csv('./app/data.csv')
  country = input('Country => ')
  country_data = utils.get_data(data, country)
  print(country_data)
  values = [int(country_data[i]) for i in popul_keys]
  generate_bar_chart(labels, values)
  #generate_pie_chart(labels, values)}
  

Mi solucion

import read
import chart

def filter_country(data, country):
  return list(filter(lambda data_country: data_country['Country/Territory'] == country, data))

def population(data):
  return {key: value for key,value in data[0].items() if key.endswith('Population') == True}

def population_bar_char(data):
  population_labels = list(data.keys())
  population_values = []
  for value in data.values():
    population_values.append(int(value))
  print(population_labels)
  print(population_values)
  chart.generate_bar_chart(population_labels, population_values)

def run():
  country = input('Ingrese un pais: ')
  data = read.read_csv('./app/data.csv')
  data = filter_country(data, country.capitalize())
  data = population(data)
  population_bar_char(data)

if __name__ == '__main__':
  run()

Quee genial reto!

import read_csv
data = read_csv.read_csv("app/data.csv")

def get_population_data(country):
  for element in data:
    if element["Country/Territory"] == country:
      new_country = {}    
      for key, value in element.items():
        if 'Population' in key and key != "World Population Percentage" :
          new_country[key.replace(" Population","")] = int(value)          
        else: 
          continue     
      return new_country
    else:
      continue

#Ejemplo:    
ecu = get_population_data("Ecuador")
print(ecu)

"""

Así lo hice yo

def get_population(country):
  new_country = {}
  for key, value in country.items():
    if ' Population' in key and not 'World' in key :
      new_key = key.replace(' Population', '')
      new_country[new_key] = int(value)
    else: 
      continue
      
  return new_country

reto de convertir el pais en un diccionario solo con los años de la poblacion y el numero,
aclaro que importe la funcion que convierte el archivo csv en un lista de diccionarios, luego filtro por el nombre del pais que se desee buscar

Alguien sabe como conecto replit con el servidor, esto es lo que me aparece y no puedo graficar nada, alguien que me pueda ayudar por favor

import matplotlib.pyplot as plt
from read_csv import read_csv

def get_population_by_country(data, country):
    info_country = list(filter(lambda item: item['Country/Territory'] == country, data))
    country = info_country[0]
    population_dict = {key:country[key] for key in country if 'Population' in key}
    return population_dict

def chart_population_by_country(population_dict):
    labels = list(map(lambda item: item, population_dict))
    labels.pop()
    #values = population_dict.values()
    def get_values(labels, population_dicts):
        values = []
        for label in labels:
            population = population_dicts[label]
            values.append(population)
        return values
    values = get_values(labels, population_dict)
    values2 = list(map(lambda item: int(item), values))
    print(labels)
    print(values)
    print(values2)
    fig, ax = plt.subplots()
    ax.bar(labels, values2)
    plt.show()
    


if __name__ == '__main__':
    data = read_csv('./app/data.csv')
    population_dict = get_population_by_country(data,'Afghanistan')
    chart_population_by_country(population_dict)