Tutorial Seaborn: Gráficos bivariantes

¿Qué son las gráficas bivariantes?

Las gráficas bivariantes son herramientas de visualización que permiten analizar la relación entre dos variables, ya sean numéricas o categóricas. Estas representaciones facilitan la comprensión de cómo una variable puede influir en otra, mostrando patrones, tendencias y posibles correlaciones dentro de un conjunto de datos.

En el análisis de datos, es esencial entender la interacción entre las variables para descubrir insights significativos. Las gráficas bivariantes permiten visualizar esta interacción de manera clara, ayudando a identificar relaciones lineales, no lineales o incluso la ausencia de relación entre las variables estudiadas.

Seaborn, una biblioteca de Python especializada en visualización estadística, ofrece funciones intuitivas para crear gráficas bivariantes de alta calidad. Gracias a su integración con pandas y numpy, Seaborn facilita la creación de visualizaciones informativas con código conciso y sencillo.

Por ejemplo, para comenzar a utilizar Seaborn en el análisis bivariante, primero es necesario importar la biblioteca y cargar un conjunto de datos adecuado:

import seaborn as sns
import matplotlib.pyplot as plt

datos = sns.load_dataset('tips')

A continuación, es posible crear una gráfica que muestre la relación entre dos variables específicas. Aunque profundizaremos en los tipos de gráficas en secciones posteriores, aquí se presenta un ejemplo básico para visualizar cómo la propina varía según el total de la cuenta:

sns.scatterplot(data=datos, x='total_bill', y='tip')
plt.show()

Este sencillo código genera una gráfica de dispersión que proporciona una perspectiva inicial sobre cómo se relacionan las propinas con el total de la factura en un restaurante. Es un primer paso para detectar si existe algún patrón o tendencia entre estas dos variables.

Es importante recordar que la elección del tipo de gráfica y las variables adecuadas es crucial para obtener visualizaciones significativas. Seaborn ofrece una variedad de opciones que permiten adaptar las gráficas a las necesidades específicas del análisis, lo que exploraremos detalladamente en las próximas secciones.

Gráficas de Dispersión (Scatter Plots)

Las gráficas de dispersión son una herramienta esencial para visualizar la relación entre dos variables numéricas. En Seaborn, se pueden crear fácilmente para identificar patrones, tendencias y posibles correlaciones en los datos.

Para empezar, es necesario importar las bibliotecas necesarias y cargar un conjunto de datos adecuado:

import seaborn as sns
import matplotlib.pyplot as plt

datos = sns.load_dataset('iris')

La función principal para crear gráficas de dispersión en Seaborn es scatterplot(). 

A continuación, se muestra cómo generar una gráfica básica que representa la relación entre la longitud y el ancho de los pétalos en el conjunto de datos 'iris':

sns.scatterplot(data=datos, x='petal_length', y='petal_width')
plt.show()

Esta gráfica permite observar cómo se distribuyen las muestras y si existe alguna relación entre las dos variables. Es posible que se identifiquen tendencias lineales o agrupaciones que indiquen diferentes categorías en los datos.

Para enriquecer la visualización y añadir una tercera variable categórica, se puede utilizar el parámetro hue para colorear los puntos según la especie de la flor:

sns.scatterplot(data=datos, x='petal_length', y='petal_width', hue='species')
plt.show()

Ahora, los puntos están coloreados según la especie, lo que facilita distinguir entre diferentes grupos y puede revelar diferencias significativas entre ellos.

Además de colorear, es posible ajustar el tamaño de los puntos con el parámetro size y cambiar su forma utilizando style:

sns.scatterplot(data=datos, x='petal_length', y='petal_width', hue='species', size='sepal_width', style='species')
plt.show()

Con esta configuración, el tamaño de cada punto representa el ancho del sépalo, proporcionando una dimensión adicional de información. La forma de los puntos sigue diferenciando las especies.

En casos donde los datos son muy densos, puede ser útil ajustar el nivel de transparencia de los puntos con el parámetro alpha para evitar la superposición y mejorar la legibilidad:

sns.scatterplot(data=datos, x='petal_length', y='petal_width', alpha=0.7)
plt.show()

La personalización de la gráfica es clave para transmitir la información de manera clara. Seaborn permite modificar aspectos estéticos como la paleta de colores con palette:

