Reto: graficando la población mundial

Para este reto se me ocurrio hacer otra funcion que recibiera la data, hacer un dictionary comprehention para filtrar los datos y devolver las llaves y los valores de ese diccionario

def get_world_percentages(data):
    percentages_dict = {item["Country/Territory"]: item["World Population Percentage"] for item in data}

    names = percentages_dict.keys()
    per = percentages_dict.values()

    return names, per

Si te sale el error: KeyError: 'Country’
Mismo caso que en el video anterior, solo sustituye ‘Country’ por ‘Country/Territory’

countries = list(map(lambda x: x['Country/Territory'], data))

def get_country_percentage(data):
    data_percentage = {i['Country/Territory']:
            float(i['World Population Percentage']) for i in data}
    return data_percentage.keys(),data_percentage.values()

import mod as md
import Charts as ch
import Read_csv_Dic as rd

def run():
    data = rd.read_csv('app/Data.csv')
    #print(data[0])
    data = list(filter(lambda i : i['Continent'] == 
                'South America', data))
    enc, val = md.get_country_percentage(data)
    ch.generate_pie_chart(enc,val)

if __name__ == '__main__':
    run()

Yo lo hice ordenando los paises respecto al porcentaje, aqui les comparto.

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 'World Population' in i :
                codict[i]=j
        data1.append(codict)


def graficar(data,name):
    data2 = sorted(data, key= lambda x: x['World Population Percentage'])
    labels=[i['Country'] for i in data2]
    values=[i['World Population Percentage'] for i in data2]
    fig, ax = plt.subplots()
    ax.pie(values,labels=labels)
    plt.show()

graficar(data1,'Bolivia')

Hola! mi solución fue crear otra función en utils para obtener label y value

import utils
import readcsv
import charts

def run():
  data = readcsv.readCsv('./app/data.csv')
  labels, values = utils.populationTotal(data)
  charts.generatePieChart(labels, values)

if __name__ == '__main__':
  run()

# función dentro de utils.py
def populationTotal(data):
  percentages = []
  countries = []
  for i in data:
    #countries.append(i['Country/Territory']) 
    countries.append(i['CCA3'])
    percentages.append(float(i['World Population Percentage']))
  return countries, percentages

Yo resolví este reto preguntándole al usuario que elija si quiere población de un país o mundial. acá va el código:

from read_csv import read
from population_by_country import country_population
from charts import generate_bar_chart
from world_population import world_population


def run():
    data = read('./world_population.csv')
        
    choose = input('What would you like to know, the population grown in one country(C)\
or the world population growth(W)?(choose C or W): ')
    choose = choose.upper()
    if choose == 'C':
        countries = input('Choose a country: ')
        countries = countries.capitalize()
        for country in data:
            if country['Country/Territory'] == countries:
                labels , values = country_population(country)
                generate_bar_chart(countries, labels, values)
    elif choose == 'W':
        labels, values = world_population(data)
        generate_bar_chart('Wolrd Population Growth', labels, values)

        


if __name__ == '__main__':
    run()

función población mundial

from read_csv import read

def world_population(data):
    
    data = data
    
    population_1970 = []
    population_1980 = []
    population_1990 = []
    population_2000 = []
    population_2010 = []
    population_2015 = []
    population_2020 = []
    population_2022 = []

    for population in data:
        population_1970.append(int(population['1970 Population']))
        population_1980.append(int(population['1980 Population']))
        population_1990.append(int(population['1990 Population']))
        population_2000.append(int(population['2000 Population']))
        population_2010.append(int(population['2010 Population']))
        population_2015.append(int(population['2015 Population']))
        population_2020.append(int(population['2020 Population']))
        population_2022.append(int(population['2022 Population']))

    labels = ['1970', '1980', '1990', '2000', '2010', '2015', '2020', '2022']
    values = [
            sum(population_1970), 
            sum(population_1980), 
            sum(population_1990), 
            sum(population_2000), 
            sum(population_2010),
            sum(population_2015),
            sum(population_2020),
            sum(population_2022)
            ]
    
    return labels, values


if __name__ == '__main__':
    world_population('world_population.csv')

Saludos comunidad,
.
Les comparto el repo del proyecto: Github
.
Si quieres hacer Networking, estoy aquí: Website
.

Me encanto este ejercicio de filtrar datos para mostrar un grafico. Es algo interesante para aprender.

Este fue la solución al reto, aproveché y también ordene los valores y gráfique los top 15 paises con más población y al resto lo dejé como “otros”

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)
    # print(data)
    return data

def llave(dict):
  # aquí lo que hago es que tomo la data del csv leido y hago un zip de dos list comprehension, una con los nombres del país y otra con el porcentaje de participación
  # a esto lo que hago es de una leerlo en un dictionary comprehension para poder ya tener el formato diccionario correcto con "pais: % population"
  popu = {key: value for key, value in list(zip([item['Country/Territory'] for item in dict], [float(item['World Population Percentage']) for item in dict]))}

  #luego lo que hago es crear otra variable para ordenar de mayor a menor la participación.
  # como al ordenarlo vuelve a quedar como una lista, vuelvo a hacer un dictionary comprehension con la lista de ordenamiento para tener el formato correcto.
  my_dict = {key: value for key, value in list(sorted(popu.items(), key=lambda item: item[1], reverse=True))}

  # luego creo una variable del top 15 de los paises y me lo traigo con [:15] ya que al estar ordenado me trae las 15 primeras  llaves y valores 
  top_15 = {key: value for key, value in list(my_dict.items())[:15] }

  # creo la variable del procentaje restante con una resta de la suma de dict values (el total) - la suma de valores de la variable que cree recién.
  porcentaje_restante = sum(my_dict.values()) - sum(top_15.values())

  #y lo que hago acá es agregar como "otros" el porcentaje resultante de la resta anterior para que el gráfico sea más amigable
  top_15["Otros"] = porcentaje_restante

  # creo los labels y values correspondientes para poder retornar y gráficar.
  paises = [x for x in top_15.keys()]
  world = [x for x in top_15.values()]

  # print(my_dict)
  # print(top_15)
  # print(porcentaje_restante)
  return paises, world

