Creando una gráfica

Yo estoy usando el Vscode y me toco escribir estos comandos para generar las gráficas. Por a alguien le sirve, xd :p

 pip install matplotlib

Después me toco ejecutar el siguiente código porque me aparecía el error ‘UserWarning: Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.’

 sudo apt-get install python3-tk

Y ya, all good

Para la persona que venían trabajando con Vscode, pueden usar Jupyter para la visualización de la gráfica.

Ya entramos a la ciencia de datos ❤️

Yo instale matplotlib en win10 desde la terminal de Git Bash
con los comandos:

py -m pip install -U pip
py -m pip install -U matplotlib

eso fue suficiente.

Por si alguien se siente confundido sobre algo de la clase les dejo el código con explicación

import matplotlib.pyplot as plt
#plt es un alias para matplotlib.pyplot


# funcion para grafico de barra
def generate_bar_chart(labels, values):
  fig, ax = plt.subplots()
  #son dos valores que nos da la librería, fig es como la figura y ax se refire a las coordenadas donde  vamos a empezar a graficar
  ax.bar(labels, values)
  #aquí le estás indicando que quieres generar una gráfica de barras (bar), y le envías labels y values para que sepa que tiene que crear el gráfico con esos valores
  plt.show()
  #es para mque nos pide que muestre la gráfica



# funcion para pie chart
def generate_pie_chart(labels, values):
  fig, ax = plt.subplots()
  ax.pie(values, labels=labels)
  """
 Aquí le estamos indicando que queremos que nos muestre una gráfica de torta, 
  fijate que en el anterior pusimos un bar y no un pie.

  Ahora le indicamos los labels pero también tenemos que indicarle como van a ser los labels 
  """
  ax.axis('equal')
  plt.show()


# ejecutar archivo como script desde la terminal
if __name__ == '__main__':
  labels = ['a', 'b', 'c']
  values = [20, 50, 10]
  #son los valores y los labels que tendrá la gráfica
  generate_bar_chart(labels, values)
    #Llamando a la función

  generate_pie_chart(labels, values)
    #Llamamos a la función pie chart

que tal, en replit si funciona la gráfica pero en vscode no, aun cuando se instaló matplot, alguién sabrá por qué?

Respondo lo que preguntaron sobre usar matplotlib en VSCode. Lo ideal es correr el código en el modo interactivo. Es similar a un notebook de jupyter y con toda la potencia de VSCode.

Solo deben colocar # %% como separador de celda. Esto les va a pedir instalar algunas extensiones necesarias y despues ya todo es felicidad.

Les dejo un ejemplo donde lo vi claramente:

# %%
import matplotlib.pylab as plt
import numpy as np

# %% 
plt.figure()
plt.plot(np.sin(np.linspace(-np.pi, np.pi, 1001)))
plt.show()

Con esto lo que pasará es que van a pder ejecutar cada celda donde se use el #%% como separador. Le dan run cell y listo.

No entiendo porqué este curso no se hace desde un principio en vsc, cómo se instalan paquetes en linux, no entiendo nada…

Para los que no les sale la barra de tareas como al profe y no encuentran packages lo pueden encontrar de lado derecho 👀

Para los que están trabjando desde Linux-Ubuntu, para instalar la librería Matplotlib es con la siguiente línea:

sudo apt-get install python3-matplotlib

Ya que especifica la version de python de esta distribución de python que es python3. Lo pueden hacer desde la terminal del mismo sistema o en mi caso, desde la terminal del VScode

Creando una grafica

#--------- Graficas en Python -----------

import matplotlib.pyplot as plt

# funcion para grafico de barra
def generate_bar_chart(labels, values):
  fig, ax = plt.subplots()
  ax.bar(labels, values)
  plt.show()

# funcion para pie chart
def generate_pie_chart(labels, values):
  fig, ax = plt.subplots()
  ax.pie(values, labels=labels)
  ax.axis('equal')
  plt.show()

# ejecutar archivo como script desde la terminal
if __name__ == '__main__':
  labels = ['a', 'b', 'c']
  values = [20, 50, 10]
  
  generate_bar_chart(labels, values)
  generate_pie_chart(labels, values)

