Guía de Visualización de Datos en Python con Pandas

En esta guía, repasaremos todo lo que necesita saber para realizar la visualización de datos en Python con Pandas: gráficos de barras, histogramas, gráficos de área, gráficos circulares, gráficos de densidad y matrices de dispersión.

Introducción

Las personas rara vez pueden mirar datos sin procesar e inmediatamente deducir una observación orientada a datos como:

¡La gente en las tiendas tiende a comprar pañales y cerveza en conjunto!

O incluso si usted, como científico de datos, puede leer a primera vista los datos sin procesar, lo más probable es que su inversor o jefe no pueda.

Para que podamos analizar correctamente nuestros datos, debemos representarlos de una manera tangible y completa. ¡Es exactamente por eso que usamos la visualización de datos!

La biblioteca pandas ofrece una gran variedad de herramientas que te ayudarán a lograr esto. En este artículo, iremos paso a paso y cubriremos todo lo que necesitará para comenzar con las herramientas de visualización de pandas, incluidos gráficos de barras, histogramas, diagramas de área, diagramas de densidad, matrices de dispersión y diagramas de arranque.

Importación de datos

Primero, necesitaremos un pequeño conjunto de datos para trabajar y probar cosas.

Usaré un conjunto de datos de comida india ya que, francamente, la comida india es deliciosa. Puede descargarlo gratis desde Kaggle.com. Para importarlo, usaremos el método read_csv() que devuelve un DataFrame. Aquí hay un pequeño fragmento de código, que imprime las primeras cinco y las últimas cinco entradas en nuestro conjunto de datos. Hagamos un intento:

1
2
3
import pandas as pd
menu = pd.read_csv('indian_food.csv')
print(menu)

Ejecutar este código generará:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
               name            state      region ...  course
0        Balu shahi      West Bengal        East ... dessert
1            Boondi        Rajasthan        West ... dessert
2    Gajar ka halwa           Punjab       North ... dessert
3            Ghevar        Rajasthan        West ... dessert
4       Gulab jamun      West Bengal        East ... dessert
..              ...              ...         ... ...     ...
250       Til Pitha            Assam  North East ... dessert
251         Bebinca              Goa        West ... dessert
252          Shufta  Jammu & Kashmir       North ... dessert
253       Mawa Bati   Madhya Pradesh     Central ... dessert
254          Pinaca              Goa        West ... dessert

Si desea cargar datos de otro formato de archivo, pandas ofrece métodos de lectura similares como read_json(). La vista está ligeramente truncada debido a la forma larga de la variable ingredients.

Para extraer solo unas pocas columnas seleccionadas, podemos dividir el conjunto de datos entre corchetes y enumerar los nombres de las columnas en las que nos gustaría centrarnos:

1
2
3
4
5
import pandas as pd

menu = pd.read_csv('indian_food.csv')
recepies = menu[['name', 'ingredients']]
print(recepies)

Esto produce:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
               name                                        ingredients
0        Balu shahi                    Maida flour, yogurt, oil, sugar
1            Boondi                            Gram flour, ghee, sugar
2    Gajar ka halwa       Carrots, milk, sugar, ghee, cashews, raisins
3            Ghevar  Flour, ghee, kewra, milk, clarified butter, su...
4       Gulab jamun  Milk powder, plain flour, baking powder, ghee,...
..              ...                                                ...
250       Til Pitha            Glutinous rice, black sesame seeds, gur
251         Bebinca  Coconut milk, egg yolks, clarified butter, all...
252          Shufta  Cottage cheese, dry dates, dried rose petals, ...
253       Mawa Bati  Milk powder, dry fruits, arrowroot powder, all...
254          Pinaca  Brown rice, fennel seeds, grated coconut, blac...

[255 rows x 2 columns]

Trazado de gráficos de barras con pandas

El clásico gráfico de barras es fácil de leer y es un buen lugar para comenzar: visualicemos cuánto tiempo lleva cocinar cada plato.

Pandas se basa en el motor Matplotlib para mostrar los gráficos generados. Así que tendremos que importar el módulo PyPlot de Matplotlib para llamar a plt.show() después de generar los gráficos.