def generate_pie_chart(labels, values):
  fig, ax = plt.subplots()

  # Hemos agregado (auto porcentaje) autopct='%1.1f%%' al primer llamado de ax.pie en la función para que se muestren los porcentajes en formato de texto dentro de cada porción.
  # Luego, utilizamos la variable autotexts para modificar los valores de porcentaje y agregar el signo "%" al final.

  # La opción autopct en Matplotlib se utiliza para especificar el formato de presentación de los porcentajes dentro de las porciones de un gráfico de pastel.
  #Por ejemplo, autopct='%1.1f%%' significa que los porcentajes se presentarán con un formato que muestra un dígito antes del punto decimal y un dígito después del punto decimal,
  # seguido del signo "%" (por ejemplo, "12.3%").

  #startangle define en que grado se empezará a posicionar los valores en el caso de 180 china se empieza a graficar a las 9 horas reloj

  ax.pie(values, labels=labels, autopct='%1.1f%%', startangle=360)
  ax.axis('equal')

  # Agregar el número del porcentaje dentro de cada porción
  #   En un gráfico de pastel (pie chart) de Matplotlib, wedges, texts, y autotexts son variables que se obtienen cuando se llama a la función ax.pie() 
  # y se utilizan para personalizar y manipular elementos del gráfico. Aquí te explico brevemente el propósito de cada uno:

# wedges: Esta variable contiene información sobre las porciones individuales del gráfico de pastel. 
  #Puedes utilizar wedges para realizar cambios en el aspecto de las porciones, como colores, sombreado, bordes, etc.

  # texts: Esta variable contiene información sobre las etiquetas de las porciones. Puedes usar texts para personalizar las etiquetas, como cambiar su color, tamaño de fuente o posición.

# autotexts: Esta variable contiene información sobre los números del porcentaje que se muestran dentro de las porciones.
# Puedes utilizar autotexts para personalizar cómo se muestran los números del porcentaje, como el tamaño de fuente, el formato o la posición.

  wedges, texts, autotexts = ax.pie(values, labels=labels, autopct='', startangle=360)

  # for text, autotext in zip(texts, autotexts):
  #   autotext.set_text(f'{autotext.get_text()}%')
  #   autotext.set_fontsize(0.01)  # Ajusta el tamaño de la fuente aquí
  
  plt.show()

if __name__ == '__main__':

  final = llave(read_csv('./data.csv'))
  
  generate_pie_chart(final[0], final[1])

Todo esto lo puedo hacer con excel lol

import csv
import matplotlib.pyplot as plt


def read_csv(ruta, continent):
    # convertir los datos en una lista de diccionarios
    with open(ruta) as f:
        reader = csv.reader(f)
        header = next(reader)

        paises = []
        for row in reader:
            dict_pais = {key: value for key, value in zip(header, row)}
            paises.append(dict_pais)

    # [[label],[value]]
    poblacion_mundial = [[], []]
    for pais in paises:
        # clasifico segun el continente seleccionado
        if pais['Continent'] == continent:
            # label
            cca3 = pais['CCA3']
            poblacion_mundial[0].append(cca3)

            # value
            porcentaje = pais['World Population Percentage']
            poblacion_mundial[1].append(porcentaje)

    return poblacion_mundial

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




if __name__ == '__main__':
    mis_datos = read_csv('./data.csv', 'South America')
    generate_pai_chart(mis_datos[0], mis_datos[1])

import utils2
import readCSV2
import graficas2

def run():
    
    data = readCSV2.readCsv("./proyectoPoblacionPais/data2.csv")

    columnCountries = list(map(lambda x : x["Country"], data)) 
    columnPorcentages = list(map(lambda x : x["World Population Percentage"], data))
    graficas2.generatePieChart(columnCountries, columnPorcentages)
    
if __name__ == '__main__':
    run()

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

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

data=read_csv('./data.csv')
new_data=[]
for i in data:
  country_labels=[value for key,value in i.items() if key=='Country' ]
  country_values=[value for key,value in i.items() if key=='World Population Percentage' ]
  #country['World Population Percentage']=i['World Population Percentage']
  array_vs=zip(country_labels,country_values)
  new_data.append(array_vs)
values=[]
labels=[]
for i in new_data:
  l,v=list(i)[0]
  values.append(v)
  labels.append(l)


import matplotlib.pyplot as plt

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


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

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

data=read_csv('./data.csv')
new_data=[]
for i in data:
  country_labels=[value for key,value in i.items() if key=='Country' ]
  country_values=[value for key,value in i.items() if key=='World Population Percentage' ]
  #country['World Population Percentage']=i['World Population Percentage']
  array_vs=zip(country_labels,country_values)
  new_data.append(array_vs)
values=[]
labels=[]
for i in new_data:
  l,v=list(i)[0]
  values.append(v)
  labels.append(l)


import matplotlib.pyplot as plt

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


generate_pie_chart(labels,values)

Creo que entendi mal ejerccicio, pero me salio algo interesante

def get_columna(columna_dicc):
  cantidad_camp=int(input('Digita el numero de campos :'))
  contador=0
  llaves=[]
  definiciones=[]
  while contador<cantidad_camp:
    b=str(contador+1)
    nombre_camp=input('Digita el nombre del campo '+b+': ')    
    llaves.append(nombre_camp)
    arreglo_def=columna_dicc[nombre_camp]
    definiciones.append(float(arreglo_def))
    contador+=1 
  columna_dict = dict(zip(llaves,definiciones))
  llaves=columna_dict.keys()
  valores=columna_dict.values()
  return llaves, valores  

import read_csv as r_csv
import charts as chrts

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

countries = [ elem['Country'] for elem in data]

percentages = [ elem['World Population Percentage'] for elem in data]

chrts.generate_pie_chart(countries, percentages)

Les dejo mi pequeña aportacion.
Es diferente y aun se puede optimizar. Pero yo lo hice. Ja, ja.
Usando los recursos y lo aprendido en las clase anteriores.

''
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: value for key, value in zip(header, row)}
      data.append(country_dictionary)
    return data

def ordered_lists(data):
  labels = []
  values = []
  continente = input('Que continente revisamos? ')
  for element in data:
    if element['Continent'] == continente:
      for item in element:
        if item == 'Country/Territory':
          labels.append(element[item])
        if item == 'World Population Percentage':
          values.append(float(element[item]))
  return labels, values

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

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

Utilicé esta función en mi módulo UTILS:

def get_world_population_percentage(data):
  countries = [country['Country/Territory'] for country in data]
  percentages = [country['World Population Percentage'] for country in data]
  return countries,percentages 

Posteriormente en mi archivo MAIN:

import utils
import read_csv
import charts

def run():
  data = read_csv.read_csv('./project/data.csv')
  labels,values = utils.get_world_population_percentage(data)
  charts.generate_pie_chart(labels,values)
  
if __name__ == '__main__':    #Ejecutar desde la terminal
  run()

Usando pandas y matplotlib:

df = pd.read_csv('world_population.csv') 
df2 = df.filter(['Country/Territory', 'World Population Percentage'])

fig, ax = plt.subplots()
ax.pie(df2['World Population Percentage'], labels = df2['Country/Territory'])
ax.axis('equal')
plt.show

Esta es mi solucion