Para los que estén usando Vs Code en WSL-Linux & Ubuntu 20.04.5
Abren la terminal en Vs Code y ponen los siguientes comandos:
sudo apt-get update
sudo apt-get install python-matplotlib

El “python” de la segunda linea le deben agregar “python3” si tienen versiones mas actualizadas del lenguaje, quedando así:
sudo apt-get install python3-matplotlib

Para que les corre en VS code usen:
pip install matplotlib

y en Commando Palette :
Select Interpeter: Python3.10

y Debuggen el Python File :

Debería salirles así

no me termina de convencer la forma de enseñanza de Nicolas, va muy rápido, no explica bien la estructura de muchas funciones 😦

Si les apareció este error:

Traceback (most recent call last):
File “/home/runner/NonstopBadWorker/app/charts.py”, line 1, in <module>
import matplotlib.pyplot as plt
ModuleNotFoundError: No module named 'matplotlib’

Se arregló volviendo a cargar la página, quizá no se cargó bien y hace falta darle refresh a la ventana. Suerte.

maestro dejas muchas cosas al aire, de que sirve el metodo subplot(), el bar().

se hacerlo, pero no entiendo como funciona 🤩

Hasta aca vine siendo un excelente curso

Es muy interesante ver como en esta herramienta se instalan bibliotecas y visualizan fácilmente las gráficas, sin embargo, se recomienda ir revisando en Visual Studio Code, y con la consola de Linux ya que aquí es algo más complejo y puede ser un quebradero de cabeza después

Les comparto el código de la clase.

# Creando una gráfica

# https://platzi.com/blog/matplotlib/
# https://platzi.com/cursos/matplotlib-seaborn/
# https://matplotlib.org/
# https://www.w3schools.com/python/matplotlib_pyplot.asp

#pip install matplotlib
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()

if __name__ == "__main__":
  labels = ["a", "b", "c"]
  values = [70, 150, 120]
  #generate_bar_chart(labels, values)
  generate_pie_chart(labels, values)

yo estoy trabajando en vs code y esta versión de la función fue la que al final me ejecuto

import matplotlib.pyplot as plot
def generate_bar_chart():
    labels=['a','b','c']
    values=[100,200,30.2]
    ax=plot.subplot()
    ax.bar(labels,values)
    plot.show()
<code> 

Mis primeras gráficas en Python, estoy emocionado!!!

Trazado de datos

import matplotlib.pyplot as plt
import numpy as np

xpoints = np.array([0, 6])
ypoints = np.array([0, 250])

plt.plot(xpoints, ypoints)
plt.show()

Para los que no esten usando replit y esten en consola, aqui les dejo como instalarse matplotlib y de paso como crear un entorno virtual.

1. Primero crea un entorno virtual de python en consola con:

py -m venv venv

1. Para iniciar el entorno virtual tienes que correr este comando.
   (No he usado el comando de Linux y Mac, espero que te funcione xD)

#Windows
.\venv\scripts\activate

#Linux o Mac
Source venv/bin/activate

1. Y con este instalas Matplotlib.

pip install matplotlib

Una vez termine la descarga ya lo puedes utilizar.
Otra cosa mas, si quieres salir del entorno virtual solo escribe:

Deactivate

Espero haberte ayudado!!

Que forma tan rapida para hacer gráficas!

PAra quienes estén teniendo problemas con vscode al momento de visualizar la gráfica está sucediendo lo siguiente (fuente gemini):
Este error suele ocurrir cuando estás intentando mostrar una gráfica en un entorno que no es interactivo, como un script que se ejecuta en la línea de comandos o en un servidor.
Cambiar el backend a uno interactivo: Para mostrar la gráfica en una ventana interactiva, puedes cambiar el backend a uno como TkAgg, QtAgg, o wxAgg. Esto se hace al inicio del script, antes de importar cualquier otra cosa de Matplotlib.

<import matplotlib
matplotlib.use('TkAgg')  # Cambia 'TkAgg' por el backend que tengas instalado

import matplotlib.pyplot as plt
# Resto del código> 