Primero, importemos nuestros datos. Hay muchos platos en nuestro conjunto de datos: 255 para ser exactos. Esto realmente no encajará en una sola figura mientras permanece legible.

Usaremos el método head() para extraer los primeros 10 platos y extraer las variables relevantes para nuestra trama. Es decir, querremos extraer el “nombre” y el “tiempo de cocción” de cada plato en un nuevo DataFrame llamado “nombre_y_tiempo”, y truncarlo en los primeros 10 platos:

1
2
3
4
5
6
import pandas as pd
import matplotlib.pyplot as plt

menu = pd.read_csv('indian_food.csv')

name_and_time = menu[['name','cook_time']].head(10)

Ahora usaremos el método bar() para trazar nuestros datos:

1
DataFrame.plot.bar(x=None, y=None, **kwargs)

Se pueden pasar muchos parámetros adicionales para personalizar aún más el gráfico, como rot para la rotación de etiquetas, leyenda para agregar una leyenda, estilo, etc.

Muchos de estos argumentos tienen valores predeterminados, la mayoría de los cuales están desactivados. Dado que el argumento rot está predeterminado en 90, nuestras etiquetas se rotarán 90 grados. Cambiemos eso a 30 mientras construimos la trama:

1
name_and_time.plot.bar(x='name',y='cook_time', rot=30)

Y finalmente, llamaremos al método show() desde la instancia de PyPlot para mostrar nuestro gráfico:

1
plt.show()

Esto generará nuestro gráfico de barras deseado:
bar chart pandas

Trazado de varias columnas en el eje X del gráfico de barras en Pandas

A menudo, es posible que queramos comparar dos variables en un gráfico de barras, como cook_time y prep_time. Ambas son variables correspondientes a cada plato y son directamente comparables.

Cambiemos el DataFrame name_and_time para incluir también prep_time:

1
2
name_and_time = menu[['name','prep_time','cook_time']].head(10)
name_and_time.plot.bar(x='name', rot=30)

Pandas asumió automáticamente que los dos valores numéricos junto con nombre están vinculados a él, por lo que es suficiente definir el eje X. Cuando se trata de otros DataFrames, este podría no ser el caso.

Si necesita definir explícitamente qué otras variables deben trazarse, simplemente puede pasar una lista:

1
name_and_time.plot.bar(x='name', y=['prep_time','cook_time'], rot=30)

Ejecutar cualquiera de estos dos códigos producirá:
multiple bar plots pandas
Eso es interesante. Parece que la comida que se cocina más rápido requiere más tiempo de preparación y viceversa. Sin embargo, esto proviene de un subconjunto de datos bastante limitado y esta suposición podría ser incorrecta para otros subconjuntos.

Trazado de gráficos de barras apiladas con pandas

Veamos qué plato lleva más tiempo hacer en general. Como queremos tener en cuenta tanto el tiempo de preparación como el tiempo de cocción, los apilaremos uno encima del otro.

Para hacer eso, estableceremos el parámetro ‘apilado’ en ‘Verdadero’:

1
name_and_time.plot.bar(x='name', stacked=True)

stacked bar graphs with pandas

Ahora, podemos ver fácilmente qué platos tardan más en prepararse, teniendo en cuenta tanto el tiempo de preparación como el tiempo de cocción.

Personalización de diagramas de barras en Pandas

Si queremos que las gráficas se vean un poco mejor, podemos pasar algunos argumentos adicionales al método bar(), como:

  • color - Que define un color para cada uno de los atributos de DataFrame. Puede ser una cadena como 'orange', rgb o un código rgb como #faa005.
  • título - Una cadena o lista que representa el título de la trama.
  • grid: un valor booleano que indica si las líneas de cuadrícula son visibles.
  • figsize - Una tupla que indica el tamaño de la trama en pulgadas.
  • leyenda - Booleano que indica si se muestra la leyenda.

Si queremos un gráfico de barras horizontales, podemos usar el método barh() que toma los mismos argumentos.

Por ejemplo, grafiquemos un gráfico de barras naranja y verde horizontal, con el título "Platos", con una cuadrícula, de tamaño 5 por 6 pulgadas, y una leyenda:

1
2
3
4
5
6
7
8
import pandas as pd
import matplotlib.pyplot as plt