import read_csv as re
import matplotlib.pyplot as plt

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

if name == ‘main’:
data = re.read_csv(’./app/data.csv’)
labels = list(map(lambda item: item[‘Country/Territory’], data))
values = list(map(lambda item: item[‘World Population Percentage’],data))

generate_pie_chart(labels, values)

Para el reto, creé una nueva función, en la cual selecciono de la lista de diccionarios, solo el nombre del país y su porcentaje de población, usando comprehensions

Aqui mi solucion:
.
.
.
.
.
.
.
.
.

import csv
import matplotlib.pyplot as plt


def population(path):
   # Tu código aquí 👇
   labels = []
   values = []

   with open(path, 'r') as csvfile:
      reader = csv.reader(csvfile, delimiter=',')
      print(next(reader))
   
      for row in reader:
        labels.append(row[2])
        values.append(float(row[16]))


  
   plt.pie(values, labels=labels)
   plt.show()

Me siento orgulloso de haber hecho el reto sin mirar la del curso, siento que es un poco mas directa que la del curso 😛

mi propuesta de solución era utilizando FOR para almacenar la informacion, sin embargo, veo que una solución mas sencilla es implementando Dictionary Comprehension.
1 - Solución inicial:

2 - Solución con Dictionary comprehensivo:

1- Main de la aplicacion desarrollado para la primera propuesta de solución:

2 - Main de la aplicacion usando el Dictionary Comprehension:

Para variar un poco el reto, traje el top 10 de los países con mayor World Population Percentage

def get_info(data):
  labels = list(map(lambda val: val["Country/Territory"],data))
  values = list(map(lambda val: float(val["World Population Percentage"]),data))

  #Ordeno el diccionario - Top 10 países
  sort = sorted(zip(labels, values),key=lambda x:x[1],reverse=True)[0:10]
  print()
  return dict(sort).keys(),dict(sort).values()

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

para el reto hice el código desde 0. Consta de 2 funciones: La primera lee el csv y extrae las columnas de interés en una lista, retornándolas como labels y values:

• Obtenemos los índices de las columnas de interés: header.index('nombre_col'), y luego iteramos la lista que contiene al dataset (data)
• • Comenzamos la iteración desde la fila sub 1 => data[1:] ya que la primera contiene los headers.

Objetivo de la iteración: Colocar los nombres de países y porcentajes en su respectiva lista, siempre y cuando su porcentaje poblacional sea mayor a 1 (por que si imprimimos todo se hace un desmadre 👇)

Para ello, por cada iteración: agregamos el contenido de country_index de la fila actual, y la agregamos a countries. (siempre y cuando se cumplan las condiciones de porcentaje >1)

• repetimos el proceso en la misma fila pero con la otra col de interés. Al terminar las iteraciones, retornamos ambas listas

La segunda función se encarga de graficar los labels / values obtenidos en la función anterior:

Creamos la figura junto con su axes porque si no matplotlib se enoja, y también definimos el tamaño de toda la gráfica. Argumentos del pie():

• Configuramos la visualización del porcentaje, o sea el “%” que se muestra en las etiquetas. Esto => autopct=‘1.1f%%’ mostrará los porcentajes redondeados a una décima, seguidos de un “%”
• textprops = {‘cosas’ : cosas} lo usamos para configurar el texto de las labels, en este caso fontsize indica el tamaño que tendrá el texto en cuestión.

Despues, set() ayuda a configurar varias propiedades del objeto ax. Con esto podemos personalizar aspectos tales como el título de la gráfica, aspecto visual, etiquetas en los ejes ( xlabel=texto, ylabel=texto)

y boom… Esto es lo que obtenemos:

Conclusión, estudiar pie charts da hambre

Mi solucion usando map

def get_world_population_percentage(data):
    countries, percentages = \
        [[item['Country/Territory'] for item in data], [item['World Population Percentage'] for item in data]]

    return countries, percentages

Mi solución a la segunda parte del proyecto usando la librería pandas:

def creat_only_list(data):
  datoG = {}
  for dat in data:
    dato = {}
    for dat1 in dat:
      if dat1 == 'Country/Territory':
        dato['Country'] = dat[dat1]
      elif "World Population Percentage" in dat1:        
        datoG[dato['Country']] = float(dat[dat1])

  return datoG

Funcion para asignar el valor de cada pais x la columna que se debe mostrar en el grafico de pie

Sigo pensando en FOR, en vez de LAMBDA:

import read_csv
import charts

def getPopulationPercentage(data):
  labels = []
  percentage = []

  for country in data:
    labels.append(country['Country/Territory'])
    percentage.append(float(country['World Population Percentage']))

  return labels, percentage

if __name__ == "__main__":
    data = read_csv.read_csv("./app/data.csv")
    labels, percentage = getPopulationPercentage(data)
    charts.generatePiechart(labels, percentage)

Se logró banda. sin ver la solución de la clase:

import read_csv
import charts


def run():
  data = read_csv.read_csv('./app/data.csv')
  #print(len(data))
  countryes = [data[i]['Country/Territory'] for i in range(len(data))]
  percents = [data[i]['World Population Percentage'] for i in range(len(data))]
  #par = []
  #for i in range(len(data)):
   # par.append({data[i]['Country/Territory'], data[i]['World Population Percentage']})
  print(countryes, percents)
  charts.generate_pie_chart(countryes, percents)

if __name__ == '__main__':
  run()

ni para que comparto esta vez si me fruste feo. es como un enredo de conceptos en la cabeza, el anterior medio lo lleve pero este aunque se ve sencillo jum a repasar mas.

Hice unas modificaciones usando expresiones regulares, anidando dos validaciones dentro de un ternario, para que cuando se este creando el diccionario con la data.
Revise si los valores son numeros, si son enteros hace la conversion a INT, o si tienen decimales hace la conversion a FLOAT.

import csv
from pprint import pprint
import re
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)
      isFloat = lambda x: bool(re.match("\d+.\d+",x))
      isInt = lambda x: bool(re.match("\d+",x))
      
      country_dict = {key:float(value) if isFloat(value) else int(value) if isInt(value) else value for key,value in iterable}
      data.append(country_dict)
  return data
      
if __name__ == "__main__":
  data = read_csv("./data.csv")
  print(data[0])

Una manera mas corta de extraer el nombre de los paises y el porcentaje, es usando list comprehesion sobre la data.

countries = [x["Country"] for x in data]
percentage = [float(x["World Population Percentage"]) for x in data]

en percentage, agregue un float, para transformar el tipo de str a números y poder operar con ellos.

Una manera mas corta de extraer el nombre de los paises y el porcentaje, es usando list comprehesion sobre la data. ``` countries = [x["Country"] for x in data] percentage = [float(x["World Population Percentage"]) for x in data] ``` en percentage, agregue un float, para transformar el tipo de str a números y poder operar con ellos.