Pero si ésto les genera error es porque no tienen instalados los módulos tkinter necesario para usar el backend TkAgg de Matplotlib.

Ubuntu/Debian:

Abre una terminal y ejecuta el siguiente comando:

Bash

<sudo apt-get install python3-tk> 

Usa el código con precaución.

Fedora/CentOS:

Bash

<sudo dnf install python3-tkinter> 

Usa el código con precaución.

macOS:

tkinter viene preinstalado con Python en macOS. Sin embargo, si tienes problemas, puedes intentar reinstalar Python.

Una vez instalados ejecutan el archivo donde están trabajando en la terminal y funciona.

Para quienes estén utilizando VsCode, pueden ir a la página de matplotlib y copiar el prompt que dice:pip install matplotlib Pero desde una terminal linux ejecutan el siguiente comando:

<sudo apt install python3-pip>

. Si están usando una versión 3 deberán usar el 3 atrás de la palabra python de esta manera: python 3. Luego de ésto deberán escribir su contraseña de usuario root. Luego de la installación del paquete pip podrán instalar matplotlib con el siguiente prompt:

<python3 -m pip install -U matplotlib >

Siempre con el 3 detrás de la palabra python. Esto lo pueden hacer desde su terminal linux o dentro del editor cuando estan usando la terminal para visualizar su código. Espero les sirva de mucha ayuda.

A mi me apareció esto

Si alguien esta trabando con python3, puede que exista cierta discrepancia entre lo que hay en este video para la opción de gráficas de pie, yo lo resolví con esta referencia: https://www.w3schools.com/python/matplotlib_pie_charts.asp

Con google colab se puede utilizar todas esas librerias sin necesidad de instalar.

Estas dos últimas clases, no las asimilo, pues no entiendo en sí que se hace. Para saber que estoy haciendo, leeré la documentación de la librería y aprenderé ahí

Me gusto esta introduccion de manejo de graficas con python. Es algo bueno e interesante. Que bueno seguir aprendiendo.

✅

Hola para los que están practicado con un editor, lo pueden instalar con pip
pip install matplotlib

1. Importación de matplotlib:

   pythonCopy code
   import matplotlib.pyplot as plt
   
   

   En esta línea, importamos la biblioteca matplotlib y le asignamos el alias plt, que es una convención común para abreviar el nombre de esta biblioteca.

2. Definición de la función generate_bar_chart:

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

   Esta función toma dos argumentos: labels (etiquetas) y values (valores). Su propósito es generar un gráfico de barras a partir de estos datos.

   • fig, ax = plt.subplots(): Esta línea crea una figura (fig) y un eje (ax) para el gráfico. La figura es el lienzo en el que se dibujará el gráfico, y el eje es la región en la que se representarán los datos.
   • ax.bar(labels, values): Esta línea crea el gráfico de barras en el eje (ax). Utiliza las etiquetas (labels) en el eje x y los valores (values) en el eje y.
   • plt.show(): Finalmente, esta línea muestra el gráfico en una ventana emergente.

3. Definición de la función generate_pie_chart:

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

   Similar a la función anterior, esta función toma dos argumentos: labels y values, y su propósito es generar un gráfico circular (pie chart).

   • fig, ax = plt.subplots(): Al igual que antes, se crea una figura y un eje.
   • ax.pie(values, labels=labels): Esta línea genera el gráfico circular. Los valores (values) representan las proporciones de cada sector del gráfico, y las etiquetas (labels) se utilizan para etiquetar cada sector.
   • ax.axis('equal'): Asegura que el gráfico sea circular y no elíptico.
   • plt.show(): Muestra el gráfico circular.

4. Bloque principal (if __name__ == '__main__':):
   En este bloque, se definen las etiquetas (labels) y los valores (values) que se utilizarán para crear los gráficos. En este caso, se ha comentado la generación del gráfico de barras (generate_bar_chart(labels, values)) y se ha dejado habilitada la generación del gráfico circular (generate_pie_chart(labels, values)).

   • labels: Una lista de etiquetas que se usarán en los gráficos.
   • values: Una lista de valores que se utilizarán en los gráficos.

