Introducci贸n

1

El Zen de Python

Conjuntos

2

Sets

3

Modificando conjuntos

4

Operaciones con conjuntos

5

Playgrounds: Elimina elementos duplicados usando conjuntos

Comprehensions

6

List Comprehension

7

Dictionary Comprehension

8

Dictionary Comprehension: condition

9

Playgrounds: Crea una lista usando List Comprehension

10

Lists vs. Tuples vs. Sets

Funciones

11

Funciones

12

Funciones: return

13

Par谩metros por defecto y m煤ltiples returns

14

El scope

15

Refactor game

16

Playgrounds: Tienda de Tecnolog铆a

17

Funciones an贸nimas: lambda

18

Higher order function: una funci贸n dentro de otra funci贸n

19

Map

20

Map con diccionarios

21

Reto: map con inmutabilidad

22

Playgrounds: Multiplica todos los elementos por dos

23

Filter

24

Playgrounds: Retorna solo palabras de 4 letras y m谩s

25

Reduce

M贸dulos

26

M贸dulos

27

Mis propios m贸dulos

28

M贸dulos como scripts: __name__ y __main__

29

Paquetes

30

Playgrounds: Calcular la suma de todas las compras

Manipulaci贸n de archivos y errores

31

Iterables

32

Errores en Python

33

Manejo de excepciones

34

Playgrounds: Captura la excepci贸n: ZeroDivisionError

35

Leer un archivo de texto

36

Escribir en un archivo

37

Leer un CSV

38

Playgrounds: Lee un CSV para calcular el total de gastos

Gr谩ficas en Python

39

Creando una gr谩fica

40

Reto: graficando la poblaci贸n de un pa铆s

41

Reto: graficando la poblaci贸n mundial

Pr贸ximos pasos

42

隆Conoce otros proyectos de este curso!

43

Reconoce tu proceso y certif铆cate

44

Toma el Curso de PIP y Entornos Virtuales con Python

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Reto: graficando la poblaci贸n mundial

41/44
Recursos

Aportes 163

Preguntas 6

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥楥ountry鈥 por 鈥楥ountry/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
.

