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

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')

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() 

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

Este es mi aporte, mi solucion

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 😂

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")

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:

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 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()

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)

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

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)

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

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])

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

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

Comparto mi solucion (admito que me ayude con Copilot)

    # guardo el index a trabajar
    dataIndex = data[10]
    # itero por el diccionaro dataIndex y todos los elementos que en su key tengan la palabra 'Population' los guardo en un diccionario
    population = {key: value for key, value in dataIndex.items() if 'Population' in key}
    #modifico el nombre de la key borrando 'Population'
    population = {key.replace('Population', ''): value for key, value in population.items()}
    print(population)

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()

Hola chicos!! yo quise prepararme un poco más y subi mi proyecto a github, si quieren darle un ojo aqui se los comparto 👀

https://github.com/Maxterjs99/world_population

import csv

with open('./data.csv', 'r') as csvfile:
  reader = csv.reader(csvfile, delimiter=',')
  header = next(reader)
  data = []
  for row in reader:
    iterable = zip(header, row)
    pupulaton_dict = {key.split(' ')[0]: value for key, value in iterable if 'Population' in key}
    data.append(pupulaton_dict)
  print(data)

Hola, compañeros.

Es de mi agrado informarles que pude resolver el reto. Ja, ja.
🎉🎊🥳
No fue facil. Pero se logró.
Lo unico que no agregue fue el filtro por ciudad.

Se los dejo por si a ustedes les sirve.

Justo como dijo el profesor, esto se logró utilizando todo lo aprendedido.
Vamos compañeros, sí podemos. 💪

''
import csv
import matplotlib.pyplot as plt

def read_csv(path):
  with open(path,'r') as csvfile:
    lectura = csv.reader(csvfile,delimiter=',')
    header = next(lectura)
    data = []
    for row in lectura:
      iterable = zip(header, row)
      country_dictionary = {key.replace(' Population',''): int(value) for key , value in zip(header, row) if key.endswith('lation')}
      data.append(country_dictionary)
    return data

def ordered_lists(data):
  just_year = []
  just_population = []
  for element in data:
    for item in element:
      just_year.append(item)
      just_population.append(element[item])
  return just_year, just_population

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

if __name__ == '__main__':
  data = read_csv('./csv/data.csv')
  labels, values = ordered_lists(data)
  barras = my_fist_barchart(labels, values)

''

Hola aqui hago mi aporte al problema, aunque me costo mucho mas tiempo del que pensaba , espero le sirva a alguien, se que se puede usar pandas, pero como se a visto en el curso use este metodo

#librerias usadas
import matplotlib.pyplot as plt
import csv

# funcion que lee cvs y lo guarda en lista
def read_csvV2(path):
    with open(path, 'r') as csvfile:
        reader = csv.reader(csvfile, delimiter=',')
        header=next(reader) #tomar el nombre delas columnas
        data =[]
        for row in reader:
            iterable = zip(header, row) 
            country_dic ={key: value for key, value in iterable}
            data.append(country_dic)
        return data

#funcion que grafica en linea resaltando los puntos
def generate_line_chart(labels , values , title):
    fig, ax = plt.subplots()
    ax.plot(labels, values, marker = "*")
    plt.title(f"crecimiento poblacional de {title}")
    plt.show()

#funcion que toma de la lista un diccionario de un pais y obtiene las poblaciones y el nombre
def read_data_country(dict_world, n):
    dict_pais = dict_world[n]
    Nombre_pais = dict_pais["Country/Territory"]
    lista_key_poblacion =list(dict_world[n].keys())[12:5:-1] # al buscar las keys deseadas estan del puesto 5 al 12 
    lista_de_poblaciones = []

    for i  in lista_key_poblacion:
        lista_de_poblaciones.append(int(dict_pais[i]))
    
    lista_key_poblacion = [label.replace(' Population', '') for label in lista_key_poblacion] #esto quita el popuplation de la key para que sea mas facil de leer la grafica

    return Nombre_pais, lista_key_poblacion, lista_de_poblaciones

read_csvV2("world_population.csv")
dict_world = list(read_csvV2("world_population.csv"))
Nombre_pais, lista_key_poblacion, lista_de_poblaciones = read_data_country(dict_world , 20)
generate_line_chart(lista_key_poblacion, lista_de_poblaciones, Nombre_pais)

hice esto, me falta pulirlo

import pandas as pd
import matplotlib.pyplot as mtpl
import time as time

def yeco(a):
    year_population = {
        '1970': a['1970 Population'],
        '1980': a['1980 Population'],
        '1990': a['1980 Population'],
        '2000': a['1980 Population'],
        '2010': a['1980 Population'],
        '2015': a['1980 Population'],
        '2020': a['1980 Population'],
        '2022': a['1980 Population']
        }
    labels = list(year_population.keys())
    values = list(year_population.values())
    return labels, values

def generate_pie_chart(a, b):
    print(type(a))
    print(type(b))
    fig, ax = mtpl.subplots()
    ax.pie(b, labels=a)
    ax.axis('equal')
    mtpl.show()

if __name__ == '__main__':
    read_csv = pd.read_csv('./proyecto/data_wp.csv', header=0)
    country = (read_csv['Country/Territory'])

    counter = 0
    date_pop = 0
    while counter == 0:
        opt_country = input('Pais: ')
        opt_country = opt_country.capitalize()
        for i in country:
            if opt_country == i:
                break
            else:
                date_pop += 1
        if date_pop < 234:
             counter = 1
             break
        print('Pais Invalido')
        date_pop = 0
        time.sleep(0.5)

    population = (read_csv.iloc[date_pop, 5:13])

    labels, values = yeco(population)

    generate_pie_chart(labels, values)

import char_bar as chart
import file_csv_read as data
def create_chart_csv(pais):
  country = list(filter(lambda country: country['Country/Territory'] ==     pais.title(),data.read_csv_file('world_population.csv')))
  objecto = country[0]
  popu = {prop[:4]: float(objecto[prop]) for prop in objecto if   'Population' in prop and not'Worl' in prop}
  return chart.generate_bar_chart(popu.keys(), popu.values())
if __name__ == '__main__':
  pais = input('Type country => ')
  create_chart_csv(pais)

Sé quie no está modularizado pero esta fue mi solución:

import matplotlib.pyplot as plt
import csv


def csv_to_dict(path):
  with open(path) as file:
    reader = csv.reader(file, delimiter=',')
    headers = next(reader)
    data = list(
      map(lambda row: {key: value
                       for key, value in zip(headers, row)}, reader))

    return data


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