sns.scatterplot(data=datos, x='petal_length', y='petal_width', hue='species', palette='Set2')
plt.show()

Es importante etiquetar adecuadamente los ejes y añadir un título para contextualizar la gráfica:

sns.scatterplot(data=datos, x='petal_length', y='petal_width', hue='species')
plt.xlabel('Longitud del pétalo')
plt.ylabel('Ancho del pétalo')
plt.title('Relación entre longitud y ancho del pétalo por especie')
plt.show()

En resumen, las gráficas de dispersión en Seaborn son una forma eficaz de explorar y visualizar relaciones entre variables numéricas. Gracias a su flexibilidad y facilidad de uso, es posible crear visualizaciones informativas que ayuden en el análisis y comprensión de los datos.

Gráficas de Línea (comparación de dos variables)

Las gráficas de línea son fundamentales para visualizar cómo una variable numérica cambia en relación con otra, permitiendo identificar tendencias y patrones en los datos. En Seaborn, la función lineplot() facilita la creación de estas gráficas de manera sencilla y efectiva.

Para empezar, es necesario importar las bibliotecas esenciales y cargar un conjunto de datos adecuado. En este ejemplo, utilizaremos el conjunto de datos 'fmri', que incluye mediciones de actividad cerebral durante diferentes eventos:

import seaborn as sns
import matplotlib.pyplot as plt

datos = sns.load_dataset('fmri')

La función lineplot() se emplea para generar la gráfica básica que muestra la señal en función del tiempo:

sns.lineplot(data=datos, x='timepoint', y='signal')
plt.show()

Esta gráfica representa cómo la señal neuronal varía a lo largo del tiempo. Para enriquecer la visualización, podemos agregar variables categóricas utilizando el parámetro hue. Por ejemplo, diferenciamos los tipos de evento:

sns.lineplot(data=datos, x='timepoint', y='signal', hue='event')
plt.show()

Ahora, las líneas se colorean según el tipo de evento, lo que facilita la comparación entre ellos. Si deseamos distinguir aún más las líneas, podemos utilizar el parámetro style para variar el estilo según otra variable categórica, como la región:

sns.lineplot(data=datos, x='timepoint', y='signal', hue='event', style='region')
plt.show()

Con esta modificación, cada combinación de evento y región tiene una representación única, permitiendo un análisis más detallado de las interacciones entre variables.

Cuando los datos contienen múltiples observaciones para cada valor en el eje x, Seaborn calcula automáticamente la media y muestra un intervalo de confianza alrededor de la línea, reflejando la variabilidad de los datos:

sns.lineplot(data=datos, x='timepoint', y='signal', hue='event', errorbar='sd')
plt.show()

Si preferimos eliminar el intervalo de confianza, podemos establecer el parámetro errorbar en None:

sns.lineplot(data=datos, x='timepoint', y='signal', hue='event', errorbar=None)
plt.show()

La personalización es clave para mejorar la claridad de la gráfica. Podemos ajustar las etiquetas de los ejes, el título y la ubicación de la leyenda:

sns.lineplot(data=datos, x='timepoint', y='signal', hue='event', style='region')
plt.xlabel('Tiempo')
plt.ylabel('Señal')
plt.title('Actividad neuronal por evento y región')
plt.legend(title='Evento', loc='upper right')
plt.show()

También es posible modificar la paleta de colores para adaptarla a nuestras preferencias o necesidades de presentación:

sns.lineplot(data=datos, x='timepoint', y='signal', hue='event', palette='dark')
plt.show()

Para ilustrar el uso de gráficas de línea con datos temporales, utilizaremos el conjunto de datos 'flights', que registra el número de pasajeros aéreos por mes y año:

datos_vuelos = sns.load_dataset('flights')

Podemos representar la tendencia de pasajeros a lo largo de los años:

sns.lineplot(data=datos_vuelos, x='year', y='passengers')
plt.xlabel('Año')
plt.ylabel('Pasajeros')
plt.title('Tendencia anual de pasajeros aéreos')
plt.show()

Esta gráfica muestra un incremento en el número de pasajeros con el paso del tiempo, evidenciando una tendencia positiva. Si deseamos analizar patrones estacionales, podemos graficar el número de pasajeros por mes:

