Gráficos de Torta con Datos Filtrados en Python

Clase 41 de 44 • Curso de Python: Comprehensions, Funciones y Manejo de Errores

Resumen

¿Cómo crear un gráfico de tortas utilizando Python?

Crear un gráfico de tortas es una forma eficaz de visualizar la distribución porcentual de diferentes categorías dentro de un conjunto de datos. Aquí te presentamos una guía práctica para crear este tipo de gráfico, basándonos en un reto que consiste en seleccionar datos de una columna específica. Vamos a profundizar en este proceso paso a paso.

¿Cómo seleccionar datos de una columna específica?

La clave para realizar este tipo de análisis es seleccionar los datos de una columna específica que nos interese graficar. Para ilustrarlo, utilizaremos el caso de la columna World Population Percentage:

Carga de datos: Asegúrate de tener tus datos en un formato adecuado, como un archivo CSV. Importa los datos de una forma en que puedas manejarlos como diccionarios en Python.
Selección Columnar: Extrae toda la columna que necesitas. Por ejemplo, si trabajamos con población mundial por porcentaje, seleccionaremos esa columna específica.
Utilizar la función map: Esto permite transformar los datos de la columna a una lista que será utilizada para graficar.

# Suponiendo que datos_csv es el diccionario con los datos ya cargados
paises = list(map(lambda x: x['country'], datos_csv)) 
porcentajes = list(map(lambda x: x['world_population_percentage'], datos_csv))

¿Cómo filtrar datos según preferencia?

Antes de pasar a graficar, es posible que quieras filtrar datos para hacer el gráfico más legible, como seleccionando sólo los países de un continente. Este paso ayuda a enfocarse en una región de interés y facilita la interpretación visual.

Filtrar por continente: Aquí puedes limitar el conjunto de datos, por ejemplo, seleccionando solo los países de Sudamérica.

datos_sudamerica = [dato for dato in datos_csv if dato['continent'] == 'South America']
paises_sudamerica = list(map(lambda x: x['country'], datos_sudamerica))
porcentajes_sudamerica = list(map(lambda x: x['world_population_percentage'], datos_sudamerica))

¿Cómo graficar con un pie chart?

Una vez que has seleccionado y filtrado los datos pertinentes, el siguiente paso es graficar. Utilizando bibliotecas de visualización como matplotlib, puedes crear un gráfico de tortas de manera sencilla.

import matplotlib.pyplot as plt

plt.pie(porcentajes_sudamerica, labels=paises_sudamerica, autopct='%1.1f%%')
plt.title('Distribución de la población por países en Sudamérica')
plt.show()

¿Qué desafíos pueden surgir?

Al manejar muchos datos, el gráfico puede volverse complejo de interpretar, especialmente si incluye muchos países o categorías. Filtrar los datos, como se explicó anteriormente, es crucial para mejorar la claridad de la visualización.

Te animamos a seguir explorando y perfeccionando tus habilidades de programación y análisis de datos. Dominar herramientas como los gráficos de tortas es un paso fundamental en tu camino para convertirte en un desarrollador Python competente. ¡Sigue practicando y experimentando con diferentes conjuntos de datos!

Alejandro Argüello Duarte

student•

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

Diego Jurado

student•

Que bueno aplicando alternativas

John Alexander Peña Bedoya

student•

Que buen aporte, gracias

Israel Orea

student•

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

Santiago Rubiano

student•

Si igual les sale error ponerlo entre comilla doble

Jesus Escobar

student•

Tambien pueden cambiarlo directamente desde el csv, cambien la parte de 'Country/Territory' por la que mejor les convenga

FELIX DAVID CORDOVA GARCIA

student•

ROBINSON TORRES HERRERA

student•

con pandas sale en pocas lineas, buen aporte

Julio Rogers Cajas Guncay

student•

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

Brayant Palomino Navarro

student•


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

Jorge Miguel Diaz

student•

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

Edwin Acosta

student•

Todo esto lo puedo hacer con excel lol

ARMANDO ISMAEL DIAZ REYES

student•

🤣😂

Samuel Bethancourt

student•

LOL

Jorge Cifuentes

student•

Alguien me podría ayudar, para saber por qué uso map en vez de filter?

Tal vez no comprendo bien cuando debo usar uno o el otro.

Edgardo Luis Jimenez Nuñez

student•

Hola Jorge, segun lo que he entendido del curso, el map lo utilizamos cuando queremos aplicar una funcion especifica a una serie de datos, en cambio el filter lo utilizamos para seleccionar una serie de datos en funcion de una condicion previamente descrita. Las dos herramientas(map y filter) devuelven un iterador.

Astrid Baquero Bernal

student•