def plotCountryPoblation(country):
  countries_dict = csv_to_dict('chart/data.csv')

  try:
    filtered_countries = list(
      filter(
        lambda country_dict: country in country_dict['Country/Territory'].
        lower(), countries_dict))
    country_found = filtered_countries[0]
    population_tuples = list(
      filter(lambda item: 'Population' in item[0], country_found.items()))
    years = list(
      map(lambda tuple: tuple[0].replace('Population', '', 1),
          population_tuples))
    population = list(map(lambda tuple: tuple[1], population_tuples))
    generate_bar_chart(years, population)
  except IndexError:
    print(f'Country {country} not found')


if __name__ == '__main__':
  country = input('Selecciona el país para ver su población: ').lower().strip()
  plotCountryPoblation(country)

Hasta aqui llegue

data = read_csv(csv_path) #aqui uso el modulo donde aprendimos a leer un .csv

list_year_population = ['2022 Population', '2020 Population', '2015 Population', '2010 Population',
                        '2000 Population', '1990 Population', '1980 Population', '1970 Population']


def search_country(country_name):
    population = {}
    for element in data:
        # print(element)
	      # print(element['Country/Territory'])
        if element['Country/Territory'].lower() == country_name:
            # print(element)
            for key, value in element.items():
                if key in list_year_population:
                    population[key] = value
                    # print(key,':',value)
            # print(population)
            return population

print(search_country('brazil'))

No me la puedo creer =D, ya he avanzado mucho en python, recuerdo que cuando vi esta clase me asuste.

mmmtaa y yo perdiendo mucho tiempo en la clase pasa de porque no me generaba la grafica, si tenia todo igual y era dandole click al + y luego en output

Aqui mi solucion:
.
.
.
.
.
.

.
.

import csv
import matplotlib.pyplot as plt


def population(path, country):
   # Tu código aquí 👇
   labels = ['2022', '2020', '2015', '2010', '2000', '1990', '1980', '1970']
   values = []

   with open(path, 'r') as csvfile:
      reader = csv.reader(csvfile, delimiter=',')
      next(reader)
   
      for row in reader:
        if row[2] == country :
           values.extend([int(item) for item in row[5:13]])


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

Así lo hice yo

import sys

def get_population_by_year(countries_dic, country):
    country_list = list(filter(lambda item : item['CCA3'] == country, countries_dic))
    country_dict = country_list[0]
    result = get_year_popl(country_dict)
    return result

def get_year_popl(dict):
    new_keys = list(filter(lambda match : 'Population' in match[0] and 'Percentage' not in match[0], dict.items()))
    dict = { key[0:4] : value for key, value in new_keys }
    return dict

def read_csv(path):
    rows = []
    with open(path, 'r', encoding="UTF-8") as csvfile:
        reader = csv.reader(csvfile, delimiter=',')
        header = next(reader) 
        for row in reader:
            iterable = zip(header, row)
            country_dict = { key : value for key, value in iterable }
            rows.append(country_dict)
        return rows

country = input('Ingrese el código del país a graficar => ')
countries = csv.read_csv(f'{sys.path[0]}/data.csv')
result = utils.get_population_by_year(countries, country)
print(result)

Por fin después de ver muchas veces el video pude hacer la gráfica, en el archivo utils py estaba poniendo country_dict.keys() en lugar de population_dict.keys()

Aporto mi solución al reto utilizando expresiones regulares

import csv
import re

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

def reader_csv(path):
  with open(path, "r") as csvfile:
    reader = csv.reader(csvfile, delimiter= ",")
    header = next(reader)
    data = []
    for row in reader:
      data.append(dict(zip(header, row)))
    return data

def get_info(datam,search):
  country = list(filter(lambda d: d["Country/Territory"] == search, data))
  labels = [k for k in country[0].keys() if re.search(r"\d Population",k)]
  values = [int(country[0][k]) for k in labels]
  return list(map(lambda val: val.split(" ")[0],labels)), values

if __name__ == '__main__':
    data = read_csv("/content/drive/MyDrive/Colab Files/world_population.csv")
    labels, values = get_info(data,"Argentina")
    generate_bar_chart(values, labels)

Para crear un diccionario con los elementos {‘año’ : población}, pude resolverlo de la siguiente forma:

• Respecto a year_columns: usamos una list comprehension para obtener las posiciones de las cols que contienen datos de los diferentes años.