sns.lineplot(data=datos_vuelos, x='month', y='passengers', hue='year', palette='coolwarm')
plt.xlabel('Mes')
plt.ylabel('Pasajeros')
plt.title('Pasajeros aéreos por mes y año')
plt.legend(title='Año', bbox_to_anchor=(1.05, 1), loc=2)
plt.show()

Esta representación permite comparar cómo varía el número de pasajeros en cada mes para diferentes años, identificando posibles patrones estacionales.

En resumen, las gráficas de línea en Seaborn son una herramienta versátil para analizar la relación entre dos variables, especialmente cuando es necesario visualizar cambios a lo largo de un eje continuo, como el tiempo. La función lineplot() ofrece múltiples opciones de personalización que facilitan la creación de visualizaciones informativas y estéticamente agradables.

Diagramas de Calor (Heatmaps)

Los diagramas de calor, también conocidos como heatmaps, son representaciones gráficas que utilizan colores para mostrar la magnitud de los valores de una variable en dos dimensiones. Son especialmente útiles para visualizar matrices de datos, correlaciones y distribuciones, permitiendo identificar rápidamente patrones y relaciones en los conjuntos de datos.

Para comenzar, es necesario importar las bibliotecas esenciales y cargar un conjunto de datos adecuado. En este caso, utilizaremos el conjunto de datos flights, que contiene información sobre el número de pasajeros aéreos por mes y año:

import seaborn as sns
import matplotlib.pyplot as plt

datos_vuelos = sns.load_dataset('flights')

Antes de crear el diagrama de calor, es necesario reorganizar el conjunto de datos en una forma de tabla cruzada o pivote, donde las filas representen los años, las columnas los meses y los valores sean el número de pasajeros:

tabla_pivote = datos_vuelos.pivot(index='month', columns='year', values='passengers')

Una vez preparada la tabla pivote, podemos utilizar la función heatmap() de Seaborn para generar el diagrama de calor:

sns.heatmap(tabla_pivote)
plt.show()

Este código produce un diagrama de calor básico donde los colores representan el número de pasajeros, permitiendo visualizar las variaciones a lo largo del tiempo. Para mejorar la legibilidad y proporcionar contexto adicional, es posible ajustar diversos parámetros.

Por ejemplo, podemos añadir anotaciones que muestren los valores numéricos en cada celda:

sns.heatmap(tabla_pivote, annot=True, fmt='d')
plt.show()

El parámetro annot=True habilita las anotaciones, mientras que fmt='d' especifica que los valores son enteros. Esto facilita la comprensión de los datos exactos representados en cada celda.

Además, es posible ajustar la paleta de colores para resaltar mejor las diferencias en los datos. Seaborn ofrece diversas paletas predefinidas, y también permite crear paletas personalizadas. Por ejemplo, podemos utilizar la paleta 'YlGnBu':

sns.heatmap(tabla_pivote, cmap='YlGnBu', annot=True, fmt='d')
plt.show()

La elección de una paleta adecuada es importante para asegurar que los colores sean intuitivos y accesibles para todos los usuarios, incluyendo aquellos con dificultades visuales.

Para resaltar valores altos o bajos, podemos utilizar el parámetro center para definir un punto medio en el mapa de colores. Si queremos centrar el mapa en el valor promedio de pasajeros, calculamos la media y la aplicamos:

media_pasajeros = datos_vuelos['passengers'].mean()
sns.heatmap(tabla_pivote, cmap='coolwarm', center=media_pasajeros, annot=True, fmt='d')
plt.show()

Este ajuste permite visualizar más claramente qué valores están por encima o por debajo de la media.

En ocasiones, es útil normalizar los datos para facilitar la comparación entre distintas categorías. Podríamos calcular la proporción de pasajeros respecto al total anual:

tabla_pivote_normalizada = tabla_pivote.div(tabla_pivote.sum(axis=0), axis=1)
sns.heatmap(tabla_pivote_normalizada, cmap='viridis')
plt.show()

La normalización nos ayuda a identificar meses que tienen una mayor o menor proporción de pasajeros en comparación con el total del año.

Además de visualizar datos numéricos, los diagramas de calor son valiosos para representar matrices de correlación. Por ejemplo, utilizando el conjunto de datos tips, que contiene información sobre propinas en un restaurante:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

datos_propinas = sns.load_dataset('tips')