Cuando ejecutas este código, se generará un gráfico circular (pie chart) utilizando las etiquetas y valores proporcionados en el bloque principal. Puedes habilitar la generación del gráfico de barras eliminando el comentario en la línea correspondiente.

El jupyter le da mil vueltas a esto

Gráficas en Python…

¡Por supuesto! Las gráficas son una parte fundamental en muchas aplicaciones de Python, especialmente en el análisis de datos y la visualización de resultados. Python ofrece varias bibliotecas populares para crear gráficas. Algunas de las bibliotecas de gráficos más utilizadas en Python son:

1. Matplotlib: Matplotlib es una de las bibliotecas más utilizadas para crear gráficos estáticos en Python. Permite crear una amplia variedad de gráficos, incluyendo gráficos de dispersión, barras, líneas, histogramas y más. Es altamente personalizable y se puede utilizar junto con otras bibliotecas como NumPy y Pandas.

   Ejemplo de uso básico de Matplotlib:

   import matplotlib.pyplot as plt
   
   # Datos
   x = [1, 2, 3, 4, 5]
   y = [10, 12, 5, 8, 9]
   
   # Crear un gráfico de barras
   plt.bar(x, y)
   
   # Mostrar el gráfico
   plt.show()
   

2. Seaborn: Seaborn es una biblioteca de alto nivel que se basa en Matplotlib y simplifica la creación de gráficos estadísticos atractivos. Está diseñada especialmente para trabajar con DataFrames de Pandas.

   Ejemplo de uso de Seaborn:

   import seaborn as sns
   import pandas as pd
   
   # Datos en un DataFrame de Pandas
   df = pd.DataFrame({'x': [1, 2, 3, 4, 5], 'y': [10, 12, 5, 8, 9]})
   
   # Crear un gráfico de barras usando Seaborn
   sns.barplot(x='x', y='y', data=df)
   
   # Mostrar el gráfico
   plt.show()
   

3. Plotly: Plotly es una biblioteca que permite crear gráficos interactivos y dinámicos. Puede generar gráficos en línea y fuera de línea y es útil para la creación de paneles de control y visualizaciones interactivas.

   Ejemplo de uso de Plotly:

   import plotly.express as px
   
   # Datos en un DataFrame de Pandas
   df = pd.DataFrame({'x': [1, 2, 3, 4, 5], 'y': [10, 12, 5, 8, 9]})
   
   # Crear un gráfico de barras interactivo con Plotly Express
   fig = px.bar(df, x='x', y='y', title='Gráfico de Barras Interactivo')
   fig.show()
   

4. Bokeh: Bokeh es otra biblioteca para crear gráficos interactivos y se utiliza principalmente para aplicaciones web. Permite la creación de gráficos interactivos con herramientas de zoom, pan y selección.

   Ejemplo de uso de Bokeh:

   from bokeh.plotting import figure, show
   
   # Datos
   x = [1, 2, 3, 4, 5]
   y = [10, 12, 5, 8, 9]
   
   # Crear un gráfico de dispersión interactivo
   p = figure(title='Gráfico de Dispersión Interactivo')
   p.circle(x, y, size=10)
   
   # Mostrar el gráfico en un navegador web
   show(p)
   

Estas son solo algunas de las bibliotecas de gráficos más populares en Python. La elección de la biblioteca adecuada dependerá de tus necesidades específicas y de la estética que desees para tus gráficos.

Para los que estan con VSCode

Suponiendo que han creado su propia carpeta para esta tarea, yo por ejemplo hice una llamada (grafico csv), abren su archivo .py con vs code y siguen los siguientes pasos dentro de la terminal:

1. Primero abren un entorno virtual(esto sirve para el aislamiento de dependencias para proyectos Python, evita conflictos y asegura consistencia.):

python -m venv venv

(Si vsCode te pregunta si quieres instalarlo en la carpeta en la que te encuentras le das que si)

1. Una vez instalado ejecutas lo siguiente:

.\venv\Scripts\activate   

1. Por ultimo:

pip install matplotlib

Para los que están usando replit como yo y que se les queda pensando al graficar, yo me cambié de ocmputadora y funcionó.

