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

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

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

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

Todo esto lo puedo hacer con excel lol

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
.

Se me ocurrió una forma más automática de mantener todas las funcionalidades y solicitar la información al usuario

# charts.py
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()

#utils.py
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

def get_percent_all_countries(data):
    labels = []
    values = []
    for country in data:
        labels.append(country['Country/Territory'])
        values.append(country['World Population Percentage'])
    return labels, values

def get_population_by_continent(data, continent):
    labels = []
    values = []
    data = list(filter(lambda item: item['Continent'] == continent, data))
    for country in data:
        labels.append(country['Country/Territory'])
        values.append(country['2022 Population'])
    return labels, values

# main.py
import utils
import read_csv
import charts

def run():
    data = read_csv.read_csv('./world_population.csv')
    print('1. - Search a country')
    print('2. - World Population Percentage')
    print('3. - Countries Population by continent')
    
    option = int(input('Choose an option => '))
    if option == 1:
        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)
    elif option == 2:
        labels, values = utils.get_percent_all_countries(data)
        charts.generate_pie_chart(labels, values)
    elif option == 3:
        print('a) Africa')
        print('b) Asia')
        print('c) Europe')
        print('d) North America')
        print('e) South America')
        print('f) Oceania')
        option = input('Choose an option => ').lower()
        if option == 'a':
            labels, values = utils.get_population_by_continent(data, 'Africa')
            charts.generate_pie_chart(labels, values)
        elif option == 'b':
            labels, values = utils.get_population_by_continent(data, 'Asia')
            charts.generate_pie_chart(labels, values)
        elif option == 'c':
            labels, values = utils.get_population_by_continent(data, 'Europe')
            charts.generate_pie_chart(labels, values)
        elif option == 'd':
            labels, values = utils.get_population_by_continent(data, 'North America')
            charts.generate_pie_chart(labels, values)
        elif option == 'e':
            labels, values = utils.get_population_by_continent(data, 'South America')
            charts.generate_pie_chart(labels, values)
        elif option == 'f':
            labels, values = utils.get_population_by_continent(data, 'Oceania')
            charts.generate_pie_chart(labels, values)
        else:
            print('Invalid option... exiting')
        print(option)
    else:
            print('Invalid option... exiting')
        
        
if __name__ == '__main__':
    run()

reto solucionado

Agregué dos líneas al if en main

y a ultils le agregué esta función

Mi aporte:

import csv
import matplotlib.pyplot as plt

def open_csv():
    with open('./world_population.csv', 'r') as file:
        reader = csv.reader(file, delimiter=',')
        header = next(reader)
        result = []
        for row in reader:
            response = list(zip(header, row))
            response = dict(response)
            result.append(response)
        return result

def get_populations():
    data = open_csv()
    population = []        
    for raw in data:
        population.append(
            [
                raw['Country/Territory'], float(raw['World Population Percentage']),
            ]
        )

    return population

def generate_pie_chart(population):
    labels = []
    values = []
    for country, value in population:
        labels.append(country)
        values.append(value)
    print(labels)
    print(values)
    fig, ax = plt.subplots()
    ax.pie(values, labels=labels, autopct='%1.1f%%', shadow=True, startangle=90)
    ax.axis('equal')
    plt.show()


if __name__ == '__main__':
    generate_pie_chart(get_populations())

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

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