# Seleccionar solo las columnas numéricas
matriz_correlacion = datos_propinas.select_dtypes(include=[np.number]).corr()
sns.heatmap(matriz_correlacion, annot=True, cmap='coolwarm')
plt.show()

Este diagrama de calor muestra las correlaciones entre las variables numéricas del conjunto de datos, permitiendo identificar relaciones positivas o negativas entre ellas.

Para mejorar aún más la presentación, podemos ajustar la rotación de las etiquetas y eliminar la visualización de la parte superior de la matriz que es redundante:

mascara = np.triu(np.ones_like(matriz_correlacion, dtype=bool))
sns.heatmap(matriz_correlacion, annot=True, cmap='coolwarm', mask=mascara)
plt.xticks(rotation=45)
plt.yticks(rotation=0)
plt.show()

En este ejemplo, utilizamos np.triu para enmascarar la mitad superior de la matriz, ya que la correlación es simétrica. También ajustamos la rotación de las etiquetas de los ejes para mejorar la legibilidad.

Los diagramas de calor son herramientas versátiles para analizar y visualizar datos complejos. Al combinar color y datos numéricos en una matriz bidimensional, facilitan la identificación de patrones y tendencias ocultas en los datos.

Gráficos de Barras Apiladas y Agrupadas

Los gráficos de barras son una herramienta efectiva para visualizar y comparar datos categóricos. En Seaborn, es posible crear gráficos de barras agrupadas y, con la ayuda de pandas y matplotlib, también podemos elaborar gráficos de barras apiladas para analizar múltiples variables categóricas de manera simultánea.

Para comenzar, importamos las bibliotecas necesarias y cargamos un conjunto de datos adecuado. Utilizaremos el conjunto de datos tips, que contiene información sobre las propinas en un restaurante:

import seaborn as sns
import matplotlib.pyplot as plt

datos = sns.load_dataset('tips')

Gráficos de Barras Agrupadas

Los gráficos de barras agrupadas permiten comparar una métrica entre diferentes categorías y subcategorías. Empleamos la función catplot() de Seaborn con el parámetro kind='bar' para crear este tipo de gráfica.

Por ejemplo, para comparar el promedio de propinas según el día de la semana y el sexo del camarero o camarera:

sns.catplot(data=datos, x='day', y='tip', hue='sex', kind='bar', errorbar=None)
plt.ylabel('Propina promedio')
plt.title('Propina promedio por día y sexo')
plt.show()

En esta gráfica, cada grupo de barras representa un día de la semana, y las barras dentro de cada grupo distinguen entre sexo, gracias al parámetro hue='sex'. El argumento ci=None elimina los intervalos de confianza para simplificar la visualización.

Podemos personalizar la paleta de colores para mejorar la claridad y estética de la gráfica:

sns.catplot(data=datos, x='day', y='tip', hue='sex', kind='bar', errorbar=None, palette='Set2')
plt.ylabel('Propina promedio')
plt.title('Propina promedio por día y sexo')
plt.show()

Gráficos de Barras Apiladas

Aunque Seaborn no ofrece una función directa para crear gráficos de barras apiladas, podemos lograrlo combinando pandas y matplotlib. Primero, reorganizamos los datos utilizando una tabla dinámica:

tabla_pivot = datos.pivot_table(values='tip', index='day', columns='sex', aggfunc='sum', observed=False)

La tabla resultante presenta los días de la semana como filas y el sexo como columnas, con las sumas de las propinas como valores. Ahora, creamos el gráfico de barras apiladas:

tabla_pivot.plot(kind='bar', stacked=True, color=['#ff9999','#66b3ff'])
plt.ylabel('Propina total')
plt.title('Propina total por día y sexo (apilado)')
plt.legend(title='Sexo')
plt.xticks(rotation=0)
plt.show()

En este gráfico, las barras muestran la propina total por día, apilando las contribuciones de cada categoría de sexo. Esto permite visualizar no solo los totales, sino también cómo se compone cada total.

Añadiendo etiquetas de datos

Para facilitar la interpretación de los datos, podemos añadir etiquetas a cada segmento de las barras que muestren los valores numéricos:

ax = tabla_pivot.plot(kind='bar', stacked=True, color=['#ff9999','#66b3ff'])
plt.ylabel('Propina total')
plt.title('Propina total por día y sexo (apilado)')
plt.legend(title='Sexo')
plt.xticks(rotation=0)