Para lograrlo, usamos enumarate(header con el fin de obtener: tanto las **i **como los values de column de cada elemento del header. Que contiene los nombres de las cols.

• • Después, por medio de la librería re buscamos la expresión regular (r’\d{4} Population’) “Que tenga cuatro dígitos, y después un [ Population]”.Si hay coincidencias, se guarda el índice i en la lista year_columns

(los resultados del código se ven ahí abajito del print 👆)

• Respecto a esta parte del código: Recorremos cada fila de elementos de data (excepto la primera => [1:]) y verificamos si el valor en la col country_index coincide con el nombre del país que estamos buscando.

si hay coincidencia , recorremos las cols de interés (almacenadas en year_columns) por medio de i

• Dentro del loop, usamos otra RegEx: findall(r’\d{4}’) para extraer el año de la col correspondiente (o sea=> header[i])

• • Después convertimos a entero el valor que hay en la fila row[i].Por último asignamos la población correspondiente al año en el dict: country_data.

• el break lo usamos para salir del bucle, una vez que se haya encontrado la primera fila que cumpla con la condición. Asumiendo que NO hay filas duplicadas para el mismo país

Solo para confirmar, comparamos el resultado obtenido con los datos del CSV

Me costó unos días hacer este código, tuve muchos errores, pero al final me salió. No se rindan 😃

import csv
import re
import matplotlib.pyplot as plt 

def read_csv(path): 
  with open(path,'r') as csvfile: 
    reader = csv.reader(csvfile, delimiter = ',') 
    header = next(reader) 
    country_list = []
    for row in reader: 
      zipper = list(zip(header,row)) 
      country_dict = dict()  
      for (i,j) in zipper:
        if 'Population' in i or 'Country/Territory' in i:
          country_dict[i] = j
        
      country_list.append(country_dict)        

  pais = input('Ingrese el nombre de un pais ')
  pais.title()
  country_name = list(filter(lambda item:item['Country/Territory'] == pais, country_list))
  print(country_name)

  for i in country_name:
    #keys:
    keys = list(i.keys())[1:-1]
    keys_re = []
    keys_x = []
    for k in keys:
      x = re.findall('[0-9]+', k)
      keys_re.append(x)
      for j in range(len(keys_re)):
        x_lab = keys_re[j][0]
      keys_x.append(x_lab)
    print(keys_x)
    #values
    values = list(i.values())[1:-1] 
    values_y = list(map(int,values))

  #reverse
  keys_x.reverse()
  values_y.reverse()

  #graficas
  fig, ax = plt.subplots()
  ax.bar(keys_x,values_y, color = 'black')
  plt.xlabel("Años")
  plt.ylabel("Poblacion")
  plt.title(f'Población de {pais}')
  
  plt.show()
    
  
        
if __name__ == '__main__':
  read_csv('./app/data.csv')

Compañeros 😄

Les comparto mi solución;

Lo que traté de hacer fué usar los módulos que ya tenía (de las clases) para usar las funciones de obtener los datos en formato de diccionario y para mostrar el gráfico.
Luego creé una función que recibe como parámetros la lista con los datos (diccionarios) y el nombre del país por el que quiero filtrar; posteriormente retorna solo el diccionario correspondiente al país que ingrese.

La siguiente función traté de crearla no solo para descartar los demás items, si no para llamarlos al ingresar el parámetro ‘feature’.

La función get_population la hice de esta manera para no asignar dato por dato

<def get_population(dic_country):
  population = {key: value for (key, value) in dic_country.items() if 'Population' in key}
  population = {key: value for (key, value) in population.items() if 'Percentage' not in key}

  labels = list(population.keys())
  values =  list(population.values())
  
  for i in range(len(labels)):
    labels[i] = labels[i].replace('Population', '')
    values[i] = int(values[i])
  
  return labels, values>

Les comparto mi resolucion:

import csv
import moduloCSV

poblacionDicc = moduloCSV.openFileCSV("./Archivos/world_population.csv")
#print(poblacionDicc[0])
poblacion2022 = sum([int(pais["2022 Population"]) for pais in poblacionDicc])
poblacion2020 = sum([int(pais["2020 Population"]) for pais in poblacionDicc])
poblacion2015 = sum([int(pais["2015 Population"]) for pais in poblacionDicc])
poblacion2010 = sum([int(pais["2010 Population"]) for pais in poblacionDicc])
poblacion2000 = sum([int(pais["2000 Population"]) for pais in poblacionDicc])
poblacion1990 = sum([int(pais["1990 Population"]) for pais in poblacionDicc])
poblacion1980 = sum([int(pais["1980 Population"]) for pais in poblacionDicc])
poblacion1970 = sum([int(pais["1970 Population"]) for pais in poblacionDicc])

poblacionHistorico = {
    "2022":poblacion2022,
    "2020":poblacion2020,
    "2015":poblacion2015,
    "2010":poblacion2010,
    "2000":poblacion2000,
    "1990":poblacion1990,
    "1980":poblacion1980,
    "1970":poblacion1970,
}
print(poblacionHistorico)

Anteriormente habia creado un módulo para abrir este archivo (moduloCSV. py) y pasarlo a diccionario directamente, se los comparto tambien:

def openFileCSV(path):
    with open(path, "r") as csvfile:
        archivoCSV = csv.reader(csvfile, delimiter=",")
        header = next(archivoCSV)
        listaDiccionarios = [dict(zip(header, row)) for row in archivoCSV]
    return listaDiccionarios

Así lo realice yo

import csv
import matplotlib.pyplot as plt

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

def obtener_valores_graficar(pais, data):

  datapais = next((item for item in data if item['Country/Territory'].lower() == pais.lower()))
  data_seleccionada = {key.split()[0]:value  for key,value in datapais.items() if 'Population' in key and len(key.split()) == 2}

  return data_seleccionada

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


if __name__ == '__main__':
  data = read_csv('./app/data.csv')
  data_pais = obtener_valores_graficar('chile', data) 
  labels = [item for item in data_pais.keys()]
  values = [item for item in data_pais.values()]
  generate_bar_chart(labels, values)

<code> 

Bueno el aporte que puedo dar es lo siguiente

def creat_list(data):
  datoG = []
  for dat in data:
    dato = {}
    for dat1 in dat:
      if dat1 == 'Country/Territory':
        dato['Country'] = dat[dat1]
        dato['data'] = {}
      elif "Population" in dat1:
        cadenadat = dat1.split(' ')
        if cadenadat[0].isdigit():
          valor = int(dat[dat1])
          dato['data'][cadenadat[0]] = valor

    datoG.append(dato)
    
  return datoG

Esta funcion solo integra el nombre de pais y los datos x año. Considerando que las cabeceras no van a cambiar(nombre) en este caso busco la palabra Population

Pasé horas tratando de entender porqué me daba error el código.
Y es que el profe, no explicó que en la data fuente, había cambiado el nombre de la columna [‘Country/Territory’] por [‘Country’].

Así que realicé este cambió en el módulo utils

**Antes: **

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

Ahora:

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

"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

Hay una cascarita en la función population_by_country, creo que en el ejeriio se le pasó al profe corregir , pero bien despues de una hora dandole sirvió para entender y aprender… 😃

Creo que tengo que hacer más ejercicios con diccionarios, al parecer son el pan de cada día jeje

import read_csv

def transformar(dict):
  newDict = {}
  for i in dict.keys():
    if str(i)[0:4].isdigit():
      newDict[str(i[0:4])] = int(dict[i])
  print(newDict)
    
    
if __name__ == "__main__":
  data = read_csv.read_csv("./app/data.csv")

  country = "Albania"

  row =[]
  for i in data:
    if i['Country/Territory'] == country:
      row = i

  transformar(row)

Yo utilize la libreria de pandas y me cree una carpeta donde separe cada parte en un modulo, intentando aplicar algunas buenas practicas:

comparto codigo por modulos:

Main:

import csv_country as csv
import transformation as tr


if __name__=='__main__':
    df = csv.read_country_csv('\data_a2a96400-8d27-4730-83e9-3998f00eb9b6.csv')
    tr.transform_data_country(df)

csv_country:

import pandas as pd


def read_country_csv(path):
    try:
        df = pd.read_csv(path, usecols=['Country',
                                        '2022 Population',
                                        '2020 Population',
                                        '2015 Population',
                                        '2010 Population',
                                        '2000 Population',
                                        '1990 Population',
                                        '1980 Population',
                                        '1970 Population'])
        # print(df)
        return df
    except FileNotFoundError:
        print('Sorry we the file cannot be open, verify the path')

transformation:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

def transform_data_country(df):
    print(df)
    country = input('Pls, enter a country name: ')
    if country in df['Country'].values:
        print(country + ' exists')
        values = df[df['Country'] == country]
        population_values = values[[    '2022 Population',
                                        '2020 Population',
                                        '2015 Population',
                                        '2010 Population',
                                        '2000 Population',
                                        '1990 Population',
                                        '1980 Population',
                                        '1970 Population']].values[0]
        print(values)
        print(population_values)
        years = ['2022','2020','2015','2010','2000','1990','1980','1970']
        fig, axs = plt.subplots()
        axs.set_ylabel('Population')
        axs.set_xlabel('Year', rotation = 'vertical')
        axs.bar(years, population_values)
        plt.show()

    else:
        print('Sorry country not available for analysis')

Este reto es el que más me hizo demorar, inicialmente no pude filtrar correctamente el population, pero después de ver la clase tuve mejor idea… eso si esperaba algo mejor que hacerlo manual 😅 pero bueno dijo varias veces “Es valido hacerlo asi” 🐍🐧jajaj

Team les comparto mi solucion con regExp

comparto esta solucion para el ejercicio reto antes de la solucion del profe

Buenas, compañeros, paso a dejar mi solución para quien pueda servirle. 😁

Esta es mi solucion.

def get_country_population(data, territory):
    for country in data:
        if country["Country/Territory"] == territory:
	# Lista de años que funcionara de keys para el dict
            years = ["2022", "2020", "2015", "2010",
                     "2000", "1990", "1980", "1970"]
	# Creo un dict con lo que devuelve la func zip()
	# Uso la expresion para iterar sobre las keys de country
            return dict(zip(years, (country[f"{year} Population"] for year in years)))

Hola, en mi caso coloque esta funcion en utils, a la cual le pase la data y el country en string

def only_population_by_year(data, country):
  new_dict = {}
  original_dict = {}
  for info in data:
  #  print("\n\n",info)
    iterable = zip(info.keys(), info.values())
    list_iter = list(iterable)
    if ('Country/Territory', country.title()) in list_iter:
      print("\n",list_iter)
      original_dict = info
      new_dict = {key:int(value) for key,value in list_iter
                if key == '2022 Population' or 
                key == '2020 Population' or
                key == '2015 Population' or
                key == '2010 Population' or
                key == '2000 Population' or
                key == '1990 Population' or
                key == '1980 Population' or
                key == '1970 Population'
               }
      break
  return new_dict, original_dict

Y después la función run() en el archivo main me quedó de la siguiente manera

def run():
  data = read_csv.read_csv('ruta")
  
  country = input("Digite el país a graficar: ")
  new_dict, original_dict = utils.only_population_by_year(data, country)

  if len(new_dict) == 0:
    print("\n\nCountry not found")
  else:
    labels = list(new_dict.keys())
    values = list(new_dict.values())
    print("\n\n",labels,"\n\n",values)
    
    charts.generate_bar_chart(labels, values) 

Y listo, mi aporte

Me gustaría hacer un pequeño aporte. Al hacer este ejercicio, no entendía porque debíamos definir la variable ‘country’ como ‘result[0]’ para poder accionar la función ‘.get_population’. Al ir probando y revisando el contenido de las variables, esto se hace porque al usar la función ‘.population_by_country’ se esta creando una lista con el diccionario correspondiente a nuestro ‘country’. La necesidad de indicar la posición ‘o’ de esta lista en una nueva variable es para poder extraer el diccionario con el cual iterar la función .‘get_population’ ya que al usar result no funciona al ser este una lista y no un diccionario. Es algo sutil pero determinante para el funcionamiento de todo, me pareció genial el descubrimiento así que se los comparto por si no fui el único que se lo preguntó

import csv                        #colocando control csv
import matplotlib.pyplot  as plt  #colocando alias

#quitar los registros antes que se sumen al fichero
def quitar_registros_antes(data_original):
  del  data_original["Rank"]
  del  data_original["CCA3"]
  del  data_original["Capital"]
  del  data_original["Continent"]
  del  data_original["Area (km²)"]
  del  data_original["Density (per km²)"]
  del  data_original["Growth Rate"]
  del  data_original["World Population Percentage"]
  return data_original



#Recuperar datos desde el fichero
  #primero la linea cabecera
  #luego las demás lineas para unirlas
  #elimino los datos antes de subirlos a la memoria
def leer_csv(path):
  with open(path, "r") as csvfile:
    reader =csv.reader(csvfile, delimiter = ",")
    header = next(reader)  #capturamos los encabezados
  
    data = []    #aqui se guardan los datos
    for row in reader: #recuperando datos los datos
      iterable = zip(header, row)
      country_dict = {key: value for key, value in iterable} 
      country_dict = quitar_registros_antes(country_dict)
      data.append(country_dict)
  return data
      
#Solicita al usuario el nombre del pais a buscar
def solicita_nombre_pais():
  print("*" * 25)
  print("Ingresa el nombre del país a graficar datos:")
  pais = input(" -> ")
  return pais

#Busca el país ingresado por el usuario
def buscar_datos_pais(pais, datos_paises):
  print("*" * 25)
  print("* Buscando datos de:", pais) 
  resultado = "<No hay datos del pais ingresado>"
  resultado= list(filter(lambda item:item["Country/Territory"] == pais, datos_paises ))
  return resultado


#grafica los datos, si el pais existe
def generate_bar_chart(datos_pais):
  dato = datos_pais[0] # sacando el elmentodel array para que sea un diccionario
  
  del dato["Country/Territory"]  #Quito el elemento guía
  labels = dato.values()
  values = dato.keys()
  arreglo_labels = []
  arreglo_values = []
  for x in labels:
    arreglo_labels.insert(0, x)
    #arreglo_values.append(x)
  for x in values:
    arreglo_values.insert(0, x)
    #arreglo_values.append(x)
    
  fix, ax = plt.subplots()  
  ax.bar(  arreglo_labels, arreglo_values)
  plt.show()
  return "hola"
  

###principal
def run():
  datos_globales = leer_csv("./app/data.csv")
  #print(datos_globales)

  #Ahora preguntamos por el pais de interes
  pais = solicita_nombre_pais()

  #Buscamos los datos del pais en el fichero
  datos_pais = buscar_datos_pais(pais, datos_globales)
  
  #print(datos_pais)
  generate_bar_chart(datos_pais)
  
if __name__ == "__main__":
  run()

import matplotlib.pyplot as plt
import csv

def read_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    head = next(reader)
    data = []

    for row in reader:
      info = zip(head,row)
      info2 = {head:reader for head,reader in info}
      data.append(info2)

  return data

def run():
  print('This is a program where do going to get the population of a selected country\n')
  while True:
    country = input('Please introduce an existing country: ').capitalize()
    select_country = list(filter(lambda dictionary: dictionary['Country/Territory'] == country, data))
    if select_country != []:
      break

  population = {
    '1970':int(select_country[0]['1970 Population']),
    '1980':int(select_country[0]['1980 Population']),
    '1990':int(select_country[0]['1990 Population']),
    '2000':int(select_country[0]['2000 Population']),
    '2010':int(select_country[0]['2010 Population']),
    '2015':int(select_country[0]['2015 Population']),
    '2020':int(select_country[0]['2020 Population']),
    '2022':int(select_country[0]['2022 Population']),
  }
  
  labels = population.keys()
  values = population.values()
  
  fig, ax = plt.subplots()
  ax.bar(labels, values)
  ax.set(xlabel='Years', ylabel='Population', title=f'Population by year from {country}')
  plt.show()
  
if __name__ == '__main__':
  data = read_csv('./world_population.csv')
  run()```

Aquí mi solución 💪

import csv
import matplotlib.pyplot as plt


def loadCountries():
  with open("./data.csv", 'r') as file:
    next(file)
    csvreaded = csv.reader(file)
    countries = dict()
    for row in csvreaded:
      country = {
        row[2]: {
          "2022": int(row[5]),
          "2020": int(row[6]),
          "2015": int(row[7]),
          "2010": int(row[8]),
          "2000": int(row[9]),
          "1990": int(row[10]),
          "1980": int(row[11])
        }
      }
      countries.update(country)
    return countries


def getCountry():
  countrySelected = input('Please, type a country ').capitalize()
  return countrySelected


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


def runChart(countrySelected, countries):
  if countrySelected in countries:
    countryDict = countries[countrySelected]
    generate_bar_chart(countryDict.keys(), countryDict.values())
  else:
    print('This country does not exist')
    getCountry()


if __name__ == '__main__':
  countries = loadCountries()
  countrySelected = getCountry()
  runChart(countrySelected, countries)

import csv
import matplotlib.pyplot as plt

###################
###  FUNCIONES  ###
###################

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

######################

# Leer el archivo.
with open('data.csv') as csvfile:

    # Recojo la información en forma de diccionario.
    reader = csv.DictReader(csvfile)

    dict_population = {}

    for row in reader:
        population_data = [
                            (2022, row['2022 Population']),
                            (2020, row['2020 Population']),
                            (2015, row['2015 Population']),
                            (2010, row['2010 Population']),
                            (2000, row['2000 Population']),
                            (1990, row['1990 Population']),
                            (1980, row['1980 Population']),
                            (1970, row['1970 Population'])
                            ]

        dict_population[row['Country']] = [(year, row[f'{year} Population']) for year in [2022, 2020, 2015, 2010, 2000, 1990, 1980, 1970]]

    # Recogida del país a buscar

    pais_busqueda = input('Introduce el nombre del país del cuál desear imprimir su gráfico => ')

    fila_encontrada = dict(dict_population[pais_busqueda])

    # Extracción de claves y valores

    key_anyo = fila_encontrada.keys()
    values_population = fila_encontrada.values()

    print(fila_encontrada)
    print(type(fila_encontrada))
    print(fila_encontrada.keys())
    print(fila_encontrada.values())

# Creación de gráficos.

    generate_bar_chart(key_anyo, values_population)

Mi forma de solucionarlo

from read_csv import read_csv
from charts import generate_bar_chart as chart

data=read_csv('app/data.csv')
country=input('Ingrese el pais que desea buscar: ')

try:
    data_country=list(filter(lambda x:x['Country/Territory']==country,data))[0]
    dic_final={key[0:4:]:data_country[key] for key in data_country if ('Population' in key and 'World' not in key)}
    dic_final = dict(reversed(list(dic_final.items())))
    chart(dic_final.keys(),dic_final.values())
except:
    print('El nombre del pais no se ha encontrado')

Si les aparece el error: KeyError: ‘Country’ es porque en el documento data.csv aparece como Country/Territory, lo más fácil es borrar y dejar solo la palabra Country dentro del data.csv

Aquí les dejo mi solución. La dejé toda en un archivo. No importa si al CSV le agregan datos de otros años, el programa se basa en la etiquetas “xxxx Population”. También tiene en cuenta que hay una etiqueta “World Population Percentage”, la cual omite del resultado. El nombre del país se puede pasar sin importar mayúsculas y minúsculas.

import csv
import matplotlib.pyplot as plt

# Lee el archivo y retorna un diccionario con los datos del país
def read_country(country_name, pathcsv = './world_population.csv'):
  with open(pathcsv, 'r') as filecsv:
    reader = csv.reader(filecsv, delimiter = ',')
    headers = next(reader)
    for row in reader:
      # En la segunda columna está el nombre del país
      # Los transformo en mayúsculas para que no hayan errores
      if(row[2].upper() == country_name.upper()):
        pairs_key_value = zip(headers, row)
        country = {key: value for key, value in pairs_key_value}
        return country
  # Lanzamos una excepción en caso de que el país no se encuentre
  raise Exception(f'Country {country_name} not found.')

# Devuelve una lista de tuplas (año, población)
def get_pairs_data_population(country):
  pairs_key_value = []
  for key, value in country.items():
    if 'Population' in key and 'Percentage' not in key:
      pairs_key_value.append((key[:4], int(value)))

  pairs_key_value.sort(key = lambda pair: pair[0] )
  return pairs_key_value
  

# Muestra la gráfica de población para un objeto Country
def show_population_from_data(country):
  pairs_key_value = get_pairs_data_population(country)
  labels = list(map(lambda v: v[0], pairs_key_value))
  values = list(map(lambda v: v[1], pairs_key_value))
  fig, ax = plt.subplots()
  ax.bar(labels, values)
  plt.show()

# Muestra la gráfica de población del país
# cuayo nombre se pasa por parámetro
def show_population_to(country_name):
  country = read_country(country_name);
  show_population_from_data(country)

if __name__ == '__main__':
  show_population_to('CoLoMbIa');

Y este es el codigo de mi archivo 'main’
Este programa puede graficar la poblacion de un pais desde 1970 a 2022 y filtrar por Rango o nombre de pais

import utils
import read_csv
import charts

def run():
  data = read_csv.read_csv('python 102\\40_population_graph\\data.csv')
  filter_type = input("¿Qué tipo de filtro deseas utilizar? ('Rank' o 'Country'): ")

  result = utils.population_by_country(data, filter_type)
  # print(result)
  labels, values = utils.get_population(result)
  # print(labels, values)
    
  charts.generate_bar_chart(labels, values)


if __name__ == '__main__':
  run()

Les comparto el codigo de mi archivo ‘Utils’:

def get_population(filtered_data):
    population_dict = {}
    for key in filtered_data[0].keys():
        # print(filtered_data[0][key])
        if key.endswith('Population'):
            population_year = key.split(' ')[0]
            population = filtered_data[0][key]
            population_dict[population_year] = int(population)
    # print (population_dict)
    labels = population_dict.keys()
    values = population_dict.values()
    return labels, values
    

#Filtro de entrada
def population_by_country(data, filter_type):
    if filter_type == 'Rank':
        try: 
            position = int(input("Ingresa el valor que deseas imprimir? (1 - 234): "))
            filtered_data = [rank for rank in data if int(rank['Rank']) == position]
        except:
            print('Debes ingresar un número (entre 1 y 234)')
            exit()
        return filtered_data    
    elif filter_type == 'Country':
        try:
            country_name = input("Ingresa el país que deseas filtrar: ")
            filtered_data = [country for country in data if country['Country'] == country_name]
            if len(filtered_data) == 0:
                raise ValueError('No se encontraron países con ese nombre')
        except ValueError as error:
            print(str(error))
            exit()
        return filtered_data    
    else:
        print("Ingresa un tipo de filtro válido")
        
        exit()

import csv
import graficas
           
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)    
            diccionario_pais = {key: value for key,value in iterable}  
            data.append(diccionario_pais)  
        return data   

if __name__ == "__main__":             
    diccionarioFull = read_csv("leerarchivos/data.csv")    
    

    paisDic = {}
    for pais in diccionarioFull:
     if pais['Country/Territory'] == "Argentina":
        paisDic = pais
        break

newPaisDic = {

   1990: paisDic["1990 Population"],
   2000: paisDic["2000 Population"],
   2010: paisDic["2010 Population"],
   2015: paisDic["2015 Population"],
   2020: paisDic["2020 Population"],
   2022: paisDic["2022 Population"]
}
print(newPaisDic)

keys = newPaisDic.keys()
values = newPaisDic.values()

print(keys)
print(values)

graficas.generate_bar_chart(keys,values)

Me tarde 2 horas, pero al final se pudo.
Dejo el gráfico de la población de “Antigua and Barbuda”

Y también el código.

""" Realizar un programa que grafique la población de un país. """

import csv
import matplotlib.pyplot as plt


def verificar_population(country_dict):
    list_population = ['Rank', 'CCA3', 'Capital', 'Continent', 'Area (km²)', 'Density (per km²)', 'Growth Rate', 'World Population Percentage']

    for key_list in list_population:
        if key_list in country_dict:
            del country_dict[key_list]

    return country_dict

def only_population_list(list_countries_dict):
    final_list_countries_dict = []

    final_list_countries_dict = list(filter(verificar_population, list_countries_dict))
    
    return final_list_countries_dict

def read_csv(path):
    with open(path, "r") as countries_data:
        reader = csv.reader(countries_data, delimiter=",")
        header = next(reader)
        data_countries_list = []

        for row in reader:
            country_data_dict = {key:value for (key, value) in zip(header, row)}
            data_countries_list.append(country_data_dict)

    return data_countries_list

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

if __name__ == "__main__":
    list_countries_dict = read_csv("./27_Leer_Archivos_CSV/data.csv")
    list_countries_dict_population = only_population_list(list_countries_dict)

    list_labels = list(list_countries_dict_population[7].keys())
    list_values = list(list_countries_dict_population[7].values())

    print(list_labels[0])
    print(list_values[0])

    list_labels.pop(0)
    list_values.pop(0)

    numeric_list_values = list(map(lambda element: int(element), list_values))

    list_labels.reverse()
    numeric_list_values.reverse()

    generar_grafica(list_labels, numeric_list_values)

Por si les ayuda, les comparto el código que hice para filtrar por Rango o por país:

import csv

def read_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    header = next(reader)
    # print(header)
    data = []
    for row in reader:
      iterable = zip(header, row)
      # print(list(iterable))
      country_dict = {key: value for key, value in iterable}
      # print(country_dict)
      data.append(country_dict)
    return data

if __name__ == '__main__':
  data = read_csv('python 102\\app_readcsv\\data.csv')

  #Filtro de entrada
  filter_type = input("¿Qué tipo de filtro deseas utilizar? ('Rank' o 'Country'): ")

  if filter_type == 'Rank':
    try: 
      position = int(input("Ingresa el valor que deseas imprimir? (1 - 234): "))
      filtered_data = [rank for rank in data if int(rank['Rank']) == position]
    except:
      print('Debes ingresar un número (entre 1 y 234)')
      exit()
  elif filter_type == 'Country':
    try:
      country_name = input("Ingresa el país que deseas filtrar: ")
      filtered_data = [country for country in data if country['Country'] == country_name]
      if len(filtered_data) == 0:
        raise ValueError('No se encontraron países con ese nombre')
    except ValueError as error:
      print(str(error))
      exit()
  else:
    print("Ingresa un tipo de filtro válido")
    exit()

Dejo mi resolución al challenge y el grafico obtenido:

import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import numpy as np
import csv

def generate_bar_chart(labels, values):
    values_int = []
    for value in values[1:]:
        values_int.append(int(value))
    fig, ax = plt.subplots()
    ax.bar(labels[1:],values_int,)
    ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, _: f'{int(x)}'))
    ax.invert_xaxis()
    plt.xticks(np.arange(8) ,("2022","2020","2015","2010","2000","1990","1980","1970"), rotation=45)
    plt.title(f'Evolución poblacional de {values[0]}')
    plt.show()

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 if key in 
                            ('Country/Territory','2022 Population','2020 Population',
                             '2015 Population','2010 Population','2000 Population',
                             '1990 Population','1980 Population','1970 Population')}
            data.append(country_dict)
        return data
    
if __name__ == '__main__':
    data = read_csv('./world_population.csv')
    generate_bar_chart(labels = list(data[8].keys()), values= list(data[8].values()))

Resultado:

Buenoooo, aquí dejo mi querido aporte, sin mucha complicación, usando comprehensión en dict, en indexing en string y por supuesto, los módulos read_csv y generate_bar_chart creados en clases anteriores, espero que les guste o les ayude… 😃

from read_csv import read_csv
from charts import generate_bar_chart

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

def country_population():
    population = {}
    search_country = input("Ingrese el país a buscar ")
    for country in complete_data:  
        if country['Country/Territory'] == search_country:
            population = {key[:4] : int(value) for (key, value) in country.items() if key[:4].isnumeric()}
            #value tengo que convertirlo a int para que matplotlib lo lea bien
            return population.keys(), population.values()
    return f"No se ha encontrado {search_country}"  

if __name__ == "__main__":
    labels, value = country_population()    
    generate_bar_chart(labels, value)
    

Posible solución al reto

<import csv

def read_csv(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=",") 
    header = next(reader) 
    data = []

    list = []
    header2 = []
    row2 = []
    
    cont = 0
    for  element in header:
      if("Population" in element):
        list.append(cont)
      cont = cont + 1

    list = list[:-1]
    
    i = 0
    cont = 0
    
    for row in reader:
      while(i<=len(list)-1):
          header2.append(header[list[i]])
          row2.append(row[list[i]])
          i = i + 1
      i = 0

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



if __name__=="__main__":
  result = read_csv("./data.csv")
  print(result)
> 

Cree una logica diferente con menos codigo, aqui les comparto…
La funcion get_population(): utilize list comprenhension para iterar sobre los datos hasta encontrar el pais que buscas, luego de ello, iterar sobre las llaves que contengan la poblacion del pais para crear un diccionario con solo esos valores asi

def get_populations(country, data):
  d = next(d for d in data if d['Country/Territory'] == country)
  population_dict = {key.split(' ')[0]: int(value) for key, value in d.items() if 'Population' in key and key != 'World Population Percentage'}
  labels = population_dict.keys()
  values = population_dict.values()
  return labels, values 

Ten presente que hay una llave que contiene el porcentaje de la poblacion mundial que representa ese pais y ese dato no nos interesa, por eso lo excluimos, y alli mismo convertimos en enteros los valores del numero de poblacion.

De ese manera mi main queda asi

from app import charts, read_csv, utils

def run():
  data = read_csv.read_csv('./app/data.csv')
  country = input('Ingresa el nombre del pais: ').capitalize().replace(' ', '')
  try:
    labels, values = utils.get_populations(country, data)
    print(labels, values)
    charts.generate_bar_chart(labels, values)
  except StopIteration:
    print('Pais no encontrado')

if __name__=='__main__'
	run()

Ten presente que los nombres de los paises inician en mayusculas por eso es importante utilizar el metodo capitalize en el input y mi metodo para saber si el pais que selecciono el usuario esta dentro de la data es usando la funcion try()

mi forma de solucionarlo:

<
import read_csv
import chart

list_countries = read_csv.read_csv('world_population.csv') 
country = input('introduzca el pais ->')
country_to_draw = list(filter(lambda item: item['Country/Territory'] == country, list_countries))

#print(country_to_draw)
values = [
  int(country_to_draw[0]['1970 Population']),
  int(country_to_draw[0]['1980 Population']),
  int(country_to_draw[0]['1990 Population']),
  int(country_to_draw[0]['2000 Population']),
  int(country_to_draw[0]['2010 Population']),
  int(country_to_draw[0]['2015 Population']),
  int(country_to_draw[0]['2020 Population']),
  int(country_to_draw[0]['2022 Population'])
] 
labels = ['1970', '1980', '1990',
         '2000', '2010', '2015',
         '2020', '2022']
chart.generate_bar_chart(labels, values)
> 

Saludos,

comparto el código de mi función para obtener la población de un país:

def getDictionaryPopulationByCountry(country):
  # define population dict
  population = dict()
  # use loop to check each attribute or key of the country
  for key, value in country.items():
    # if key have population and not have world
    if 'population' in key.lower() and 'world' not in key.lower():
      population[key[:key.find(' ')]] = int(value)

  return population

Si hicieron todo bien y al ejecutar la app, queda cargando el gráfico y no se muestra, sólo deben actualizar la ventana del navegador.
Estuve como 15 minutos tratando de buscar el error y no era el código, era replit que se colgó jajaja

from csv_1 import *
import  matplotlib.pyplot   as plt

data=read_csv('./world_population.csv')


def filter_data_generate(data,country):
    lista = list(filter(lambda x: x['Country/Territory']==country,data))
    return lista


def add_popultation(lista,country):
     lista = filter_data_generate(lista,country)
     for v in lista:
         new_dic = v.copy()
         graph = {}
         graph['2020'] = int(new_dic['2020 Population'])
         graph['2022'] = int(new_dic['2022 Population'])
         graph['2015'] = int(new_dic['2015 Population'])
         graph['2010'] = int(new_dic['2010 Population'])
         graph['2000'] = int(new_dic['2000 Population'])
         return graph
            
def graficar_options(func,lista,country):
    x=[ano for ano in func(lista,country).keys()]
    y=[population for population in func(lista,country).values()]
    print(y)
    return x,y 
def generate_graph(labels,values):
    ax = plt.subplot()
    ax.bar(labels,values)
    plt.show()
def main():
    
    try:
        x,y = graficar_options(add_popultation,data,'Argentina')
        generate_graph(x,y)
    except Exception as e:
        raise(e)

if __name__=='__main__':
    main()

import csv
import matplotlib.pyplot as plt
import re

def read_csv (path, country):
with open(path,‘r’) as file:
reader = csv.reader(file, delimiter=’,’)
header = next(reader)
data=[]
for row in reader:
iterable = zip(header, row)
country_dic={ key: value for key, value in iterable }
if country_dic[‘Country/Territory’] == country:
data.append(country_dic)

return data

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

if name == ‘main’:
country=input('Type country: ')
labels=[]
values=[]

data = read_csv(’./app/data.csv’,country)
for key, value in data[0].items():
if re.match(r’^[0-9]’, key):
labels.append(key.split()[0])
values.append(int(value))

generate_bar_chart(labels, values)

VISUALIZACION DE GRAFICA

Hola, un saludo a toda la comunidad, muchas gracias por sus aportes me fueron de mucha utilidad para resolver el reto, sin embargo, la única forma en la que pude resolver el reto fue creando un archivo nuevo fuera de la carpeta app y descargando una copia limpia del archivo ‘World_Population.csv’, todas mis pruebas las había hecho dentro de la carpeta app y no funcionaron, ni siquiera los códigos enviados por mis compañeros funcionaron allí, pero afuera fue distinto, todas las gráficas aparecieron, sin duda algo muy curioso.

Con Pandas ahorras muchas líneas de código, leí un poco sobre Pandas y Matplotlib para mi reto, comparto solución:

import matplotlib.pyplot as plt
import pandas as pd

df1 = pd.read_csv('./app/data.csv') #Leer el CSV con Pandas
df2 = df1.set_index('Country/Territory', drop = False) #Definir columna índice o principal
country = 'Bolivia'
filtered_columns = df2.loc[country: country , '2022 Population':'1970 Population'] #Filtrar solamente las columnas donde se muestra la población y el país

def generate_bar_chart(year, population):
    fig, ax = plt.subplots()
    ax.bar(year, population) #Ejes del gráfico de barras
    plt.xticks(rotation = 45) #Rotar los valores del eje X 45 grados para correcta visualización
    plt.subplots_adjust(bottom=0.25) #ajustar el margen inferior para no cortar las labels
    plt.show()

generate_bar_chart(filtered_columns.columns, filtered_columns.values[0])

Resultado:

Una version dinamica, solicitando los paises que se desean presentar:

from csv import reader
import matplotlib.pyplot as plt

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

def graficar(data,name):
result= list(filter(lambda item:item[‘Country’]==name,data))[0]
print(f’Pais: {name}’)
labels=list(result.keys())[1:-1]
print(f’Columnas: {labels}’)
values=list(map(int,list(result.values())[1:-1]))
print(f’Valores: {values}\n’)
fig, ax = plt.subplots()
titulo = 'Poblacion Anual de [ ’ + name + ’ ]'
plt.title(titulo)
plt.xlabel(‘Poblacion’)
plt.ylabel(‘Cantidad’)
ax.bar(labels, values)

if name == ‘main’:
pais = input('Ingrese el primer país: ')
graficar(datos,pais)
pais = input('Ingrese el segundo país: ')
graficar(datos,pais)
plt.show()

Hola, Esta es mi versión del grafico: dos graficos para dos paises, con titulo y etiqueta para los datos. Adicionalmente presentando los valores de las columnas y el valor correspondiente de la columna como texto para validar.

from csv import reader
import matplotlib.pyplot as plt

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

def graficar(data,name):
result= list(filter(lambda item:item[‘Country’]==name,data))[0]
print(f’Pais: {name}’)
labels=list(result.keys())[1:-1]
print(f’Columnas: {labels}’)
values=list(map(int,list(result.values())[1:-1]))
print(f’Valores: {values}\n’)
fig, ax = plt.subplots()
titulo = 'Poblacion Anual de [ ’ + name + ’ ]'
plt.title(titulo)
plt.xlabel(‘Poblacion’)
plt.ylabel(‘Cantidad’)
ax.bar(labels, values)

if name == ‘main’:
graficar(datos,‘Colombia’)
graficar(datos,‘Armenia’)
plt.show()

Hola! Mi código quedó frustrante mente largo. Pero aquí lo dejo c:

import csv
import matplotlib.pyplot as plt

def transform_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 = {key: value for key, value in iterable}
            data.append(country)    
     return data


def ask_country(data,elm):
    country = str.capitalize(input('¿Por cuál país quieres filtrar? (si ninguno: "None") --> '))
    data_copy = data.copy()
    is_country = list(i["Country"]==country for i in data_copy)
    is_country_filtered_list = list(filter(lambda x: bool(x), is_country))
    
    if not is_country_filtered_list:
        print(f"No se encontraron valores para el país {country}, se procede a sacar datos generales.")
        data_filtered = filter_data(data,elm)
    else:
        data = list(filter(lambda i: i["Country"] == country,data_copy))
        data_filtered = filter_data(data,elm)
    return data_filtered

def filter_data(data,elm):
    data_copy = data.copy()
    data_filter_func = [(i, j) for elemen in data_copy for i, j in elemen.items()]
    data_filtered = []
    for tuple in data_filter_func:
        if tuple[0] not in elm:
            data_filtered.append(tuple)
        else:
            print(f"Se ha eliminado el elemento {tuple}")
    return data_filtered

def graficar(data):
    labels_values = {}
    for i in data[1:]:
        labels_values[i[0]] = i[1]
    return labels_values

def graficar2(labels_vals):
    graph = str.lower(input("¿Qué tipo de grafica quieres? (barras o torta)"))
    labels = labels_vals.keys()
    values = labels_vals.values()
    print("labels", labels, type(labels), "values", values, type(values))
    if graph == "barras":
        fig, ax = plt.subplots()
        ax.bar(labels, values)
        plt.show()
    elif graph == "torta":
        fig, ax = plt.subplots()
        ax.pie(values, labels=labels)
        ax.axis("equal")
        plt.show()

data = transform_csv("./resources/datos.csv")
elementos_a_eliminar = ['Rank', 'CCA3', 'Capital', 'Continent', 'Area (km²)', 'Density (per km²)', 'Growth Rate', 'World Population Percentage']
data = ask_country(data,elementos_a_eliminar); print("Resultado  ==>  ",data)
graficar2(graficar(data))

Yo lo realice en google colab de esta manera

from os import replace
from google.colab import drive
import csv
import matplotlib.pyplot as plt

drive.mount('/content/drive')

def read_csv(path, country):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    header_full = next(reader)
    header = []
    count_h = 1
    while count_h <=12:
      if count_h>=1 and count_h<=2:
        header.append(header_full[count_h])
      if count_h>=6 and count_h<=12:
        header.append(header_full[count_h].replace(" Population",""))
      count_h += 1
    print(header)
    for row in reader:
      my_row = row[1:3]
      my_row.extend(row[6:13])
      my_row_2 = []
      count = 0
      for i in my_row:
        if count == 0 or count == 1:
          my_row_2.append(i)
          count+=1
        else:
          my_row_2.append(int(i))
      if my_row_2[0] == country:
        generate_bar_chart(header[2:],my_row_2[2:])

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

if __name__ == '__main__':
  pais = input('Dime que pais quieres que te muestre: ').upper()
  data = read_csv('/content/drive/MyDrive/Colab Notebooks/Curso de Python Comprehensions, Funciones y Manejo de Errores/world_population.csv', pais)
  print(data)

Hice el listado así:

def read_csv(path, country_name):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',')
    header = next(reader)
    header = list(map(lambda input: re.findall('[0-9]+', input)[0] if input.endswith(' Population') else input, header))

    country = {}
    for row in reader:
      if(row[1] == country_name):
        iterable = zip(header, row)
        country = {key: value for key, value in iterable}
        break

    if not bool(country):
      return ['Country not found', 0]

    population = list(map(lambda key: {key: int(country[key])} if key.isdigit() else None, header))
    while None in population:
      population.remove(None)
    
    return population