Es interesante lo facil que se trabaja con estas funciones para el analisis de datos, agregue un par de filtros, ordene y acote la lista para apreciar mejor los graficos ![](https://static.platzi.com/media/user_upload/image-37127fe1-2d83-4264-b933-9807aebe3bad.jpg) ![](https://static.platzi.com/media/user_upload/image-604c67a7-c808-4ad2-8d50-b13cb8bd5ccb.jpg)
Les comparto la forma en que yo lo realic茅, no agregu茅 ning煤n filtro, por eso los pa铆ses se ven as铆 de amontonados. les comparto el codillo tambi茅n en mi repositorio de GitHub: <https://github.com/LuisSantiago7/porcentaje_world_population> ![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202023-11-30%20a%20la%28s%29%203.48.41%E2%80%AFp.m.-1ea1025d-b580-492d-9fc2-f94b034cb4b7.jpg) ```js ###main.py import charts import read_csv if __name__ == '__main__': labels, values = read_csv.obtain_porcentage_world('PROYECTO DE PORCENTAJE MUNDIAL/world_population.csv') charts.generate_charts_pie(labels, values) ###charts.py import matplotlib.pyplot as plt def generate_charts_pie(labels, values): fig, ax = plt.subplots() ax.pie(values, labels=labels) ax.axis('equal') plt.show() ###read_csv.py import csv def obtain_porcentage_world(path): with open(path, 'r') as csvFile: reader = csv.DictReader(csvFile, delimiter = ',') country_porcentage_world = {} country_names = [] for row in reader: country = row['Country/Territory'] porcentage = float(row['World Population Percentage']) country_names.append(country) country_porcentage_world[country] = porcentage country_porcentage_world = dict(zip(country_names, country_porcentage_world.values())) return country_porcentage_world.keys(), country_porcentage_world.values() ```
buen dia campeon. satisfecho con el reto, \[repo github]\(https://github.com/brunomaldonado/World-Demographics "repo github") ![](https://static.platzi.com/media/user_upload/Screenshot%202023-11-24%20at%208.52.08%E2%80%AFPM-762e22e9-ddea-490d-8912-ed5e88101af7.jpg) ... mi solucion... ```js def generate_pie_chart(data, continent_): fig, ax = plt.subplots(figsize=(9, 6)) # world_population_percentage = [] # territories = [] population_percentage = [] countries = [] for idx, world_percentage in enumerate(data): percentage_ = world_percentage['World Population Percentage'] # world_population_percentage.append(percentage_) country = world_percentage['Country/Territory'] # territories.append(country) if world_percentage['Continent'] == str(continent_): # 'Asia' countries.append(world_percentage['Country/Territory']) population_percentage.append(world_percentage['World Population Percentage']) percentages = list(map(float, population_percentage)) percentage_continent_countries = {'Asia': 10, 'Europe': 12, 'Africa': 19, 'South America': 10, 'North America': 8, 'Oceania': 5} for key, value in percentage_continent_countries.items(): if key == str(continent_): top_countries = value explode_2d = [0.05] + [0] * (top_countries - 1) sorted_data = sorted(zip(percentages, countries), reverse=True) values, labels = zip(*sorted_data[:top_countries]) ax.pie(values, labels=labels, autopct='%1.1f%%', explode=explode_2d) # data = list(filter(lambda item: item['Continent'] == str(continent_), data)) # countries = list(map(lambda x: x['Country/Territory'], data)) # percentages = list(map(lambda x: x['World Population Percentage'], data)) # ax.pie(countries, labels=percentages, autopct='%1.1f%%') ax.axis('equal') continent_ = continent_.replace('Europe', 'European') continent_ = continent_.replace('South America', 'South American') continent_ = continent_.replace('North America', 'North American') continent_ = continent_.replace('Asia', 'Asian') continent_ = continent_.replace('Africa', 'African') plt.title(f"Percentage of population of the countries of the \n{continent_} continent", size=12, weight="bold", fontfamily="sans", color="#080404", horizontalalignment = "left", x=0.12, y=.9, transform = fig.transFigure) plt.legend() plt.show() ```def generate\_pie\_chart(*data*, *continent\_*): fig, ax = plt.subplots(*figsize*=(9, 6)) *# world\_population\_percentage = \[]* *# territories = \[]* population\_percentage = \[] countries = \[] for idx, world\_percentage in enumerate(*data*): percentage\_ = world\_percentage\['World Population Percentage'] *# world\_population\_percentage.append(percentage\_)* country = world\_percentage\['Country/Territory'] *# territories.append(country)* if world\_percentage\['Continent'] == str(*continent\_*): *# 'Asia'* countries.append(world\_percentage\['Country/Territory']) population\_percentage.append(world\_percentage\['World Population Percentage']) percentages = list(map(float, population\_percentage)) percentage\_continent\_countries = {'Asia': 10, 'Europe': 12, 'Africa': 19, 'South America': 10, 'North America': 8, 'Oceania': 5} for key, value in percentage\_continent\_countries.items(): if key == str(*continent\_*): top\_countries = value explode\_2d = \[0.05] + \[0] \* (top\_countries - 1) sorted\_data = sorted(zip(percentages, countries), *reverse*=True) values, labels = zip(\*sorted\_data\[:top\_countries]) ax.pie(values, *labels*=labels, *autopct*='%1.1f%%', *explode*=explode\_2d) *# data = list(filter(lambda item: item\['Continent'] == str(continent\_), data))* *# countries = list(map(lambda x: x\['Country/Territory'], data))* *# percentages = list(map(lambda x: x\['World Population Percentage'], data))* *# ax.pie(countries, labels=percentages, autopct='%1.1f%%')* ax.axis('equal') *continent\_* = *continent\_*.replace('Europe', 'European') *continent\_* = *continent\_*.replace('South America', 'South American') *continent\_* = *continent\_*.replace('North America', 'North American') *continent\_* = *continent\_*.replace('Asia', 'Asian') *continent\_* = *continent\_*.replace('Africa', 'African') plt.title(f"Percentage of population of the countries of the \n{*continent\_*} continent", *size*=12, *weight*="bold", *fontfamily*="sans", *color*="#080404", *horizontalalignment* = "left", *x*=0.12, *y*=.9, *transform* = fig.transFigure) plt.legend() plt.show()
Las list o dict comprehension nunca han sido mi fuerte, la manera en que yo lo solucion茅 fue as铆 en el c贸digo main ```js import utils import read_csv import charts def run(): data=read_csv.read_csv("./app_2/world_population.csv") #print(data) population={} for i in data: #print(utils.world_population(i)) x, y=utils.world_population(i) #print(x,y) population[x]=y #print(population) charts.generate_pie_chart(population.keys(), population.values()) if __name__=="__main__": run() ```y as铆 en el c贸digo utils ```js def world_population(data): for key, value in data.items(): if ("Country/Territory") in key: return value, float(data['World Population Percentage']) ```Espero le sirva a alguien
lo hice de la siguiente forma, cree una funcion que regrese las listas pais porcentaje , para ser usado de la siguiente forma: ![](https://static.platzi.com/media/user_upload/image-b75e805d-89c7-499c-a221-97358e453c40.jpg) y la implementacion de esta funcion es como se ve a continuacion: ![](https://static.platzi.com/media/user_upload/image-29a40856-3c50-436f-8dfc-7a304368fd84.jpg) en cada row , el pais esta en la posicion 2 de la lista y el porcentaje en el 16.

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 鈥渙tros鈥

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])
No mire la solucion del video todavia, pero esta es mi resultado. (casi explota replit xd) ![](https://static.platzi.com/media/user_upload/image-1f96aeaf-5688-4784-ae2a-6938f6cd2521.jpg) ```python def run(): data = read_csv.read_csv('./app/data.csv') countrys = [] values= [] for dict in data: country, value = utils.get_population_percentage(dict) countrys.append(country) values.append(value) print(countrys) charts.generate_pie_chart(countrys,values) ``````js def get_population_percentage(dict_country): country = dict_country['Country'] value = dict_country ['World Population Percentage'] return country,value ```
```js import read_csv import charts data = read_csv.read_csv('./app/data.csv') #column= input("que columna quiere revisar? ") world_population_percentage_list = [] countries_list =[] # Iterar a trav茅s de los diccionarios anidados en la lista 'data' for country_data in data: if 'World Population Percentage' in country_data: world_population_percentage = country_data['World Population Percentage'] world_population_percentage_list.append(world_population_percentage) if 'Country/Territory' in country_data: country_name = country_data['Country/Territory'] countries_list.append(country_name) values = world_population_percentage_list labels = countries_list charts.generate_pie_chart(labels,values) ````import read_csv` `import charts` `data = read_csv.read_csv('./app/data.csv')` `#column= input("que columna quiere revisar? ")` `world_population_percentage_list = []` `countries_list =[]` `# Iterar a trav茅s de los diccionarios anidados en la lista 'data'` `for country_data in data:` ` if 'World Population Percentage' in country_data:` ` world_population_percentage = country_data['World Population Percentage']` ` world_population_percentage_list.append(world_population_percentage)` ` if 'Country/Territory' in country_data:` ` country_name = country_data['Country/Territory']` ` countries_list.append(country_name)` ` ` `values = world_population_percentage_list` `labels = countries_list` `charts.generate_pie_chart(labels,values)`
Con este codigo es f谩cil obtener en una lista los porcentajes y paises `percentage = [x['World Population Percentage'] for x in data]` ` country = [x['Country/Territory'] for x in data]`
Recomiendo el curso : "Introducci贸n al curso computacional". Al final tiene clases sobre el "test" o "Pruebas de caja negra". Puedes ver d贸nde tienes un "bug". Otra es preguntarle a Ada la "I.A, de Platzi"
Realic茅 un reto diferente. Utilic茅 una lista de productos de amaz贸n. Uno de los problemas que tuve era : "convertir una cadena de texto vac铆a en un n煤mero de punto flotante". Esto, cuando al entrar a la lista ten铆a un "$". Ten铆a que quitarlo para que, pudiera leer el precio. Al final me sali贸. No pude agregar la imagen pero, les recomiendo usar : Google Colab (Te puede Graficar r谩pidamente). Lo recomiendo si quieres seguir practicando m谩s. ```js 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) product_dict = {key:value for key, value in iterable} data.append(product_dict) return data if __name__ == "__main__": data = read_csv("/content/amazon_laptop_prices_v01.csv") print(data) ## # ========== # def clean_convert_price(price_str): clean_price = price_str.strip("$ ").replace(",", "") if clean_price == "": return None return float(clean_price) ## ======= ## prices = [clean_convert_price(product["price"]) for product in data] filtered_prices = [price for price in prices if price is not None] plt.bar(range(len(filtered_prices)), filtered_prices) plt.xlabel("Productos") plt.ylabel("Precios") plt.title("Gr谩fico de Precios de Productos") plt.show() ```import csvimport 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)聽 聽 聽 product\_dict = {key:value for key, value in iterable}聽 聽 聽 data.append(product\_dict)聽 聽 return data if \_\_name\_\_ == "\_\_main\_\_":聽 data = read\_csv("/content/amazon\_laptop\_prices\_v01.csv")聽 print(data) 聽 ## # ========== #聽 def clean\_convert\_price(price\_str):聽 聽 clean\_price = price\_str.strip("$ ").replace(",", "") 聽 聽 if clean\_price == "":聽 聽 聽 return None 聽 聽 return float(clean\_price) \## ======= ##聽 prices = \[clean\_convert\_price(product\["price"]) for product in data] 聽 filtered\_prices = \[price for price in prices if price is not None] 聽 plt.bar(range(len(filtered\_prices)), filtered\_prices)聽 plt.xlabel("Productos")聽 plt.ylabel("Precios")聽 plt.title("Gr谩fico de Precios de Productos") 聽 plt.show()
```python 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) product_dict = {key:value for key, value in iterable} data.append(product_dict) return data if __name__ == "__main__": data = read_csv("/content/amazon_laptop_prices_v01.csv") print(data) ## # ========== # def clean_convert_price(price_str): clean_price = price_str.strip("$ ").replace(",", "") if clean_price == "": return None return float(clean_price) ## ======= ## prices = [clean_convert_price(product["price"]) for product in data] filtered_prices = [price for price in prices if price is not None] plt.bar(range(len(filtered_prices)), filtered_prices) plt.xlabel("Productos") plt.ylabel("Precios") plt.title("Gr谩fico de Precios de Productos") plt.show() ```![](https://static.platzi.com/media/user_upload/datas-d4380a17-175b-465c-9d24-36816ff37658.jpg)
Yo, utilic茅 una lista de productos de Amaz贸n: ```python 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) product_dict = {key:value for key, value in iterable} data.append(product_dict) return data if __name__ == "__main__": data = read_csv("/content/amazon_laptop_prices_v01.csv") print(data) ## # ========== # def clean_convert_price(price_str): clean_price = price_str.strip("$ ").replace(",", "") if clean_price == "": return None return float(clean_price) ## ======= ## prices = [clean_convert_price(product["price"]) for product in data] filtered_prices = [price for price in prices if price is not None] plt.bar(range(len(filtered_prices)), filtered_prices) plt.xlabel("Productos") plt.ylabel("Precios") plt.title("Gr谩fico de Precios de Productos") plt.show() ```import csvimport 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)聽 聽 聽 product\_dict = {key:value for key, value in iterable}聽 聽 聽 data.append(product\_dict)聽 聽 return data if \_\_name\_\_ == "\_\_main\_\_":聽 data = read\_csv("/content/amazon\_laptop\_prices\_v01.csv")聽 print(data) 聽 ## # ========== #聽 def clean\_convert\_price(price\_str):聽 聽 clean\_price = price\_str.strip("$ ").replace(",", "") 聽 聽 if clean\_price == "":聽 聽 聽 return None 聽 聽 return float(clean\_price) \## ======= ##聽 prices = \[clean\_convert\_price(product\["price"]) for product in data] 聽 filtered\_prices = \[price for price in prices if price is not None] 聽 plt.bar(range(len(filtered\_prices)), filtered\_prices)聽 plt.xlabel("Productos")聽 plt.ylabel("Precios")聽 plt.title("Gr谩fico de Precios de Productos") 聽 plt.show()

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 import matplotlib.pyplot as plt \# Leer el archivo CSV with open('world\_population.csv') as f: reader = csv.reader(f) header = next(reader) data = \[] for row in reader: data.append(row) \# Obtener la poblaci贸n mundial total sumando las poblaciones de todos los pa铆ses world\_pop = 0 for row in data: world\_pop += int(row\[5]) print("Poblaci贸n mundial total:", world\_pop) \# Graficar los 10 pa铆ses m谩s poblados top10\_countries = sorted(data, key=lambda x: int(x\[5]), reverse=True)\[:10] pops = \[int(country\[5]) for country in top10\_countries] countries = \[country\[2] for country in top10\_countries] plt.bar(countries, pops) plt.title("10 Pa铆ses M谩s Poblados") plt.ylabel("Poblaci贸n (millones)") plt.show() \# Graficar los continentes por porcentaje de poblaci贸n mundial continents = {} for row in data: cont = row\[3] pop = int(row\[5]) if cont in continents: continents\[cont] += pop else: continents\[cont] = pop sizes = \[pops/world\_pop\*100 for pops in continents.values()] labels = list(continents.keys()) plt.pie(sizes, labels=labels, autopct='%1.1f%%') plt.title("Poblaci贸n Mundial por Continente") plt.show()
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(鈥榚qual鈥)
plt.show()

if name == 鈥main鈥:
data = re.read_csv(鈥./app/data.csv鈥)
labels = list(map(lambda item: item[鈥楥ountry/Territory鈥橾, data))
values = list(map(lambda item: item[鈥榃orld 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 = {鈥榗osas鈥 : 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[鈥楥ontinent鈥橾 == 鈥楽outh America鈥:
country_dict01 = {d[鈥楥ountry鈥橾:d[鈥榃orld Population Percentage鈥橾 for clave, valor in d.items() if 鈥楥ountry鈥 in clave or clave in 鈥榃orld 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[鈥楥ountry/Territory鈥橾
value = row[鈥榃orld 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(鈥楾kAgg鈥,force=True)
import matplotlib.pyplot as plt
print(鈥淪witched to:鈥,matplotlib.get_backend())

def read_csv(path):
with open(path, 鈥榬鈥) 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[鈥榗ountry鈥橾 == country:
# selection.append[i]
selection = [i for i in data if i[鈥楥ountry/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(鈥楢帽o鈥)
plt.ylabel(鈥楥iudadanos鈥)

def char_porcentage_population(data):
labels = [i[鈥楥ountry/Territory鈥橾 for i in data]
values = [i[鈥榃orld Population Percentage鈥橾 for i in data]
fig2, ax2 = plt.subplots()
ax2.pie(values, labels = labels)
ax2.set_title(鈥楶ie Chart鈥)
ax2.axis(鈥榚qual鈥)

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(鈥楥ountry鈥), data))
porcentajes = list(map(lambda x: x.get(鈥榃orld Population Percentage鈥, 0), data))
charts.generate_pie_chart(countries, porcentajes)

import pandas as pd
import matplotlib.pyplot as plt
data = pd.read_csv(鈥渄ata.csv鈥)
continente = "South America"
columnas = [鈥淐ountry鈥,鈥淲orld Population Percentage鈥, 鈥淐ontinent鈥漖
data = data.loc[data.Continent==continente,columnas]
plt.pie(data[鈥淲orld 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