Yo puse estos códigos para que me corriera, ya que el codigo visto en clase no me corría.

Aca una estupenda guia para el tema https://matplotlib.org/stable/tutorials/introductory/pyplot.html

Por parar la clase antes de su typo me comí más tiempo pensando que que tenía un problema con mi matplotlib hasta instalé de más jajaj pero bueno funciona correctamente 🐍

Escribí la gráfica de la cardioide. Utilicé herramientas de matemáticas para parametrizar las listas de datos pero seguro que habrá comandos para automatizar este proceso en python. Solo usé lo que tenía mas inmediato y un poquito de investigación para utilizar algunos comandos.

import matplotlib.pyplot as plt
import math

angle = [math.radians(i) for i in range(0,360)]
x = [(1+math.cos(i))*math.cos(i) for i in angle]
#r = [1+math.cos(i) for i in x]
y = [(1+math.cos(i))*math.sin(i) for i in angle]
# print(x,y)

fig, ax = plt.subplots()  # Create a figure containing a single axes.
ax.plot(x, y)  # Plot some data on the axes
plt.show()

Si no les muestra las gráficas en windows con Visual Studio, se tiene que setear el backend que usa matplotlib a “TkAgg”:

import matplotlib # Esto es importante
matplotlib.use('TkAgg')# Esto también es importante
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()

if __name__ == '__main__':
    labels = ['a','b','c']
    values = [100, 200, 80]
    
    #generate_bar_chart(labels, values)
    generate_pie_chart(labels, values)

Estoy trabajando en Ubuntu Server y para instalar matplotlib verifiquen si tienen instalado pip

pip --version

si no lo tienen instalado abren consola y pegan esto

sudo apt-get update
sudo apt-get install python3-pip

verificamos

pip --version

y ahora si

pip install matplotlib

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

if __name__ == '__main__':
  labels = ['a', 'b', 'c']
  values = [100, 200,30]
  #generate_bar_chart(labels, values)
  generate_pie_chart(labels,values)

Para instalar la librería en VS Code Windows

copiar en la terminal:
python -m pip install -U pip

y luego
python -m pip install -U matplotlib

Listo!

Les recomiendo revisar el tutorial y los recursos de la clase, me han servido mucho para aprender a manipular las gráficas

Al final no lo pude hacer en replit, no se porque y para avanzar lo pude hacer con vscode. super facil instalando la extension.

Hola Mundo

Sufrí un poco al principio, porque no estaba siguiendo el paso a paso en orden, y así como me sucedió a mi es posible que sin querer le pasé a más compañeros, así que les comento, lo primero que se debe hacer es ingresar a la página de Matplotlib y descargar el pip install matplotlib en la simbología del sistema, luego se dirigen a Replit y descargan en pakages la libreria matplotlib, hacen una prueba llamando el programa en el shell y si no funciona o sale algun error, copian el error y lo buscan en la paguina de matplotlib, hay aparecen varios soportes para manejar errores, todos los soportes deben ser descargados en la simbología del sistema, una vez hecho esto vuelves a Replit y ‘ojo’ es importante, debes desinstalar la biblioteca de matplotlib que tenías instalada ya que esta se va a quedar bloqueada con el error anterior, una vez desinstala vuelves a pakages y la instalas nuevamente, esta nueva instalación se ejecuta sin problema, y listo a divertirse 😏

Todo iba bien en el curso hasta esta clase

no se porque pero mi instinto me dice que esa librería se contruyó con interfaz gráfica para poder hacerlo visual a la hora de hacer análisis

import matplotlib.pyplot as plt 
#import numpy as np

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(total['World Population Percentage']) for total in data if total['Continent'] == 'South America']

    labels = [total['Country/Territory'] for total in data if total['Continent'] == 'South America']
    
    fig, ax = plt.subplots()
    ax.bar(labels, values)
    plt.show()

tuve , como dos dias , que visual code en modo interactivo no me visualizava los charts . desde wsl , ubuntud ,
termine instalandole , gnome , y conociendo que es un GUI
ala final no me quedo muy claro como pero coguio , chatgpt3 lo tengo integrado en la terminal me ayudo mucho en algunas cosas y conocimientos , pero fue decisivo la documentación , por si estan en mi caso les recomiendo busquen estas dos lineas en la doc