menu = pd.read_csv('indian_food.csv')
name_and_time = menu[['name','cook_time','prep_time']].head()

name_and_time.plot.barh(x='name',color =['orange','green'], title = "Dishes", grid = True, figsize=(5,6), legend = True)
plt.show()

customizing bar plots in pandas

Trazado de histogramas con pandas {#trazado de histogramas con pandas}

Los histogramas son útiles para mostrar la distribución de datos. Mirando una receta, no tenemos idea si el tiempo de cocción está cerca del tiempo medio de cocción o si lleva mucho tiempo. Los medios pueden ayudarnos con esto, hasta cierto punto, pero pueden ser engañosos o propensos a grandes barras de error.

Para tener una idea de la distribución, que nos brinda mucha información sobre el tiempo de cocción, querremos trazar un gráfico de histograma.

Con Pandas, podemos llamar a la función hist() en un DataFrame para generar su histograma:

1
DataFrame.hist(column=None, by=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, fcigsize=None, layout=None, bins=10, backend=None, legend=False,**kwargs)

El parámetro bins indica el número de bins a utilizar.

Una gran parte de trabajar con cualquier conjunto de datos es la limpieza y el preprocesamiento de datos. En nuestro caso, algunos alimentos no tienen los tiempos de cocción y preparación adecuados en la lista (y tienen un valor de -1 en su lugar).

Filtrémoslos de nuestro menú, antes de visualizar el histograma. Este es el tipo más básico de preprocesamiento de datos. En algunos casos, es posible que desee cambiar los tipos de datos (cadenas con formato de moneda en flotantes, por ejemplo) o incluso construir nuevos puntos de datos basados ​​en alguna otra variable.

Filtremos los valores no válidos y tracemos un histograma con 50 contenedores en el eje X:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import pandas as pd
import matplotlib.pyplot as plt

menu = pd.read_csv('indian_food.csv')
menu = menu[menu.cook_time != -1] # Filtering
cook_time = menu['cook_time']

cook_time.plot.hist(bins = 50)

plt.legend()
plt.show()

Esto resulta en:
histogram plot pandas

En el eje Y, podemos ver la frecuencia de los platos, mientras que en el eje X, podemos ver cuánto tardan en cocinarse.

Cuanto más alta sea la barra, mayor será la frecuencia. Según este histograma, la mayoría de los platos tardan entre 0..80 minutos en cocinarse. El número más alto de ellos está en la barra realmente alta, sin embargo, no podemos distinguir qué número es exactamente porque la frecuencia de nuestros ticks es baja (uno cada 100 minutos).

Por ahora, intentemos cambiar la cantidad de contenedores para ver cómo eso afecta nuestro histograma. Después de eso, podemos cambiar la frecuencia de los ticks.

Destacando datos con tamaños de contenedores

Intentemos trazar este histograma con “10” contenedores en su lugar:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import pandas as pd
import matplotlib.pyplot as plt

menu = pd.read_csv('indian_food.csv')
menu = menu[menu.cook_time != -1] # Filtering
cook_time = menu['cook_time']

cook_time.plot.hist(bins = 10)

plt.legend()
plt.show()

changing bins in histogram pandas

Ahora, tenemos 10 contenedores en todo el eje X. Tenga en cuenta que solo 3 contenedores tienen alguna frecuencia de datos mientras que el resto está vacío.

Ahora, tal vez aumentemos el número de contenedores:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import pandas as pd
import matplotlib.pyplot as plt

menu = pd.read_csv('indian_food.csv')
menu = menu[menu.cook_time != -1] # Filtering
cook_time = menu['cook_time']

cook_time.plot.hist(bins = 100)

plt.legend()
plt.show()

histogram bins pandas

Ahora, los contenedores están extrañamente colocados muy separados, y nuevamente hemos perdido algo de información debido a esto. Siempre querrá experimentar con los tamaños de contenedores y ajustarlos hasta que los datos que desea explorar se muestren bien.

La configuración predeterminada (el número de contenedor predeterminado es 10) habría resultado en un número de contenedor impar en este caso.

Cambiar la frecuencia de marca para el histograma de Pandas

Dado que estamos usando Matplotlib como motor para mostrar estos gráficos, también podemos usar cualquier técnica de personalización de Matplotlib.

Dado que nuestros ticks del eje X son un poco infrecuentes, crearemos una matriz de números enteros, en incrementos de 20 pasos, entre 0 y cook_time.max(), que devuelve la entrada con el número más alto.

Además, dado que tendremos muchas marcas en nuestro gráfico, las rotaremos 45 grados para asegurarnos de que encajen bien:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Clean data and extract what we're looking for
menu = pd.read_csv('indian_food.csv')
menu = menu[menu.cook_time != -1] # Filtering
cook_time = menu['cook_time']

# Construct histogram plot with 50 bins
cook_time.plot.hist(bins=50)

# Modify X-Axis ticks
plt.xticks(np.arange(0, cook_time.max(), 20))
plt.xticks(rotation = 45) 

plt.legend()
plt.show()

Esto resulta en:

change tick frequency pandas

Trazado de múltiples histogramas {#trazado de múltiples histogramas}

Ahora agreguemos el tiempo de preparación a la mezcla. Para agregar este histograma, lo trazaremos como una configuración de histograma separada, ambas con una opacidad del 60 %.

Compartirán tanto el eje Y como el eje X, por lo que se superpondrán. Sin configurarlos para que sean un poco transparentes, es posible que no veamos el histograma debajo del segundo que trazamos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Filtering and cleaning
menu = pd.read_csv('indian_food.csv')
menu = menu[(menu.cook_time!=-1) & (menu.prep_time!=-1)] 

# Extracting relevant data
cook_time = menu['cook_time']
prep_time = menu['prep_time']

# Alpha indicates the opacity from 0..1
prep_time.plot.hist(alpha = 0.6 , bins = 50) 
cook_time.plot.hist(alpha = 0.6, bins = 50)

plt.xticks(np.arange(0, cook_time.max(), 20))
plt.xticks(rotation = 45) 
plt.legend()
plt.show()

Esto resulta en:
plotting multiple hsitograms pandas

Podemos concluir que la mayoría de los platos se pueden preparar en menos de una hora o en aproximadamente una hora. Sin embargo, hay algunos que tardan un par de días en prepararse, con tiempos de preparación de 10 horas y tiempos de cocción prolongados.

Personalización de gráficos de histogramas

Para personalizar los histogramas, podemos usar los mismos argumentos de palabras clave que usamos con el gráfico de barras.

Por ejemplo, hagamos un histograma verde y rojo, con un título, una cuadrícula, una leyenda, del tamaño de 7x7 pulgadas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

menu = pd.read_csv('indian_food.csv')
menu = menu[(menu.cook_time!=-1) & (menu.prep_time!=-1)] #filltering

cook_time = menu['cook_time']
prep_time = menu['prep_time']

prep_time.plot.hist(alpha = 0.6 , color = 'green', title = 'Cooking time', grid = True, bins = 50)
cook_time.plot.hist(alpha = 0.6, color = 'red', figsize = (7,7), grid = True, bins = 50)

plt.xticks(np.arange(0, cook_time.max(), 20))
plt.xticks(rotation = 45) 

plt.legend()
plt.show()

Y aquí está nuestro histograma de colores navideños:

customizing histogram pandas

Trazado de parcelas de área con pandas {#trazado de parcelas con pandas}

Los diagramas de área son útiles cuando se observa la correlación de dos parámetros. Por ejemplo, a partir de los gráficos de histogramas, sería válido inclinarse hacia la idea de que los alimentos que tardan más en prepararse, tardan menos en cocinarse.

Para probar esto, trazaremos esta relación usando la función area():

1
DataFrame.plot.area(x=None, y=None, **kwargs)

Usemos la media de los tiempos de cocción, agrupados por tiempos de preparación para simplificar este gráfico:

1
time = menu.groupby('prep_time').mean() 

Esto da como resultado un nuevo DataFrame:

1
2
3
4
5
6
7
8
9
prep_time
5           20.937500
10          40.918367
12          40.000000
15          36.909091
20          36.500000
...
495         40.000000
500        120.000000

Ahora, trazaremos un diagrama de área con el DataFrame time resultante:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import pandas as pd
import matplotlib.pyplot as plt

menu = pd.read_csv('indian_food.csv')
menu = menu[(menu.cook_time!=-1) & (menu.prep_time!=-1)]

# Simplifying the graph
time = menu.groupby('prep_time').mean() 
time.plot.area()

plt.legend()
plt.show()

area plot pandas

Aquí, nuestra noción de la correlación original entre el tiempo de preparación y el tiempo de cocción se ha hecho añicos. Aunque otros tipos de gráficos pueden llevarnos a algunas conclusiones, existe una especie de correlación que implica que con tiempos de preparación más altos, también tendremos tiempos de cocción más altos. Que es lo contrario de lo que hipotetizábamos.

Esta es una gran razón para no limitarse a un solo tipo de gráfico, sino explorar su conjunto de datos con múltiples enfoques.

Trazado de parcelas de áreas apiladas

Los gráficos de área tienen un conjunto de argumentos de palabras clave muy similar al de los gráficos de barras y los histogramas. Una de las excepciones notables sería:

  • apilado - Valor booleano que indica si dos o más parcelas se apilarán o no

Tracemos los tiempos de cocción y preparación para que queden apilados, rosa y morado, con una cuadrícula de 8x9 pulgadas de tamaño, con una leyenda:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import pandas as pd
import matplotlib.pyplot as plt

menu = pd.read_csv('indian_food.csv')
menu = menu[(menu.cook_time!=-1) & (menu.prep_time!=-1)]

menu.plot.area()

plt.legend()
plt.show()

stacked area plot pandas

Trazado de gráficos circulares con pandas {#trazado de gráficos circulares con pandas}

Los caracteres circulares son útiles cuando tenemos una pequeña cantidad de valores categóricos que necesitamos comparar. Son muy claros y van al grano, sin embargo, ten cuidado. La legibilidad de los gráficos circulares disminuye con el más mínimo aumento en el número de valores categóricos.

Para trazar gráficos circulares, usaremos la función pie() que tiene la siguiente sintaxis:

1
DataFrame.plot.pie(**kwargs)

Trazado de los perfiles de sabor:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import pandas as pd
import matplotlib.pyplot as plt

menu = pd.read_csv('indian_food.csv')

flavors = menu[menu.flavor_profile != '-1']
flavors['flavor_profile'].value_counts().plot.pie()

plt.legend()
plt.show()

Esto resulta en:

pie chart pandas

Con mucho, la mayoría de los platos son picantes y dulces.

Personalización de gráficos circulares

Para hacer que nuestro gráfico circular sea más atractivo, podemos modificarlo con los mismos argumentos de palabras clave que usamos en todos los gráficos alternativos anteriores, con algunas novedades:

  • sombra - Booleano que indica si las porciones del gráfico circular tienen una sombra
  • startangle - Ángulo inicial del gráfico circular

Para mostrar cómo funciona esto, tracemos las regiones de las que se originan los platos. Usaremos head() para tomar solo los primeros 10, para no tener demasiados cortes.

Hagamos el pastel rosa, con el título "Estados", démosle una sombra y una leyenda y hagamos que comience en el ángulo de 15:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import pandas as pd
import matplotlib.pyplot as plt

menu = pd.read_csv('indian_food.csv')
states = (menu[menu.state != '-1'])['state'].value_counts().head(10)

# Colors to circle through
colors = ['lightpink','pink','fuchsia','mistyrose','hotpink','deeppink','magenta']

states.plot.pie(colors = colors, shadow = True, startangle = 15, title = "States")

plt.show()

customize pie chart pandas

Trazado de diagramas de densidad con pandas

Si tiene alguna experiencia con las estadísticas, probablemente haya visto un gráfico de densidad. Los diagramas de densidad son una representación visual de la densidad de probabilidad en un rango de valores.

Un histograma es un gráfico de densidad, que agrupa puntos de datos en categorías. El segundo gráfico de densidad más popular es el gráfico KDE (Estimación de la densidad del kernel) - en términos simples, es como un histograma muy suave con un número infinito de contenedores.

Para trazar uno, usaremos la función kde():

1
DataFrame.plot.kde(bw_method=None, ind=None, **kwargs)

Por ejemplo, trazaremos el tiempo de cocción:

1
2
3
4
5
6
7
8
9
import pandas as pd
import matplotlib.pyplot as plt
import scipy

menu = pd.read_csv('indian_food.csv')

time = (menu[menu.cook_time != -1])['cook_time']
time.value_counts().plot.kde()
plt.show()

Esta distribución se ve así:
density plots with pandas

En la sección Histograma, hemos tenido problemas para capturar toda la información y los datos relevantes usando bins, porque cada vez que generalizamos y agrupamos los datos, perdemos algo de precisión.

Con los diagramas de KDE, tenemos la ventaja de usar un número infinito de bins. Ningún dato se trunca ni se pierde de esta manera.

Trazado de una matriz de dispersión (diagrama de pares) en pandas

Una forma un poco más compleja de interpretar datos es usar Scatter Matrices. Que son una forma de tener en cuenta la relación de cada par de parámetros. Si ha trabajado con otras bibliotecas, este tipo de gráfico le resultará familiar como un gráfico de pares.

Para trazar Scatter Matrix, necesitaremos importar la función scatter_matrix() desde el módulo pandas.plotting.

La sintaxis de la función scatter_matrix() es:

1
pandas.plotting.scatter_matrix(frame, alpha=0.5, figsize=None, ax=None, grid=False, diagonal='hist', marker='.', density_kwds=None, hist_kwds=None, range_padding=0.05, **kwargs)

Dado que estamos trazando relaciones por pares para varias clases, en una cuadrícula, todas las líneas diagonales en la cuadrícula quedarán obsoletas ya que compara la entrada consigo misma. Dado que esto sería un espacio muerto, las diagonales se reemplazan con un diagrama de distribución univariante para esa clase.

El parámetro diagonal puede ser 'kde' o 'hist' para Estimación de densidad del kernel o Gráficas de histograma.

Hagamos un gráfico de matriz de dispersión:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import pandas as pd 
import matplotlib.pyplot as plt
import scipy
from pandas.plotting import scatter_matrix

menu = pd.read_csv('indian_food.csv')

scatter_matrix(menu,diagonal='kde')

plt.show()

La trama debería verse así:
scatter matrix pandas

Trazado de un diagrama Bootstrap en Pandas

Pandas también ofrece un gráfico Bootstrap para sus necesidades de trazado. Un diagrama de Bootstrap es un diagrama que calcula algunas estadísticas diferentes con diferentes tamaños de submuestra. Luego, con los datos acumulados en las estadísticas, genera la distribución de las propias estadísticas.

Usarlo es tan simple como importar el método bootstrap_plot() desde el módulo pandas.plotting. La sintaxis de bootstrap_plot() es:

1
pandas.plotting.bootstrap_plot(series, fig=None, size=50, samples=500, **kwds)

Y finalmente, vamos a trazar un diagrama Bootstrap:

1
2
3
4
5
6
7
8
9
import pandas as pd
import matplotlib.pyplot as plt
import scipy
from pandas.plotting import bootstrap_plot

menu = pd.read_csv('indian_food.csv')

bootstrap_plot(menu['cook_time'])
plt.show()

El diagrama de arranque se verá así:
bootstrap plots in pandas

Conclusión

En esta guía, hemos repasado la introducción a Visualización de datos en Python con Pandas. Hemos cubierto gráficos básicos como gráficos circulares, gráficos de barras, progresamos a gráficos de densidad como histogramas y gráficos KDE.

Finalmente, hemos cubierto matrices de dispersión y diagramas de arranque.

Si te interesa la visualización de datos y no sabes por dónde empezar, asegúrate de consultar nuestro libro sobre [Visualización de datos en Python](https://gumroad.com/l/data-visualization-in -python).

Visualización de datos en Python, un libro para desarrolladores principiantes e intermedios de Python, lo guiará a través de la manipulación de datos simple con Pandas, cubrirá bibliotecas de trazado centrales como Matplotlib y Seaborn, y le mostrará cómo aprovechar bibliotecas declarativas y experimentales como Altair.

Visualización de datos en Python ¡Comprenda mejor sus datos con visualizaciones! Con 340 páginas, aprenderá los entresijos de la visualización de datos en Python con bibliotecas populares como Matplotlib, Seaborn, Bokeh y más.