Hola Jorge, en este enlace hay ejemplos sobre las similitudes y diferencias entre las funciones "Built-in" map y filter y en qué contexto se usa una o la otra.

Emilio Ciappi

student•

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

Emilio Ciappi

student•

bueno compare como fue creciendo la población mundial desde 1970 al 2022, tengo que admitir que no vi el video e hice lo que me pareció que iba a pedir solo leyendo el titulo.

Jorge Luis Castillo Ruz

student•

Me compliqué la vida:

def get_population_percentage(data):

    dict_countries = []
    dict_popupercentage = []
    for row in data: dict_countries.append({x:y for x,y in row.items() if x == 'Country/Territory'})
    for row in data: dict_popupercentage.append({x:y for x,y in row.items() if x == 'World Population Percentage'})
    labels=[key['Country/Territory'] for key in dict_countries]
    values = [key['World Population Percentage'] for key in dict_popupercentage]
    return labels, values
    #values = map(filter(lambda x: x == x['World Population Percentage'], data ), data)
```def get\_population\_percentage(data):
    dict\_countries = \[]    dict\_popupercentage = \[]    for row in data: dict\_countries.append({x:y for x,y in row.items() if x == 'Country/Territory'})    for row in data: dict\_popupercentage.append({x:y for x,y in row.items() if x == 'World Population Percentage'})    labels=\[key\['Country/Territory'] for key in dict\_countries]    values = \[key\['World Population Percentage'] for key in dict\_popupercentage]    return labels, values    #values = map(filter(lambda x: x == x\['World Population Percentage'], data ), data)

ANDRES ALFONSO MIRA MEJIA

student•

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

Salome Arboleda

student•

Mi solución:

En este caso considero que es más óptimo usar un for loop en lugar de dos list comprehensions o dos métodos de lista. La razón es que, si hago la construcción de cada lista por separado, estoy recorriendo la lista completa dos veces: una para obtener los porcentajes y otra para obtener los países.

Ese doble recorrido implica un mayor consumo de recursos innecesariamente, especialmente si el dataset es grande. En cambio, con un único for loop puedo ir acumulando tanto los países como los porcentajes al mismo tiempo, recorriendo la lista solo una vez.

Esto hace el código más eficiente en términos de rendimiento y también más claro, porque en un mismo bloque de lógica obtengo toda la información que necesito.

def get_world_population_percentages_by_continent(continent="Asia"):
  path = get_csv_path()

  with open(path, 'r') as file:
    reader = csv.reader(file, delimiter=',')
    next(reader)

    countries = []
    percentages = []
    for row in reader:
      if row[4].upper().strip() == continent.upper().strip():
        countries.append(row[2])
        percentages.append(get_number(row[16]))

    return countries, percentages


def get_number(value):
  try:
    return int(value)
  except ValueError:
    try:
      return float(value)
    except ValueError:
      return None

def get_world_population_percentages_by_continent(continent="Asia"):

path = get_csv_path()

with open(path, 'r') as file:

reader = csv.reader(file, delimiter=',')

next(reader)

countries = []

percentages = []

for row in reader:

if row[4].upper().strip() == continent.upper().strip():

countries.append(row[2])

percentages.append(get_number(row[16]))

return countries, percentages

Oscar Eduardo Barrios Blanco

student•

Solución

def world(data):
    result2 = dict (map(lambda item: (item['Country/Territory'], float(item['World Population Percentage'])), data))
    labels2 = result2.keys()
    values2 = result2.values()
    print (labels2,values2)
    return labels2, values2

en utils

luego en main

declarando data con scope global

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

labels2, values2 = utils.world(data)
charts.generate_pie(labels2, values2)

Jhon Gerardo Vega Medina

student•

Mi solución

import read_csv as r
import charts as ct

archivo_o = r.read_csv("./world_population.csv")

def get_col(col):
    archivo = list(filter(lambda x:x["Continent"] == "South America", archivo_o))
    values = [element[col] for element in archivo]
    countries = [element["Country/Territory"] for element in archivo]
    return countries, values

if __name__ == '__main__':
    countries, values = get_col("World Population Percentage")
    ct.generate_pie_chart(countries, values)

Julio Bastidas

student•

Yo hice mostrando un listado de continentes y que se pueda seleccionar alguno colocando su nombre y filtrarlo de esa forma, usando un set para eliminar duplicados

import read_csv
import charts

def run():
    data = read_csv.read_csv("./app/data.csv")
    continents = list(set(map(lambda x: x['Continent'], data)))
    for continent in continents:
        print(continent)
    
    continent_select = input("Type one continent: ")

    data = list(filter(lambda x: x['Continent'] == continent_select, data))
    countries = list(map(lambda x: x['Country'], data))
    percentages = list(map(lambda x: x['World Population Percentage'], data))
    charts.generate_pie_chart(countries, percentages)

if __name__ == '__main__':
    run()

Johan Garcia

student•

import csv
import matplotlib.pyplot as plt
import re

def read_csv(path):
    with open(path, "r") as csvfile:
        reader = csv.DictReader(csvfile, delimiter=",")
        dictPopulation = {}
        for row in reader:
            dictPopulation[row['Rank']] = row
        return dictPopulation

def generate_pie_chart(labels, values):
    fig, ax = plt.subplots()
    ax.pie(values, labels=labels, autopct='%1.1f%%')
    ax.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.
    plt.show()


if __name__ == "__main__":

    csvDictPopulation = read_csv("data.csv")

    SouthAmerica = list(filter(lambda x: x['Continent'] == 'South America', csvDictPopulation.values()))
    labels = list(map(lambda x: x['Country/Territory'], SouthAmerica))
    values = list(map(lambda x: x['World Population Percentage'], SouthAmerica))


    print(labels)
    print(values)
    
    generate_pie_chart(labels, values)

Samuel Bethancourt

student•

import matplotlib.pyplot as plt
import utils
import read_csv
import charts

def run():
    data = read_csv.read_csv(r'C:\Users\samue\Desktop\Platzi\Data Scientist con Python\Comprehension, Functions and Error Management\Exercises\Population_graphs.py\world_population.csv')
    SouthAmerica = list(filter(lambda x: x['Continent'] == 'South America', data))
    country = input('Type in your Country: ')
    result = utils.population_by_country(data, country)

    if result:
        country = result[0]
        print(f'Dictionary for get_population: {country}\n')
        keys, values = utils.get_population(country)
        print(f'Outcome of get_pupulation: {dict(zip(keys, values))}')
        charts.generate_bar_chart(keys, values)

        countries = list(map(lambda x: x['Country/Territory'], SouthAmerica))
        percentages = list(map(lambda x: x['World Population Percentage'], SouthAmerica))
        charts.generate_pie_chart(countries, percentages)


if __name__ == '__main__':
    run()
    plt.show()

Samuel Bethancourt

student•

Output

DEY WILLIAMS GORDILLO SALAZAR

student•

// app/main.py
import utils
import read_csv
import charts

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

  if len(data) > 0:
  #  country = result[0]
  #  labels, values = utils.get_population(country)
  #  charts.generate_bar_chart(labels, values)

    labels, values = utils.world_population_perc(data)
    charts.generate_pie_chart(labels, values)

// app/utils.py
def world_population_perc(data):
  result = {item['Country/Territory']: float(item['World Population Percentage']) for item in data}
  return result.keys(), result.values()

Andres Camilo Suarez Cabrejo

student•

Yo lo hice fue con una libreria llamada pandas no se si sea recomendable usarla por que cuando loejecuto el replit me dice el uso de memoria Ram esta al tope no se si sea por esa libreria , agradezco comentario

import csv import charts import pandas as pd

datos = pd.read_csv('population.csv',header = 0) print (datos)

countries = list(datos['Country/Territory']) percentage = list(datos['World Population Percentage']) print(countries) print(percentage) charts.generate_pie_chart(countries,percentage)

Juan Diego Figueroa

student•

Hola por favor ayúdenme, se llenó la RAM y CPU en Replit. Cómo podría solucionar esto? Tampoco me deja visualizar el Diagrama de Barras en Output

Roberto D Aguilar

student•

Hola judifimo1996 Lamento escuchar que estás experimentando.entiendo lo frustrante que puede ser. Permíteme ofrecerte algunas sugerencias para solucionarlo. Para abordar el problema de la RAM y la CPU, puedes intentar lo siguiente:

Verifica si tienes algún código o proceso que esté consumiendo una cantidad excesiva de recursos. Asegúrate de cerrar cualquier programa o proceso innecesario que esté ejecutándose en segundo plano.
Optimiza tu código para que utilice menos recursos. Asegúrate de liberar memoria adecuadamente después de utilizarla y evita bucles o estructuras de datos innecesariamente grandes.
Considera aumentar la cantidad de RAM y la capacidad de la CPU asignadas a tu proyecto en Replit. Esto puede ayudar a manejar mejor la carga de trabajo. Consulta la documentación de Replit para obtener instrucciones sobre cómo hacerlo. Respecto al problema de visualización del Diagrama de Barras en Output, es posible que haya un problema con la configuración de visualización en tu código. Asegúrate de que estés utilizando la biblioteca o método adecuado para generar el gráfico y que los datos estén correctamente formateados