Aca mi aporte de como hice la gráfica de torta por mi cuenta, es un poco tosco el código pero funcional

import read_csv
import charts

def run():
  data = read_csv.read_csv('./app/data.csv')
  labels = [i['Country/Territory'] for i in data]
  values = [i['World Population Percentage'] for i in data]
  charts.generate_pie_chart(labels, values)

if __name__ == '__main__':
  run()

Que tal, yo lo hice de esta manera:

def world_percentage_population(data):
  country = []
  percentage = []

  for info in data:
    country.append(info['Country/Territory'])
    percentage.append(info['World Population Percentage'])
  
  return country, percentage

#### seleccionar una columna de un fichero y graficar
import csv                        #colocando control csv
import matplotlib.pyplot  as plt  #colocando alias

#Recuperar datos desde el fichero
  #primero la linea cabecera
  #luego dos listas, una para los nombres de los paises y otra para sus datos
def obtener_datos_columna(path, columna):
  with open(path, "r") as csvfile:
    reader =csv.reader(csvfile, delimiter = ",")
    header = next(reader)  #quito la cabecera

    data_nom_pais = []    #aqui se guardan los datos
    data_valores = []
    for row in reader: #recuperando datos de una columna
      data_nom_pais.append(row[3]) #nombre de los paises
      data_valores.append(row[columna + 4])  #dato de la columna
  return data_nom_pais, data_valores

    
#Solicita al usuario el nombre de la columna a buscar
def solicita_numero_columna():
  print("*" * 40)
  print("Ingresa el número de la información a graficar:")
  print("""
  [ 1] 2022 Population [ 2] 2020 Population [ 3] 2015 Population
  [ 4] 2010 Population [ 5] 2000 Population [ 6] 1990 Population
  [ 7] 1980 Population [ 8] 1970 Population [ 9] Area (km²)
  [10] Density (km²)   [11] Growth Rate     [12] World Populat %
  """)

  opcion = int(input(" -> "))
  return opcion

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

###principal
def run():
  num_columna = solicita_numero_columna()

  data_nom_pais, data_valores = obtener_datos_columna("./app/data.csv", num_columna)
 
  generate_pie_chart(data_nom_pais, data_valores)

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 World Population Percentage of a selected country, a region or all countries\n')
  while True:
    country = input('Please introduce an existing country or select: Region or All countries: ').capitalize()

    if country == 'All countries':
      all_country()
      break

    if country == 'Region':
      region()
      break

    select_country = list(filter(lambda dictionary: dictionary['Country/Territory'] == country, data))
   
    if select_country != []: 
      one_country(country,select_country) 
      break
      
def one_country(country,select_country):
  label = country
  value = [float(select_country[0]['World Population Percentage'])]
  
  fig, ax = plt.subplots()
  ax.bar(label, value)
  ax.set(xlabel='Country', ylabel='World Population Percentage', title=f'World Population Percentage from {country}')
  plt.show()

def all_country():
  labels = []
  values = []
  
  for i in data:
    labels.append(i['Country/Territory'])
    values.append(float(i['World Population Percentage']))
  
  fig, ax = plt.subplots()
  ax.pie(values, labels=labels)
  plt.show()
  
def region():  
  while True:
    region = input('Select a region: Africa, Asia, Europe, North America, Oceania or South America').title()
   
    if region == 'Africa' or region == 'Asia' or region == 'Europe' or region == 'North America' or region == 'Oceania' or region == 'South America':
      selected_region = list(filter(lambda dictionary: dictionary['Continent'] == region, data))
      
      labels = []
      values = []
  
      for i in selected_region:
        labels.append(i['Country/Territory'])
        values.append(float(i['World Population Percentage']))

      fig, ax = plt.subplots()
      ax.bar(labels, values)
      ax.set(xlabel='Countries', ylabel='World Population Percentage', title=f'World Population Percentage from {region}')
      plt.xticks(rotation=90,fontsize=5)
      plt.show()
    
      break  

if __name__ == '__main__':
  data = read_csv('./world_population.csv')
  run()

Mi solución:

import csv
import matplotlib.pyplot as plt


def loadCountriesPie():
  with open("./data.csv", 'r') as file:
    next(file)
    csvreaded = csv.reader(file)
    countries = dict()
    for row in csvreaded:
      country = {
        row[2]: int(float(row[16]) * 100)
      }
      countries.update(country)
    return countries

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

if __name__ == '__main__':
  countries = loadCountriesPie()
  generate_pie_chart(countries.keys(), countries.values())

Aca estan las funciones que cree:

def Grafico_torta():
  data = read_csv.read_csv('./app/data.csv')
  dato_graficar = input("Ingrese la columna que desea graficar => ")
  #print(data)
  #print("***" *4)
  print(dato_graficar)
  result,paises = utilis.elemento_grafica(data,dato_graficar)
  #print(result)
  #print(paises)
  charts.generate_pie_chart(paises, result)

def elemento_grafica(data,elemento):
  result = []
  paises = []
  for element in data:
    #print(elemento)
    #element.keys()
    for columnas in element:
      #print(columnas)
      if columnas == elemento:
        paises.append(element.get('Country/Territory'))
        result.append(int(element.get(columnas)))
  return result, paises

import pandas as pd
import matplotlib.pyplot as plt
df_v2 = pd.read_csv("pandass/world_population.csv")

