Diagrama de línea de Seaborn - Tutorial y ejemplos

En este tutorial, veremos cómo trazar un diagrama de líneas usando Python y Seaborn. Trazaremos gráficos de líneas simples y avanzados utilizando un conjunto de datos del mundo real.

Introducción

Seaborn es una de las bibliotecas de visualización de datos más utilizadas en Python, como una extensión de Matplotlib. Ofrece una API simple, intuitiva pero altamente personalizable para la visualización de datos.

En este tutorial, veremos cómo trazar un gráfico de líneas en Seaborn, uno de los tipos de gráficos más básicos.

Los diagramas de líneas muestran valores numéricos en un eje y valores categóricos en el otro.

Por lo general, se pueden usar de la misma manera que Parcelas de barras, aunque, se usan más comúnmente para realizar un seguimiento de cambios a lo largo del tiempo.

Traza un diagrama de líneas con Seaborn

Comencemos con la forma más básica de completar datos para un gráfico de líneas, proporcionando un par de listas para el eje X y el eje Y a la función lineplot():

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

sns.set_theme(style="darkgrid")

x = [1, 2, 3, 4, 5]
y = [1, 5, 4, 7, 4]

sns.lineplot(x, y)
plt.show()

Aquí tenemos dos listas de valores, x e y. La lista x actúa como nuestra lista de variables categóricas, mientras que la lista y actúa como la lista de variables numéricas.

Este código da como resultado:

gráfico de línea simple seaborn

Con ese fin, podemos usar otros tipos de datos, como cadenas para el eje categórico:

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

sns.set_theme(style="darkgrid")

x = ['day 1', 'day 2', 'day 3']
y = [1, 5, 4]

sns.lineplot(x, y)
plt.show()

Y esto daría como resultado:

diagrama de líneas categóricas de seaborn

Nota: Si está utilizando números enteros como su lista categórica, como [1, 2, 3, 4, 5], pero luego procede a ir a 100, todos los valores entre 5. .100 será nulo:

1
2
3
4
5
6
7
8
9
import seaborn as sns

sns.set_theme(style="darkgrid")

x = [1, 2, 3, 4, 5, 10, 100]
y = [1, 5, 4, 7, 4, 5, 6]

sns.lineplot(x, y)
plt.show()

linea de valores perdidos de seaborn

Esto se debe a que un conjunto de datos podría simplemente faltar valores numéricos en el eje X. En ese caso, Seaborn simplemente nos permite suponer que faltan esos valores y los aleja. Sin embargo, cuando trabaja con cadenas, este no será el caso:

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

sns.set_theme(style="darkgrid")

x = ['day 1', 'day 2', 'day 3', 'day 100']
y = [1, 5, 4, 5]

sns.lineplot(x, y)
plt.show()

gráfico de líneas de valores categóricos faltantes de seaborn

Sin embargo, por lo general, no trabajamos con listas simples hechas a mano como esta. Trabajamos con datos importados de conjuntos de datos más grandes o extraídos directamente de bases de datos. Importemos un conjunto de datos y trabajemos con él en su lugar.

Importar datos

Usemos el conjunto de datos Reservas de hotel y usemos los datos de allí:

1
2
3
import pandas as pd
df = pd.read_csv('hotel_bookings.csv')
print(df.head())

Echemos un vistazo a las columnas de este conjunto de datos:

1
2
3
4
5
6
          hotel  is_canceled reservation_status  ... arrival_date_month  stays_in_week_nights
0  Resort Hotel            0          Check-Out  ...               July                     0
1  Resort Hotel            0          Check-Out  ...               July                     0
2  Resort Hotel            0          Check-Out  ...               July                     1
3  Resort Hotel            0          Check-Out  ...               July                     1
4  Resort Hotel            0          Check-Out  ...               July                     2

Esta es una vista truncada, ya que hay muchas columnas en este conjunto de datos. Por ejemplo, exploremos este conjunto de datos usando arrival_date_month como nuestro eje X categórico, mientras usamos stays_in_week_nights como nuestro eje Y numérico:

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

sns.set_theme(style="darkgrid")

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

sns.lineplot(x = "arrival_date_month", y = "stays_in_week_nights", data = df)
plt.show()