for container in ax.containers:
    ax.bar_label(container, fmt='%.2f', label_type='center')

plt.show()

La función bar_label() añade etiquetas a cada segmento, y label_type='center' posiciona las etiquetas en el centro de cada segmento de barra.

Gráficos de Barras Apiladas con porcentajes

Para visualizar la proporción que cada subcategoría representa dentro del total, podemos convertir los valores en porcentajes:

tabla_porcentajes = tabla_pivot.div(tabla_pivot.sum(axis=1), axis=0)

ax = tabla_porcentajes.plot(kind='bar', stacked=True, color=['#ff9999','#66b3ff'])
plt.ylabel('Proporción de propinas')
plt.title('Proporción de propinas por día y sexo')
plt.legend(title='Sexo')
plt.xticks(rotation=0)

for container in ax.containers:
    labels = [f'{v.get_height()*100:.1f}%' for v in container]
    ax.bar_label(container, labels=labels, label_type='center')

plt.show()

Con este gráfico, podemos apreciar la distribución porcentual de las propinas según el día y el sexo, lo que es útil para identificar patrones en los datos.

Gráficos de Barras Simples con barplot()

Para casos más sencillos, la función barplot() de Seaborn permite crear gráficos de barras de manera directa. Por ejemplo, si deseamos visualizar el total de propinas por día:

sns.barplot(data=datos, x='day', y='tip', estimator=sum, errorbar=None, color='lightblue')
plt.ylabel('Propina total')
plt.title('Propina total por día')
plt.show()

En este caso, estimator=sum indica que se sumarán las propinas para cada día, y errorbar=None suprime el intervalo de confianza.

Personalización y estilo

La personalización de las gráficas es clave para una comunicación efectiva. Podemos ajustar estilos utilizando Seaborn:

sns.set_style('whitegrid')

sns.catplot(data=datos, x='day', y='total_bill', hue='sex', kind='bar', errorbar=None, palette='muted')
plt.ylabel('Cuenta total promedio')
plt.title('Cuenta total promedio por día y sexo')
plt.show()

El ajuste del estilo con sns.set_style('whitegrid') mejora la legibilidad y presentación de las gráficas.

Ordenando las categorías

Para ordenar las categorías en el eje x, podemos utilizar el parámetro order:

dias = ['Thur', 'Fri', 'Sat', 'Sun']

sns.catplot(data=datos, x='day', y='tip', hue='sex', kind='bar', errorbar=None, order=dias)
plt.ylabel('Propina promedio')
plt.title('Propina promedio por día ordenado')
plt.show()

Esta configuración nos permite controlar el orden en el que se presentan las categorías, lo que puede ser útil para resaltar secuencias lógicas o cronológicas.

Gráficos de regresión

Los gráficos de regresión son herramientas fundamentales para analizar y visualizar la relación entre dos variables, permitiendo representar tendencias y patrones en los datos. En Seaborn, es posible crear gráficos de regresión de manera sencilla utilizando funciones especializadas que combinan plots de dispersión con líneas de regresión ajustadas.

Para comenzar, importamos las bibliotecas necesarias y cargamos un conjunto de datos adecuado. En este caso, utilizaremos el conjunto de datos tips, que contiene información sobre las cuentas y propinas en un restaurante:

import seaborn as sns
import matplotlib.pyplot as plt

datos = sns.load_dataset('tips')

La función regplot() de Seaborn permite crear un gráfico de dispersión con una línea de regresión ajustada automáticamente. Por ejemplo, para analizar la relación entre el total de la cuenta y la propina:

sns.regplot(data=datos, x='total_bill', y='tip')
plt.xlabel('Total de la cuenta')
plt.ylabel('Propina')
plt.title('Relación entre la cuenta y la propina')
plt.show()

En este gráfico, los puntos representan las observaciones y la línea muestra la tendencia general entre las variables. Seaborn calcula y dibuja la línea de regresión lineal por defecto, junto con un intervalo de confianza.

Si queremos analizar la distribución residual y la adecuación del modelo lineal, podemos utilizar la función residplot(), que grafica los residuos de la regresión:

sns.residplot(data=datos, x='total_bill', y='tip')
plt.xlabel('Total de la cuenta')
plt.ylabel('Residuo')
plt.title('Análisis de residuos')
plt.show()