data_v2 = df_v2.loc[:,"Continent"] == "South America"
datos = (df_v2.loc[data_v2, ["Country/Territory","World Population Percentage"]])
plt.rcParams['font.size'] = 8
plt.pie(datos[datos.columns[1]], labels=datos[datos.columns[0]], labeldistance=1.2)
plt.show()```

yo lo hice asi:
una vez que arme la lista de diccionarios, en donde cada diccionario es una fila hice la seleccion de pais porcentaje de la siguiente manera>
def selecciona_un_columna(data): #5.-aqui estoy armando un dictionary con un pais especifico
country_dict = {}
country_dict01 = {}
for d in data:
if d[‘Continent’] == ‘South America’:
country_dict01 = {d[‘Country’]:d[‘World Population Percentage’] for clave, valor in d.items() if ‘Country’ in clave or clave in ‘World Population Percentage’ } #6.-aqui estoy armando
country_dict.update(country_dict01)

return country_dict

A esta funcion le envio la lista de diccionario, y por cada diccionario fui haciendo la seleccion de pais, porcentaje, una vez que lo seleccione se lo voy agregando a un nuevo diccionario, para asi formar el total, para luego graficarlo

Comparto mi solución, en la que añadí el aporte del filtro de países por continente para mejorar la visualización de la gráfica. Excelente reto!!!

import read_csv
import charts

def world_population_percentage():
  data = read_csv.read_csv('./App/data.csv')
  data = list(filter(lambda x : x['Continent'] == 'Asia', data))
  country_name = list(map(lambda x : x['Country/Territory'], data))
  for country in data:
    world_population = list(map(lambda x : float(x['World Population Percentage']), data))
    iterable = list(zip(country_name, world_population))
    world_dict = {key: value for key, value in iterable}
    labels = world_dict.keys()
    values = world_dict.values()
  return labels, values

def run():
  labels, values = world_population_percentage()
  charts.generate_pie_chart(labels, values)


if __name__ == '__main__':
  run()

En este reto creé un nuevo fichero y una nueva función que permita ver las columnas disponibles para que puedan ser seleccionadas por un usuario:

import read_csv
import charts

def select_column():
  data = read_csv.read_csv('./app/data.csv')
  
  columns = data[0].keys()
  
  for column in columns:
    print(column)
  
  column_choice = input('Type the column name: ')

Dentro de la misma función se intenta seleccionar la columna para armar un diccionario con el país y los datos de la columna seleccionada, para luego retornar las llaves y valores; en caso la columna no exista retornará None:

  try: 
    data_column = {row['Country/Territory']:row[column_choice] for row in data}

    keys = data_column.keys()
    values = data_column.values()
    
    return keys, values
    
  except KeyError:
    print('Has escrito mal la columna o no existe')
    return None, None

Al llamar la función agrego una condición para crear una gráfica solo si existen los datos:

if __name__ == '__main__':
  labels, values = select_column()
	if labels != None:
  	charts.generate_pie_chart(labels, values)

Se podría mejorar la selección usando índices en vez de escribir la palabra, así habría menos probabilidad de errores 😊

Y este es mi archivo main-py:

import utils
import read_csv
import charts


def run():
  data = read_csv.read_csv('python 102\\app_readcsv\\data.csv')
  continents = set(country['Continent'] for country in data)
  # print(list(continents))
  continent_name = input(f"Ingresa el continente que deseas filtrar {continents}: ")
  result = utils.population_by_continent(data, continent_name)
  # print(result)
  labels, values = utils.get_population_percentages(result)
  # print(labels, values)
    
#   charts.generate_bar_chart(labels, values)
  charts.generate_pie_chart(labels, values)


if __name__ == '__main__':
  run()

Les comparto mi archivo utils-py:

def get_population_percentages(filtered_data):
    population_percentages = {}
    for country in filtered_data:
        population_percentages[country['Country']] = country['World Population Percentage']
    labels = population_percentages.keys()
    values = population_percentages.values()
    return labels, values

def population_by_continent(data, continent_name):
    try:  
        filtered_data = [continent for continent in data if continent['Continent'] == continent_name]
        if len(filtered_data) == 0:
            raise ValueError('No se encontraron países en ese continente')
    except ValueError as error:
        print(str(error))
        exit()
    return filtered_data 

Bueno. La siguiente fue mi solucion:
Esta fue la funcion que creé:

def world_percentage(data):
    wpp = {}
    for i in data:
        for k,v in i.items():
            if k == 'World Population Percentage':
                name_country = i['Country/Territory']
                wpp[f'{name_country} %'] = v
    return wpp.keys(),wpp.values()   

Y de esta manera generé el resultado en el archivo main:

country_labels, country_values = utils.world_percentage(data)
   
charts.generate_pie_chart(country_labels,country_values)

Mi solución para mostrar solo los primeros 10 paises más poblados:

import app.charts as charts
import app.read_csv as csvhelper


def generate_world_population_chart():
    path = "./platzi-curso-2-backend/app/data.csv"
    countries = csvhelper.read_csv(path)

    # 1st way
    world_population = dict(map( lambda country: (country["Country/Territory"], country["World Population Percentage"]), countries ))
    population_sorted = {k: v for k, v in sorted ( world_population.items(), key = lambda item : item[1], reverse=True ) }
    labels, values = list(population_sorted.keys()) , list(population_sorted.values())

    # 2nd way
    # labels = list( map( lambda country: country["Country/Territory"], countries ) )
    # values = list( map( lambda country: country["World Population Percentage"], countries ) )

    charts.generate_pie_chart(values=values[0:11], labels=labels[0:11])


if __name__ == "__main__":
    generate_world_population_chart()

Bueno esta vez me llevo solo 1 hora mas o menos. Aunque la gráfica salio un tanto xd. Pero se logro que es lo importante.

Y aquí el código de como lo hize.

""" Realiza un programa que grafique el World Population percentage """

import csv
import matplotlib.pyplot as plt

def get_list_countries_dict(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 get_labels(list_countries_dict):
    list_labels = []
    for country_dict in list_countries_dict:
        list_labels.append(country_dict["Country/Territory"])
    return list_labels

def get_values(list_countries_dict):
    list_values = []
    for country_dict in list_countries_dict:
        list_values.append(float(country_dict["World Population Percentage"]))
    return list_values

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

if __name__ == "__main__":
    list_countries_dict = get_list_countries_dict("./27_Leer_Archivos_CSV/data.csv")
    list_labels = get_labels(list_countries_dict)
    list_values = get_values(list_countries_dict)
    Generar_Grafica_Pie(list_labels, list_values)

Les comparto el reto superado y la visualización. La misma tiene muchas etiquetas para un pie chart, por eso no se aprecian las mismas. Pero el objetivo está cumplido:

# Seleccionar solo los paises como clave y la World Population Percentage
# como valor y hacer un pie con ello.

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

def generate_pie_chart(labels, values):
    fig, ax = plt.subplots()
    ax.pie(values, labels=labels)
    ax.axis('equal')
    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','World Population Percentage')}
            data.append(country_dict)
        return data
    
def do_list(list_dict):
    labels = []
    values = []
    for dict in list_dict:
        labels.append(dict["Country/Territory"])
        values.append(dict["World Population Percentage"])
    return labels, values
    
if __name__ == '__main__':
    data = read_csv('./world_population.csv')
    labels, values = do_list(data)
    generate_pie_chart(labels= labels, values= values)

Resultado:

Este aún más fácil, aunque la verdad me complique tratándolo de hacer con comprenhesión jajaja… pero bueno, reto solucionado, me gustó… 😃

from read_csv import read_csv
from charts import generate_pie_chart


def world_population():
    all_country = read_csv("./app/data.csv")
    
    filter_countries = filter(lambda x:x['Continent']=='South America',all_country)
    population_countries = {}
    for country in filter_countries:   
        print(country)
        population_countries[country['Country/Territory']]=country['World Population Percentage']
                
    return population_countries.keys(), population_countries.values()


if __name__ == "__main__":
    keys,values = world_population()    
    generate_pie_chart(keys, values)
    

1 Archivo

<def runColumna():
  reader,header=retoProyecto.read_csv2("data.csv")
  list=retoProyecto.ubicarPosicionColumnaDinamica(header,"World Population Percentage")
  header2,row2=retoProyecto.ObtenerNewRowHeader(reader,list)
  charts.generate_pie_chart(header2,row2)> 

–2 Archivo

<def read_csv2(path):
  with open(path, 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=",") 
    header = next(reader)
    data = [row for row in reader] #Para que no se cierre el archivo reader al pasar como parametro a ObtenerNewRowHeader
    return data,header

def ubicarPosicionColumnaDinamica(header,nombreColumna):
  cont = 0
  list = []
  for  element in header:
      if(nombreColumna in element):
        list.append(cont)
        return list
      cont = cont + 1
  

def ObtenerNewRowHeader(reader,list):
  i = 0
  header2 = []
  row2 = []
  for row in reader:
      if(row[4]=="South America"):
        header2.append(row[2])
        row2.append(row[list[i]])
        print(row[2])
        i = i + 1
      i = 0
  return header2,row2> 

Cree un programa donde puedes graficar el crecimiento de la poblacion de un paise que tu selecciones o crear un grafico de torta con el porcentaje que representa la poblacion de paises que sea superior al 0.5% mundial o el porcentaje de la poblacion que representan todos los paises de un contiente de un pais ingresado. Intente hacer el codigo lo mas escalable y conciso posible, agradezco si me dan su retroalimentacion
PD: Me apoye de Bing para crear ese proyecto, pero siempre guiado y estructurado por mi
Dale clic aqui

Saludos, comparto mi solución al reto:

def getDataByColumn(data, colLabel, colValue):
  # define column dict
  colDict = dict()
  # loop data
  for item in data:
    # if item have [colLabel] and [colValues] keys
    if (item[colLabel] and item[colValue]):
      colDict[item[colLabel]] = item[colValue]
  return colDict

Yo decidí definir una función para obtener un diccionario donde los países sean claves y el porcentaje, valor.

def get_pop_percentage(data):
percentage = {}
for row in data:
key = row[‘Country/Territory’]
value = row[‘World Population Percentage’]
percentage.update({key:value})
return percentage

Luego defino labels,values = percentage.keys(), percentage.values()
y paso esas variables a mi funcion gen_pie_chart

import read_csv
import charts

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

labels = [country['Country/Territory'] for country in data]
values = [country['World Population Percentage'] for country in data]

charts.generate_pie_chart(labels, values)

Lo resolví fácilmente en main, con Pandas…

def percentage_world():
    
    data = pd.read_csv('./app/world_population.csv', sep=',')
    countries = data['Country/Territory']
    percentage = data['World Population Percentage']
    
    charts.generate_pie_chart(countries, percentage)

Buenas, yo djeo mi aporte, es unas lineas mas, pero interesante, tenes que elegir entre mundial [W] o continente [C] y luego en mundial tira el grafico de la poblacion mundial mientras que en el continente te pregunta nuevamente que continente queres, lo dejo abajo el cod.

import utilis
import read_csv
import charts

def run():
  x = input('World [W] o Country[C] ==> ')
  if x == 'W':
    data = read_csv.read_csv('./world_population.csv')
  else:
    pais = input('ingrese Continente...')
    data = list(filter(lambda item : item['Continent'] == pais,data))

  countries = list(map(lambda x: x['Country/Territory'], data))
  percentages = list(map(lambda x: x['World Population Percentage'], data))
  charts.generate_pie_chart(countries, percentages)
  '''
  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)
  '''

if __name__ == '__main__':
  run()

para el utilities use el cual obtiene un diccionario fuiltrado por continente y en el accede a la columna de pais y porcentaje de la poblacion mundial

def get_population(dict_pais):
    population_dict = {
        pais['Country/Territory']: float(pais['World Population Percentage']) for pais in dict_pais
        
    }
    keyes = population_dict.keys()
    values = population_dict.values()
    return keyes, values

def population_by_country(country, data):
    result = list(filter(lambda cosa:  cosa['Continent'] == country, data ))
    #print(result)
    return result

para el main use el input para leer por continente

import utils
import leer_csv as lcsv
import charts


def run():
    data = lcsv.leer_csv('./app/world_population.csv')
    pais = input('Escriba un continente => ')
    poblacion = utils.population_by_country(pais, data )
    
    
    keyes, values = utils.get_population(poblacion)
        # print(keyes, values)
    charts.generate_pie_chart(keyes, values)
# esta liena de codifo con el if es para que se ejecute el modulo sin necesidad de llamaarlo por medio de otra funcion.
if __name__ =='__main__':
        run()
# -------------------------------------------

Mi código:

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
continente = input('Type continent name: ')

try:
    df3 = df2[df2['Continent'] == continente] #Filtrar por continente
    world_ppl_per = df3['World Population Percentage'] #Extraer la columna que necesitamos

    labels = world_ppl_per.index.tolist() #Convertir el índice (países) a una lista
    sizes = world_ppl_per.tolist() #Convertir la columna World Population Percentage en una lista

    fig, ax = plt.subplots()
    ax.pie(sizes, autopct='%1.1f%%')
    ax.axis('equal')
    ax.legend(labels=labels, loc = 'center left', ncol=2)
    plt.title('Población mundial por país (%)')
    plt.subplots_adjust(bottom=0.1, left = 0.1) #ajustar el margen para no cortar las labels
    fig.set_size_inches(19, 9.5)
    plt.show()

except KeyError as error:
    print('Please write the country name correctly')

Esta fue mi solución

world_population_per = [float(i['World Population Percentage']) for i in data]
print("values", world_population_per)

countries = [i['Country/Territory'] for i in data]
print("labels", countries)

Yo mandé esta :

def run():
  data = read_csv.read_csv('./app/data.csv')
  
  list_porcentages = []
  list_countries = []
  for i in data:
    porcentage = i['World Population Percentage']
    list_porcentages.append(porcentage)
    name = i['Country/Territory']
    list_countries.append(name)    

  charts.generate_pie_chart(list_countries, list_porcentages)

Trbajando el archivo csv como un dataframe, todo se resuelve mas facil. La forma que lo hace el profesor no esta mal, pero no es la mas eficiente

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('/home/coderdav/personalprojects/python-intermediate/app/data.csv')
selected_column = 'World Population Percentage'
data = df[selected_column]
value_counts = data.value_counts()

plt.pie(value_counts, wedgeprops={'linewidth': 1, 'edgecolor': 'white'})
plt.title('Pie chart of {}'.format(selected_column))
plt.show()

Este reto se me facilito mas que el anterior, aquí dejo mi aporte de como lo solucione.

import read_csv as read
import charts as ch

data = read.read_csv('./app/data.csv')
country = list(map(lambda item: item['World Population Percentage'], data))
# print(country)
countries = list(map(lambda item: item['Country/Territory'], data))
# print(countries)
percentage = list(map(lambda item: float(item), country))
# print(percentage)

ch.generate_pie_chart(countries, percentage)

Agregue una funcion mas al codigo anterior, cualquier cosa me preguntan, Saludos!

import csv
import matplotlib
matplotlib.use(‘TkAgg’,force=True)
import matplotlib.pyplot as plt
print(“Switched to:”,matplotlib.get_backend())

def read_csv(path):
with open(path, ‘r’) as csv_file:
reader = csv.reader(csv_file, delimiter = ‘,’)
header = next(reader)
data = []
for row in reader:
iterable = zip(header, row)
data_dict = {key: value for key, value in iterable}
data.append(data_dict)
return data

def find_country(country, data):
#selection = []
#for i in data:
# if i[‘country’] == country:
# selection.append[i]
selection = [i for i in data if i[‘Country/Territory’] == country]
return(selection)

def chart_population(country_info):
fig, ax = plt.subplots()
labels = [k for k in country_info[0].keys() if (k.startswith(‘19’) or k.startswith(‘20’))]
labels.sort()
values = []
for i in labels:
values.append([v for k,v in country_info[0].items() if k == i][0])
labels = [i.split()[0] for i in labels]
ax.bar(labels, values)
plt.xlabel(‘Año’)
plt.ylabel(‘Ciudadanos’)

def char_porcentage_population(data):
labels = [i[‘Country/Territory’] for i in data]
values = [i[‘World Population Percentage’] for i in data]
fig2, ax2 = plt.subplots()
ax2.pie(values, labels = labels)
ax2.set_title(‘Pie Chart’)
ax2.axis(‘equal’)

if name == ‘main’:
country = 'Argentina’
path = './proyecto/world_population.csv’
data = read_csv(path)
country_info = find_country(country, data)
chart_population(country_info)
char_porcentage_population(data)
plt.show()

Siguiendo la línea de filtros intenté buscar aquellos países cuya población representa más o igual que el 2% de la población mundial.

import matplotlib.pyplot as plt
import csv


def get_plot(VALUES, LABELS):
    figure, axes = plt.subplots()
    axes.pie(VALUES, labels=LABELS)
    axes.axis("equal")
    plt.suptitle(f'Gráfica de la población mundial')
    plt.show()


def read_csv(DATASET):
    with open(DATASET, "r") as file:
        reader = csv.reader(file, delimiter=",")
        header = next(reader)
        countries = []
        for line in reader:
            iterable = zip(header,line)
            country_data = {key: val for key, val in iterable}
            countries.append(country_data)
        return countries


def run():
    DATA = "./world_population.csv" #CSV from Kaggle https://www.kaggle.com/datasets/iamsouravbanerjee/world-population-dataset
    countries = list(filter(lambda x: float(x["World Population Percentage"]) >= 2 ,read_csv(DATA)))
    #print(countries[0])
    value, label = [],[]
    for country in countries:
        label.append(country["Country/Territory"])
        value.append(float(country["World Population Percentage"]))    
    #print(list(zip(label,value)))
    get_plot(value,label)


if __name__ == "__main__":
    run()

La verdad que me sorprendió que me quede tan parecido al profe.
Solo que para no mezclar los archivos cree un nuevo .py y a la carpeta app le agregue el “init.py” para poder impotarla como modulo y usarla.

import app

def run():
  data = app.read_csv.read_csv('./app/data.csv')
  perc = app.utils.population_by_column(data, 'World Population Percentage')
  countries = app.utils.population_by_column(data, 'CCA3')
  app.charts.generate_pie_chart(countries, perc)

if __name__ == '__main__':
  run()

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

df = pd.read_csv("/content/world_population.csv")
data = df[["Country/Territory","World Population Percentage"]]

plt.pie(data['World Population Percentage'],labels=data['Country/Territory'])
plt.show()

Lo hice de esta manera:

from reto32_read_csv import read_csv
import reto32_bar_chart as bc
if __name__ == '__main__':
    data = read_csv('./world_population.csv')
    paises = list(map(lambda columna : columna['Country/Territory'], data))
    wpp    = list(map(lambda columna : float(columna['World Population Percentage']),data))
    print(paises)
    print(wpp)
    bc.generate_pie_chart(paises, wpp)

Aqui está mi solucion usando comprehensions

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 generata_data(dict_country):
    labels_years = [key[:5] for key, value in dict_country.items() if key[5:] == 'Population']
    values_years = [round(int(value)) for key, value in dict_country.items() if key[5:] == 'Population']

    labels_years = labels_years[::-1]
    values_years = values_years[::-1]
    generate_bar_chart(labels_years, values_years)

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()
  
def generate_bar_data(big_list):
  labels_percentages = [elem['Country/Territory'] for elem in big_list]
  values_percentages = [elem['World Population Percentage'] for elem in big_list]
  generate_pie_chart(labels_percentages, values_percentages)

if __name__ == '__main__':
    data = read_csv('./app/data.csv')
    print(data[0])
    '''
    country = input()
    for elem in data:
        if elem['Country/Territory'] == country:
            generata_data(elem)
            break
    '''
    
    new_data = [elem for elem in data if elem['Continent'] == "South America"] 
    generate_bar_data(new_data)

#Reto: graficando la población mundial
import csv
import matplotlib.pyplot as plt

def read_csv(path):
    with open(path, 'r') as csvfile:
        ds = csv.reader(csvfile, delimiter = ',')
        ds_header = next(ds) #leer la primera  fila que son los nombres
        data = []
        for row in ds:
            iterable = zip(ds_header, row)
            country_dict = {key: value for key, value in iterable}
            data.append(country_dict)
        return data
    
def filter_row(dic_data):
    dic_data_ds = dic_data.copy()
    percentage = []
    countrys = []
    for x in dic_data_ds:
        percentage.append(x['World Population Percentage'])
        countrys.append(x['Country/Territory'])
    return percentage, countrys

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

if __name__ == '__main__':
    data = read_csv('./world_population.csv')
    row_filter = filter_row(data)
    x, y = row_filter
    generar_grafica(y,x)

Hola, esta fue la solución que encontré para el reto 😃

def country_codes_and_world_pop(data):
    c_codes = [] 
    world_pop =[] 
    for dictionaries in data:        
        #labels serán los codigos de los paises
        c_codes.append(dictionaries["CCA3"])
        # los valores de la grafica serán los porcentajes de poblacion mundial
        world_pop.append(dictionaries["World Population Percentage"])
  
    codes = c_codes
    world_population = world_pop
    return codes , world_population

Hola!

Les comparto el código del curso.

# Importamos el modulo
import utils
import read_csv
import charts

def run():
  data = read_csv.read_csv('./app/world_population.csv')
  
  '''
  # Reto: graficando la población de un país
  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)
  '''

  # Reto: graficando la población mundial
  data = list(filter(lambda item: item["Continent"] == "South America", data))
  countries = list(map(lambda x: x["Country/Territory"], data))  
  percentages = list(map(lambda x: x["World Population Percentage"], data))

  charts.generate_pie_chart(countries, percentages)
  
# 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()

Mi solución 😄

import csv
import matplotlib.pyplot as plt

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

    for row in reader:
      iterable = zip(header, row)
      country_dict = {key: value for key, value in iterable if  'World Population Percentage' in key or 'Country/Territory' in key}
      data_natural.append(country_dict)
    return data_natural

def process_data(data):
  countries = [] 
  wpp = []
  
  for dict in data:
    for key, value in dict.items():
      if 'Country/Territory' in key:
        countries.append(value)
      if 'World Population Percentage' in key:
        wpp.append(value)

  iterable = zip(countries, wpp)
  new_data = {key: value for key, value in iterable }
  
  return new_data

def pie_chart(data):
  countries = data.keys()
  wpp = data.values()
  fig, ax = plt.subplots()
  ax.pie(wpp, labels=countries)
  ax.axis('equal')
  plt.show()

if __name__ == '__main__':
  data = read_csv('./app/data.csv')
  wpp = process_data(data)
  pie_chart(wpp)

mi solución:

def joder():
  with open('app/world_population.csv','r') as data:
    reader = csv.reader(data)
    header = next(reader)
    column_to_read = input("qué columna pa => ")
    country_names = []
    column = []
    country_column = []
    for row in reader:
      codict_names = dict() # dict vacío
      codict = dict()
      for i, j in zip(header, row):
        if "Country/Territory" in i:
          codict_names[i] = j
          country_names.append(j)
      for i, j in zip(header, row):
        if column_to_read in i:
          codict[i] = j
          column.append(j)
    country_column_zip = list(zip(country_names, column))
    country_column_dicts = {i: j for i, j in country_column_zip}
    country_column.append(country_column_dicts)
    print(country_column)
    

joder()

usé una de las soluciones en los primeros comentarios de la clase pasada y la modifiqué

Solución Propuesta:

def porcentaje_poblacion_mundial(datos,continente):
  # List comprehensions
  datos = list(filter(lambda x : x['Continent'] == continente,datos))
  valores= [float(i['World Population Percentage']) for i in datos ]
  labels = [i['Country/Territory'] for i in datos ]
  graficas.grafico_torta(labels,valores)

Excelente , gracias

MI aporte introduciendo el continente:

<import utils
import charts
import read_csv

#Preguntando el continente
def run():
  data = read_csv.read_csv("./app/data.csv")
  continent = input("Digite el continente: ")
  continent = continent.title()
  data = list(filter(lambda x : x["Continent"] == continent, data ))
  country = list(map(lambda x: x ["Country/Territory"],data))
  percentage = list(map(lambda x: x["World Population Percentage"], data))
  charts.generate_pie_chart(country, percentage )
if __name__ == "__main__":
  run()> 

Esta es mi solución

import matplotlib.pyplot as plt
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

def run():  
  # read_csv
  data = read_csv('/Users/CL/Documents/phyton/python/data.csv')
  #filter by continent
  result= list(filter(lambda item:item["Continent"] == "South America",data))
  #filter by conuntry
  labels= [item["CCA3"] for item in result]
  #filter by World population percentage
  values=[float(item["World Population Percentage"]) for item in result]
  
  return values,labels

if __name__ == '__main__':
  values,labels=run()

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

Dejo mi aporte.

def world_population_per(data):
  percentage = {item["Country/Territory"]: item["World Population Percentage"] for item in data if item["Continent"] == "South America"}
  labels = percentage.keys()
  values = percentage.values()
  return labels, values

Para este reto hice una nueva funcion que recibiera el csv y con dict comprehension filtrar los datos necesarios para realizar la grafica, adicionando una condicional en el cual solo me graficara los paises de Sudamerica.

import matplotlib.pyplot as plt 

with open('data.csv', 'r', encoding='cp1252') as f:
    header = list(next(f).strip().split(','))   # sobre el método readline del objeto file
    
    DATA = []
    for line in f.readlines():  # método readlines del objeto file
        DATA.append(dict(zip(header, line.strip().split(','))))

    values = [float(data['World Population Percentage']) for data in DATA if data['Continent'] == 'South America']
    
    labels = [data['Country/Territory'] for data in DATA if data['Continent'] == 'South America']

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

La puse hace dos clase pero aquí está de nuevo, los índices en LATAM

import csv 
import matplotlib.pyplot as plt 
from char import generate_pie_char  #importé el programa que habiamois hecho previamente 

def read_percent(path):
    with open(path, 'r') as csvfile:
        reader = csv.DictReader(csvfile)
        percent = [float(row['World Population Percentage']) for row in reader]
        return percent 
        
def read_country(path):
    with open(path,'r') as csvfile:
        reader = csv.DictReader(csvfile)
        country = [row['Country/Territory'] for row in reader]
        return country
        


if __name__ == '__main__':
    lables = read_country('6_leer_archivos\\app\\data.csv')
    values = read_percent('6_leer_archivos\\app\\data.csv')

    print(lables)
    print(values)

    generate_pie_char(lables, values )
    

import utils
import read_csv
import charts

def run():
data = read_csv.read_csv(’./app/data.csv’)
return data

if name == ‘main’:
data = run()
countries = list(map(lambda x: x.get(‘Country’), data))
porcentajes = list(map(lambda x: x.get(‘World Population Percentage’, 0), data))
charts.generate_pie_chart(countries, porcentajes)

import pandas as pd
import matplotlib.pyplot as plt
data = pd.read_csv(“data.csv”)
continente = "South America"
columnas = [“Country”,“World Population Percentage”, “Continent”]
data = data.loc[data.Continent==continente,columnas]
plt.pie(data[“World Population Percentage”], labels=data.Country,labeldistance=1.2, radius=2)
plt.show()

Esta es la función que cree para obtener los datos, decidí no utilizar map para no iterar por los mismos datos dos veces

def get_worl_population_percentage(data):
  labels = []
  values = []
  for row in data:
    labels.append(row["Country/Territory"])
    values.append(float(row["World Population Percentage"]))

  return labels, values