matplotlab.use
matplotlab.get_backend

El código crea un script en Python que analiza y visualiza datos de un archivo CSV específico (datas.csv).

El script importa la biblioteca “csv” para leer el archivo CSV. Luego, define dos funciones: “analizeData” y “charts_Circle”.

La función “analizeData” abre el archivo CSV y utiliza el método “csv.reader” para leer el contenido y almacenarlo en una lista llamada “listas”. Luego, extrae las etiquetas (columna 0) y los valores (columna 1) del archivo CSV y los almacena en las listas “labels” y “values”. Finalmente, convierte los valores en enteros y devuelve las listas “labels” y “values”.

La función “charts_Circle” toma las listas “labels” y “values” y las usa para crear un gráfico de barras mediante la biblioteca “matplotlib”. La gráfica se muestra en pantalla con la función “pit.show()”.

Finalmente, el bloque “if name == ‘main’” asegura que el código solo se ejecute cuando el script sea ejecutado directamente (no cuando sea importado como un módulo). Este bloque llama a la función “analizeData” para obtener las listas “labels” y “values”, y luego llama a la función “charts_Circle” para crear y mostrar el gráfico de barras.

Utilizando las funciones creadas en la clase quise graficar, a modo de ejercicio, la población del 2022 agrupada por continentes, les comparto el proceso a modo de aporte:

Pd: Convertí el csv en un Dataframe de Pandas porque es la forma que me parece más sencillo de manipularlo.

import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv('data.csv')

Creé un subdataframe con los Continentes y la población del 2022 agrupándolo por continente y sumando los totales:

sum_population = df[['Continent', '2022 Population']].groupby(by =['Continent']).sum()

Como los Continentes me quedaron como índice, hice un reset para que se convirtieran nuevamente en columna:

sum_population.reset_index(inplace = True)

Y listo, pude generar los gráficos a partir de las funciones:

print(generate_bar_chart(sum_population['Continent'], sum_population['2022 Population']))

print(generate_pie_chart(sum_population['Continent'], sum_population['2022 Population']))

Si estan en WSL, para instalar pip, pueden usar esta serie de comandos:

sudo apt-get install python3-setuptools
sudo python3 -m easy_install install pip
python3 -m pip --version

Para los que tuvieron inconvenientes al ejecutar la gráfica desde VScode en mi caso lo solucioné de la siguiente forma:
Ve a extenciones y busca la extensión “Jupyter” te permite ejecutar código por partes en tiempo real.
esto lo hace delimitando el código por bloques con “#%%”.
Link de la extensión: https://code.visualstudio.com/docs/datascience/jupyter-notebooks
https://docs.jupyter.org/en/latest/install.html

# %%  
import matplotlib.pyplot as plt
import numpy as np

def generate_bar_chart():
    labels = ['a', 'b', 'c']
    values = [100, 299, 129]
    fig, ax = plt.subplots()
    ax.bar(labels, values)
    plt.show()

if __name__ == '__main__':
    generate_bar_chart()

# %%

MI SOLUCIÓN> Tal vez no cumple con la filosofía de Python pero las funciones cumplen con el reto.

import read_csv
import matplotlib.pyplot as plt

def column_choice(data, column):
  #funcion que retorna la informacion de un pais elegido
  user_column = column.title()
  percentage_dict = {}
  #print(user_column)
  for country in data:
    for k, v in country.items():
      if k == user_column:
        percentage_dict[country['Country/Territory']] = v
  return percentage_dict


def generate_bar_char(data):
  labels = []
  values = []
  for k, v in data.items():
    labels.append(k)
    values.append(v)
  fig, ax = plt.subplots()
  ax.pie(values, labels = labels)
  ax.axis('equal')
  plt.show()

world_data = read_csv.read_csv('/home/runner/Python-Platzi/population/world_population.csv')

country_percentages = column_choice(world_data, 'world population percentage')

generate_bar_char(country_percentages)

import matplotlib.pyplot as plt