Hemos usado Pandas para leer los datos CSV y empaquetarlos en un DataFrame. Luego, podemos asignar los argumentos x e y de la función lineplot() como los nombres de las columnas en ese marco de datos. Por supuesto, tendremos que especificar con qué conjunto de datos estamos trabajando asignando el marco de datos al argumento data.

Ahora, esto resulta en:

seaborn dataset line plot

Podemos ver claramente que las estancias entre semana tienden a ser más largas durante los meses de junio, julio y agosto (vacaciones de verano), mientras que son las más bajas en enero y febrero, justo después de la cadena de vacaciones que preceden al Año Nuevo.

Además, puede ver el intervalo de confianza como el área alrededor de la línea misma, que es la tendencia central estimada de nuestros datos. Dado que tenemos varios valores de y para cada valor de x (muchas personas se quedaron cada mes), Seaborn calcula la tendencia central de estos registros y traza esa línea, así como un intervalo de confianza para esa tendencia.

En general, la gente se queda ~2,8 ​​días entre semana, en julio, pero el intervalo de confianza va de 2,78 a 2,84.

Trazado de datos de formato ancho

Ahora, echemos un vistazo a cómo podemos trazar datos de forma amplia, en lugar de forma ordenada como lo hemos estado haciendo hasta ahora. Querremos visualizar la variable stays_in_week_nights a lo largo de los meses, pero también querremos tener en cuenta el año de esa llegada. Esto dará como resultado un diagrama de líneas para cada año, a lo largo de los meses, en una sola figura.

Dado que el conjunto de datos no es adecuado para esto de forma predeterminada, tendremos que realizar un preprocesamiento de datos en él.

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

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

# Truncate
df = df[['arrival_date_year', 'arrival_date_month', 'stays_in_week_nights']]
# Save the order of the arrival months
order = df['arrival_date_month']
# Pivot the table to turn it into wide-form
df_wide = df.pivot_table(index='arrival_date_month', columns='arrival_date_year', values='stays_in_week_nights')
# Reindex the DataFrame with the `order` variable to keep the same order of months as before
df_wide = df_wide.reindex(order, axis=0)

print(df_wide)

Aquí, primero hemos truncado el conjunto de datos a algunas columnas relevantes. Luego, hemos guardado el orden de los meses de fecha de llegada para que podamos conservarlo para más adelante. Sin embargo, puede poner cualquier orden aquí.

Luego, para convertir los datos de forma estrecha en una forma amplia, hemos girado la tabla alrededor de la característica llegada_fecha_mes, convirtiendo llegada_fecha_año en columnas y permanencias_en_semana_noches en valores. Finalmente, hemos usado reindex() para hacer cumplir el mismo orden de llegada de los meses que teníamos antes.

Echemos un vistazo a cómo se ve nuestro conjunto de datos ahora:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
arrival_date_year       2015      2016      2017
arrival_date_month
July                2.789625  2.836177  2.787502
July                2.789625  2.836177  2.787502
July                2.789625  2.836177  2.787502
July                2.789625  2.836177  2.787502
July                2.789625  2.836177  2.787502
...                      ...       ...       ...
August              2.654153  2.859964  2.956142
August              2.654153  2.859964  2.956142
August              2.654153  2.859964  2.956142
August              2.654153  2.859964  2.956142
August              2.654153  2.859964  2.956142

¡Excelente! Nuestro conjunto de datos ahora tiene el formato correcto para una visualización amplia, con la tendencia central de stays_in_week_nights calculada. Ahora que estamos trabajando con un conjunto de datos de formato ancho, todo lo que tenemos que hacer para trazarlo es:

1
2
sns.lineplot(data=df_wide)
plt.show()

La función lineplot() puede reconocer de forma nativa conjuntos de datos de formato ancho y trazarlos en consecuencia. Esto resulta en:

wide form dataset seaborn line plot

Personalización de diagramas de líneas con Seaborn

Ahora que hemos explorado cómo trazar datos insertados manualmente, cómo trazar características de conjuntos de datos simples, así como manipular un conjunto de datos para ajustarse a un tipo diferente de visualización, echemos un vistazo a cómo podemos personalizar nuestra línea. parcelas para proporcionar información más fácil de digerir.

Trazado Gráfico de líneas con matices