Para incluir una variable categórica y ver cómo afecta la relación, podemos utilizar la función lmplot(), que permite especificar hue para distinguir categorías. Por ejemplo, analicemos la relación entre el total de la cuenta y la propina diferenciando por sexo:

sns.lmplot(data=datos, x='total_bill', y='tip', hue='sex')
plt.xlabel('Total de la cuenta')
plt.ylabel('Propina')
plt.title('Propina vs. cuenta por sexo')
plt.show()

En este caso, Seaborn ajusta una línea de regresión para cada categoría de sexo, permitiendo comparar las tendencias entre hombres y mujeres.

Si además queremos separar las gráficas por otra variable categórica, podemos utilizar el parámetro col. Por ejemplo, veamos cómo varía la relación según si el cliente fumaba o no:

sns.lmplot(data=datos, x='total_bill', y='tip', hue='sex', col='smoker')
plt.xlabel('Total de la cuenta')
plt.ylabel('Propina')
plt.suptitle('Propina vs. cuenta por sexo y hábito de fumar')
plt.tight_layout()
plt.show()

Aquí, las gráficas se dividen en columnas según la variable smoker, mostrando aún más detalle en el análisis.

La función scatterplot() combinada con lineplot() también permite personalizar gráficos de regresión. Podemos crear un gráfico de dispersión y añadir una línea de regresión calculada manualmente. Por ejemplo:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
from scipy import stats

datos = sns.load_dataset('tips')

# Crear gráfico de dispersión
sns.scatterplot(data=datos, x='total_bill', y='tip')
plt.xlabel('Total de la cuenta')
plt.ylabel('Propina')
plt.title('Propina vs. Total de la cuenta')

# Calcular línea de regresión
slope, intercept, r_value, p_value, std_err = stats.linregress(datos['total_bill'], datos['tip'])
x = np.linspace(datos['total_bill'].min(), datos['total_bill'].max(), 100)
y = intercept + slope * x

# Añadir línea de regresión
plt.plot(x, y, color='red')
plt.show()

Este método brinda mayor control sobre el modelo de regresión utilizado y permite personalizar el análisis estadístico.

Seaborn también soporta modelos de regresión no lineales. Si sospechamos que la relación entre las variables es no lineal, podemos ajustar un modelo polinomial utilizando el parámetro order. Por ejemplo, para ajustar un polinomio de segundo grado:

sns.regplot(data=datos, x='total_bill', y='tip', order=2)
plt.xlabel('Total de la cuenta')
plt.ylabel('Propina')
plt.title('Regresión polinomial de grado 2')
plt.show()

Para manejar relaciones donde la dispersión de los datos varía a lo largo del eje x, podemos utilizar una regresión robusta con el parámetro robust=True:

sns.regplot(data=datos, x='total_bill', y='tip', robust=True)
plt.xlabel('Total de la cuenta')
plt.ylabel('Propina')
plt.title('Regresión lineal robusta')
plt.show()

Esto hace que el modelo sea menos sensible a valores atípicos, proporcionando una estimación más fiable de la tendencia central.

Si nos interesa visualizar la distribución conjunta y marginal de las variables, podemos emplear la función jointplot() con kind='reg':

sns.jointplot(data=datos, x='total_bill', y='tip', kind='reg')
plt.show()

Este gráfico combina el análisis bivariante con histogramas univariantes, ofreciendo una visión más completa de los datos.

Para ajustar modelos de regresión más complejos, como regresiones logísticas, Seaborn permite especificar la familia de modelos estadísticos utilizando el parámetro logistic=True. Por ejemplo, si tuviéramos una variable binaria:

# Suponiendo que tenemos una variable binaria 'alta_propina'
datos['alta_propina'] = (datos['tip'] > datos['tip'].median()).astype(int)

sns.regplot(data=datos, x='total_bill', y='alta_propina', logistic=True, scatter_kws={'alpha':0.3})
plt.xlabel('Total de la cuenta')
plt.ylabel('Probabilidad de alta propina')
plt.title('Regresión logística')
plt.show()

En este ejemplo, la gráfica muestra la probabilidad de dejar una propina alta en función del total de la cuenta.

Es importante ajustar y personalizar los gráficos para mejorar su interpretabilidad. Seaborn ofrece diversos parámetros para modificar aspectos estéticos, como los colores, marcadores y estilos de línea.