def generate_bar_chart():
  labels = ["a", "b", "c"]
  values = [100,200,80]
  fig, ax = plt.subplots()
  ax.bar(labels, values)
  plt.show()

if __name__ == "__main__":
  try:
    generate_bar_chart()
  except Exception as e:
    print(e)

Este código genera un gráfico de barras utilizando Matplotlib. Vamos a analizarlo paso a paso:

• En la primera línea, se importa el módulo matplotlib.pyplot como plt. Esto nos permite utilizar funciones y métodos de este módulo con el alias plt.

• Se define una función llamada generate_bar_chart(). Esta función es la encargada de crear y mostrar el gráfico de barras.

• Dentro de la función, se declaran dos listas llamadas labels y values. Estas listas contienen los valores de las etiquetas y los valores de las barras, respectivamente. En este caso, se tienen 3 etiquetas a, b, c y 3 valores 100, 200, 80.

• Se crea una figura y un eje con fig, ax = plt.subplots(). La función plt.subplots() devuelve una figura y un eje en dos variables. El eje es el lugar donde se dibujarán los gráficos, y la figura es el contenedor de los ejes.

• Se utiliza el método bar del eje (ax) para crear el gráfico de barras. El primer argumento es la lista de etiquetas y el segundo argumento es la lista de valores. Esto crea las barras del gráfico con las etiquetas y valores especificados.

• Se utiliza el método show() de plt para mostrar el gráfico.

• Finalmente, se tiene una sección de código if name == “main” la cual solo se ejecutará si este script es el script principal en ejecución. En este caso, se intenta llamar a la función generate_bar_chart() y en caso de ocurrir un error se imprime dicho error.

Les recomiendo usar PyCharm para proyectos profesionales 😉

Comparto mi solución al reto:

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 = list(zip(header, row))
      country_dict = {key: value for (key, value) in iterable}
      data.append(country_dict)
  return data
  
data = read_csv('./app/data.csv')

def population(data):
  values = []
  country = input('Digite el país: ')
  
  for i in data:
    if country == i.get('Country/Territory'):
      values.append(i.get('1970 Population'))
      values.append(i.get('1980 Population'))
      values.append(i.get('1990 Population'))
      values.append(i.get('2000 Population'))
      values.append(i.get('2010 Population'))
      values.append(i.get('2015 Population'))
      values.append(i.get('2020 Population'))
      values.append(i.get('2022 Population'))
  
    # iterable = list(zip(years, values))
    # population_dict = {key: value for (key, value) in iterable}
    # population_for_year.append(population_dict)
    
  return values

years = ['1970', '1980', '1990', '2010','2000', '2015', '2020', '2022']
population = population(data)

def bar_chart(population, years):

  fig, ax = plt.subplots()
  ax.bar(years, population)
  plt.show()
  

if __name__ == '__main__':
  population_for_year = bar_chart(population, years)

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

if __name__ == '__main__':
  labels = [ 'a','b', 'c']
  values = [10, 40, 800]
  #generate_bar_chart(labels, values)
  generate_pie_chart(labels, values)

• Subplot permite crear gráficos dentro de una gráfica. Esto lo hace a través de una matriz de gráficos y se puede acceder a ellos a través de índices:
  Cómo acceder a la matriz de gráficos en Subplot
  import matplotlib.pyplot as plt
  import numpy as np

x = np.linspace(0,5,11)
y = x ** 2

Parámetros en Subplot

• Los parámetros de subplot funcionan:
  Filas Columnas Index

• Crear fila y dos columnas
  • Crear una matriz de gráficos de una fila y dos columnas

• Si estás usando un compilador y tienes problemas con la ejecución de MATPLOTLIB, puede que necesites instalarlo en tu ordenador (hay varias formas de hacerlo correctamente como hacerlo desde la consola de tu ordenador).

• Si tienes problemas con la instalación con PIP, puede que necesites habilitarlo en la versión de tu python.

• También puedes tener problemas instalando una versión anterior de la librería, esto hace que algún comando no se reconozca.

para los que están usando otros IDE abren una terminal preferiblemente usar un entorno virtual y lo instalan
https://matplotlib.org/stable/users/installing/index.html