Tonos se pueden usar para segregar un conjunto de datos en múltiples gráficos de líneas individuales, en función de una característica por la que le gustaría que se agruparan (tonos). Por ejemplo, podemos visualizar la tendencia central de la característica stays_in_week_nights, a lo largo de los meses, pero tener en cuenta también arrival_date_year y agrupar gráficos de líneas individuales en función de esa característica.

Esto es exactamente lo que hemos hecho en el ejemplo anterior: manualmente. Hemos convertido el conjunto de datos en un marco de datos de formato ancho y lo hemos trazado. Sin embargo, también podríamos haber agrupado los años en tonos, lo que nos daría exactamente el mismo resultado:

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

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

sns.lineplot(x = "arrival_date_month", y = "stays_in_week_nights", hue='arrival_date_year', data = df)
plt.show()

Al configurar la función fecha_de_llegada_año como el argumento tono, le hemos dicho a Seaborn que segregue cada mapeo X-Y por la función fecha_de_llegada_año, por lo que terminaremos con tres diagramas de líneas diferentes:

tonos de trazado de líneas de seaborn

Esta vez, también tenemos intervalos de confianza marcados alrededor de nuestras tendencias centrales.

Personalizar el intervalo de confianza del gráfico de líneas con Seaborn

Puede jugar, habilitar/deshabilitar y cambiar el tipo de intervalos de confianza fácilmente usando un par de argumentos. El argumento ci se puede usar para especificar el tamaño del intervalo y se puede establecer en un número entero, 'sd' (desviación estándar) o Ninguno si desea desactivarlo.

El err_style se puede utilizar para especificar el estilo de los intervalos de confianza: banda o barras. Hemos visto cómo funcionan las bandas hasta ahora, así que probemos un intervalo de confianza que use barras en su lugar:

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

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

sns.lineplot(x = "arrival_date_month", y = "stays_in_week_nights", err_style='bars', data = df)
plt.show()

Esto resulta en:

seaborn personaliza el diagrama de líneas del intervalo de confianza

Y cambiemos el intervalo de confianza, que está configurado de forma predeterminada en 95, para mostrar la desviación estándar en su lugar:

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

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

sns.lineplot(x = "arrival_date_month", y = "stays_in_week_nights", err_style='bars', ci='sd', data = df)
plt.show()

intervalo de confianza del diagrama de líneas seaborn

Conclusión

En este tutorial, hemos repasado varias formas de trazar un diagrama de líneas en Seaborn. Hemos echado un vistazo a cómo trazar gráficos simples, con ejes X numéricos y categóricos, después de lo cual importamos un conjunto de datos y lo visualizamos.

Hemos explorado cómo manipular conjuntos de datos y cambiar su forma para visualizar múltiples funciones, así como también cómo personalizar gráficos de líneas.

Si está interesado en Visualización de datos y no sabe por dónde empezar, asegúrese de consultar nuestro paquete de libros en [Visualización de datos en Python](https://gum.co/data-visualization -en-paquete-de-libros-de-python):

Visualización de datos en Python Vuélvase peligroso con la visualización de datos ✅ Garantía de devolución de dinero de 30 días sin preguntas ✅ Principiante a Avanzado ✅ Actualizado periódicamente de forma gratuita (última actualización en abril de 2021) ✅ Actualizado con recursos y guías adicionales

Visualización de datos en Python con Matplotlib y Pandas es un libro diseñado para llevar a los principiantes absolutos a Pandas y Matplotlib, con conocimientos básicos de Python, y permitirles construir una base sólida para el trabajo avanzado con estas bibliotecas, desde gráficos simples. a gráficos 3D animados con botones interactivos.

Sirve como una guía detallada que le enseñará todo lo que necesita saber sobre Pandas y Matplotlib, incluido cómo construir tipos de gráficos que no están integrados en la propia biblioteca.

Visualización de datos en Python, un libro para desarrolladores principiantes e intermedios de Python, lo guía a través de la manipulación de datos simple con Pandas, cubre bibliotecas de trazado centrales como Matplotlib y Seaborn, y le muestra cómo aprovechar las bibliotecas declarativas y experimentales. como Altair. Más específicamente, a lo largo de 11 capítulos, este libro cubre 9 bibliotecas de Python: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas y VisPy.

Sirve como una guía práctica única para la visualización de datos, en una plétora de herramientas que podría usar en su carrera. rrera.