A Full Information to Seaborn

Picture by Editor

# Introduction

 
Seaborn is a statistical visualization library for Python that sits on prime of Matplotlib. It offers you clear defaults, tight integration with Pandas DataFrames, and high-level features that scale back boilerplate. In case you already know Matplotlib and wish sooner, extra informative plots, this information is for you.

The main target right here is intermediate to superior utilization. You’ll work with relational, categorical, distribution, and regression plots, then transfer into grid layouts and matrix visuals that reply actual analytical questions. Anticipate brief code blocks, exact explanations, and sensible parameter decisions that have an effect on readability and accuracy.

What this information covers:

• Arrange themes and palettes you’ll be able to reuse throughout initiatives
• Plots that matter for evaluation: scatterplot, lineplot, boxplot, violinplot, histplot, kdeplot, regplot, lmplot
• Excessive-dimensional layouts with FacetGrid, PairGrid, relplot, and catplot
• Correlation and heatmaps with appropriate coloration scales, masking, and annotation
• Exact management by way of Matplotlib hooks for titles, ticks, legends, and annotations
• Efficiency suggestions for big datasets and fixes for frequent pitfalls

You’ll study when to make use of confidence intervals, learn how to handle legends in crowded visuals, learn how to hold class colours constant, and when to modify again to Matplotlib for fantastic management. The purpose is obvious, correct plots that talk findings with out further work.

# Setup and Styling Baseline

 
This part units a constant visible baseline so each plot within the article seems skilled and export-ready. We are going to set up, import, set a worldwide theme, select sensible palettes, and lock in determine sizing and DPI for clear outputs.

// Set up and import

Use a clear atmosphere and set up Seaborn and Matplotlib.

pip set up seaborn matplotlib

Normal imports:

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

Two fast checks that assist keep away from surprises:

// Venture-wide theme in a single line

Set a default type as soon as, then give attention to the evaluation as a substitute of fixed styling tweaks.

sns.set_theme(
    context="discuss",      # textual content measurement scaling: paper, pocket book, discuss, poster
    type="whitegrid",   # clear background with gentle grid
    palette="deep"       # readable, colorblind conscious categorical palette
)

Why this issues:

• context="discuss" offers readable axis labels and titles for slides and reviews
• type="whitegrid" improves worth studying for line and bar plots with out heavy visible noise
• palette="deep" supplies distinct class colours that maintain up when printed or projected

You possibly can override any of those per plot, however setting them globally retains the look uniform.

// Palettes you’ll truly use

Select palettes that talk the info sort. Use discrete palettes for classes and colormaps for steady values.

1. Viridis for steady scales

# Discrete colours for classes
cats = sns.color_palette("viridis", n_colors=5)

# Steady colormap for heatmaps and densities
viridis_cmap = sns.color_palette("viridis", as_cmap=True)

• Viridis preserves element throughout gentle and darkish backgrounds and is perceptually uniform
• Use n_colors= for discrete classes. Use as_cmap=True when mapping a numeric vary

2. Cubehelix for ordered classes or low-ink plots

# Gentle-to-dark sequence that prints effectively
dice = sns.cubehelix_palette(
    begin=0.5,    # hue begin
    rot=-0.75,    # hue rotation
    gamma=1.0,    # depth curve
    gentle=0.95,
    darkish=0.15,
    n_colors=6
)

Cubehelix stays readable in grayscale and helps ordered classes the place development issues.

3. Mix a customized model ramp

# Mix two model colours right into a clean ramp
mix = sns.blend_palette(["#0F766E", "#60A5FA"], n_colors=7, as_cmap=False)

# In case you want a steady colormap as a substitute
blend_cmap = sns.blend_palette(["#0F766E", "#60A5FA"], as_cmap=True)

Mixing helps align visuals with a design system whereas preserving numerical gradients constant.

Set a palette globally while you decide to a scheme for an entire determine or report

sns.set_palette(cats)     # or dice, or mix

Preview a palette rapidly

sns.palplot(cats)
plt.present()

// Determine sizing and DPI for export

Management measurement and determination from the begin to keep away from fuzzy labels or cramped axes.
Set a wise default as soon as

# International defaults by way of Matplotlib rcParams
plt.rcParams["figure.figsize"] = (8, 5)    # width, peak in inches
plt.rcParams["figure.dpi"] = 150           # on-screen readability with out big information

You possibly can nonetheless measurement particular person figures explicitly when wanted:

fig, ax = plt.subplots(figsize=(8, 5))

Save high-quality outputs

# Raster export for net or slide decks
plt.savefig("determine.png", dpi=300, bbox_inches="tight")

# Vector export for print or journals
plt.savefig("determine.svg", bbox_inches="tight")
plt.savefig("determine.pdf", bbox_inches="tight")

• dpi=300 is an efficient goal for crisp net pictures and displays
• bbox_inches="tight" trims empty margins, which retains multi-panel layouts compact
• Desire SVG or PDF when editors will resize figures or while you want sharp textual content at any scale

# Plots That Matter for Actual Work

 
On this part, we’ll give attention to plot varieties that reply evaluation questions rapidly. Every subsection explains when to make use of the plot, the important thing parameters that management which means, and a brief code pattern you’ll be able to adapt. The examples assume you already set the theme and baseline from the earlier part.

// Relational plots: scatterplot, relplot(variety="line")

Use relational plots to indicate relationships between numeric variables and to match teams with coloration, marker, and measurement encodings. Add readability by mapping a categorical variable to hue and type, and a numeric variable to measurement.

import seaborn as sns
import matplotlib.pyplot as plt

penguins = sns.load_dataset("penguins").dropna(
    subset=["bill_length_mm", "bill_depth_mm", "body_mass_g", "species", "sex"]
)

# Scatter with a number of encodings
ax = sns.scatterplot(
    information=penguins,
    x="bill_length_mm",
    y="bill_depth_mm",
    hue="species",
    type="intercourse",
    measurement="body_mass_g",
    sizes=(30, 160),
    alpha=0.8,
    edgecolor="w",
    linewidth=0.5
)
ax.set_title("Invoice size vs depth with species, intercourse, and mass encodings")
ax.legend(title="Species")
plt.tight_layout()
plt.present()

For strains, want the figure-level API while you want markers per group and straightforward faceting.

flights = sns.load_dataset("flights")  # 12 months, month, passengers

g = sns.relplot(
    information=flights,
    variety="line",
    x="12 months",
    y="passengers",
    hue="month",
    markers=True,      # marker on every level
    dashes=False,      # stable strains for all teams
    peak=4, facet=1.6
)
g.set_axis_labels("12 months", "Passengers")
g.determine.suptitle("Month-to-month passenger development by 12 months", y=1.02)
plt.present()

Notes:

• Use type for a second categorical channel when hue is just not sufficient
• Hold alpha barely beneath 1.0 on dense scatters to disclose overlap
• Use sizes=(min, max) to constrain level sizes so the legend stays readable

// Categorical plots: boxplot, violinplot, barplot

Categorical plots present distributions and group variations. Select field or violin while you care about unfold and outliers. Select bar while you need aggregated values with intervals.

import numpy as np
suggestions = sns.load_dataset("suggestions")

# Boxplot: sturdy abstract of unfold
ax = sns.boxplot(
    information=suggestions,
    x="day",
    y="total_bill",
    hue="intercourse",
    order=["Thur", "Fri", "Sat", "Sun"],
    dodge=True,
    showfliers=False
)
ax.set_title("Whole invoice by day and intercourse (boxplot, fliers hidden)")
plt.tight_layout()
plt.present()

# Violin: form of the distribution with quartiles
ax = sns.violinplot(
    information=suggestions,
    x="day",
    y="total_bill",
    hue="intercourse",
    order=["Thur", "Fri", "Sat", "Sun"],
    dodge=True,
    internal="quartile",
    minimize=0,
    scale="width"
)
ax.set_title("Whole invoice by day and intercourse (violin with quartiles)")
plt.tight_layout()
plt.present()

# Bar: imply tip with percentile intervals
ax = sns.barplot(
    information=suggestions,
    x="day",
    y="tip",
    hue="intercourse",
    order=["Thur", "Fri", "Sat", "Sun"],
    estimator=np.imply,
    errorbar=("pi", 95),   # percentile interval for skewed information
    dodge=True
)
ax.set_title("Imply tip by day and intercourse with 95% PI")
plt.tight_layout()
plt.present()

Notes:

• order fixes class sorting for constant comparisons
• For big samples the place intervals add noise, set errorbar=None (or ci=None on older Seaborn)
• Disguise fliers on boxplots when excessive factors distract from the group comparability

// Distribution plots:histplot

Distribution plots reveal form, multimodality, and group variations. Use stacking while you need totals, and fill while you need composition.

# Single distribution with a clean density overlay
ax = sns.histplot(
    information=penguins,
    x="body_mass_g",
    bins=30,
    kde=True,
    factor="step"
)
ax.set_title("Physique mass distribution with KDE")
plt.tight_layout()
plt.present()

# Grouped comparability: composition throughout species
ax = sns.histplot(
    information=penguins,
    x="body_mass_g",
    hue="species",
    bins=25,
    a number of="fill",    # fraction per bin (composition)
    factor="step",
    stat="proportion",
    common_norm=False
)
ax.set_title("Physique mass composition by species")
plt.tight_layout()
plt.present()

# Grouped comparability: complete counts by stacking
ax = sns.histplot(
    information=penguins,
    x="body_mass_g",
    hue="species",
    bins=25,
    a number of="stack",
    factor="step",
    stat="depend"
)
ax.set_title("Physique mass counts by species (stacked)")
plt.tight_layout()
plt.present()

Notes:

• Use a number of="fill" to match relative composition throughout bins
• Use common_norm=False when teams differ in measurement and also you need within-group densities
• Select factor="step" for clear edges and straightforward overlaying

// Regression plots: regplot, lmplot

Regression plots add fitted relationships and intervals. Use regplot for a single axes. Use lmplot while you want hue, row, or col faceting with out handbook grid work.

Let’s check out an lmplot. Simply make sure the dataset has no lacking values within the mapped columns.

penguins = sns.load_dataset("penguins").dropna(
    subset=["bill_length_mm", "bill_depth_mm", "species", "sex"]
)

g = sns.lmplot(
    information=penguins,
    x="bill_length_mm",
    y="bill_depth_mm",
    hue="species",
    col="intercourse",
    peak=4,
    facet=1,
    scatter_kws=dict(s=25, alpha=0.7),
    line_kws=dict(linewidth=2)
)
g.set_titles(col_template="{col_name}")
g.determine.suptitle("Invoice dimensions by species and intercourse", y=1.02)
plt.present()

Notes:

• On newer Seaborn variations, want errorbar=("ci", 95) on features that help it. If ci continues to be accepted in your model, you’ll be able to hold utilizing it for now.
• In case you see related errors, examine for different unique pairs like lowess=True, logistic=True, or logx=True used collectively.

// Interval decisions on massive information

On large samples, interval bands can obscure the sign. Two choices enhance readability:

• Use percentile intervals for skewed distributions:

sns.barplot(information=suggestions, x="day", y="tip", errorbar=("pi", 95))

 

• Take away intervals totally when variation is already apparent:

sns.lineplot(information=flights, x="12 months", y="passengers", errorbar=None)
# or on older variations:
sns.lineplot(information=flights, x="12 months", y="passengers", ci=None)

 

Guideline:

• Desire errorbar=("pi", 95) for skewed or heavy-tailed information
• Desire errorbar=None (or ci=None) when the viewers cares extra about development form than exact uncertainty on a really massive N

# Excessive-Dimensional Views with Grids

 
Grids aid you evaluate patterns throughout teams with out handbook subplot juggling. You outline rows, columns, and coloration as soon as, then apply a plotting perform to every subset. This retains construction constant and makes variations apparent.

// FacetGrid and catplot/ relplot

Use a FacetGrid while you need full management over what will get mapped to every side. Use catplot and relplot while you desire a fast, figure-level API that builds the grid for you. The core thought is similar: break up information by row, col, and coloration with hue.
Earlier than the code: hold side counts lifelike. 4 to 6 small multiples are straightforward to scan. Past that, wrap columns or filter classes. Management sharing with sharex and sharey so comparisons stay legitimate.

import seaborn as sns
import matplotlib.pyplot as plt

suggestions = sns.load_dataset("suggestions").dropna()

# 1) Full management with FacetGrid + regplot
g = sns.FacetGrid(
    information=suggestions,
    row="time",                # Lunch vs Dinner
    col="day",                 # Thur, Fri, Sat, Solar
    hue="intercourse",                 # Male vs Feminine
    margin_titles=True,
    sharex=True,
    sharey=True,
    peak=3,
    facet=1
)
g.map_dataframe(
    sns.regplot,
    x="total_bill",
    y="tip",
    scatter_kws=dict(s=18, alpha=0.6),
    line_kws=dict(linewidth=2),
    ci=None
)
g.add_legend(title="Intercourse")
g.set_axis_labels("Whole invoice", "Tip")
g.fig.suptitle("Tipping patterns by day and time", y=1.02)
plt.present()

# 2) Fast grids with catplot (constructed on FacetGrid)
sns.catplot(
    information=suggestions,
    variety="field",
    x="day", y="total_bill",
    row="time", hue="intercourse",
    order=["Thur", "Fri", "Sat", "Sun"],
    peak=3, facet=1.1, dodge=True
).set_axis_labels("Day", "Whole invoice")
plt.present()

# 3) Fast relational grids with relplot
penguins = sns.load_dataset("penguins").dropna()
sns.relplot(
    information=penguins,
    variety="scatter",
    x="bill_length_mm", y="bill_depth_mm",
    row="intercourse", col="island", hue="species",
    peak=3.2, facet=1
)
plt.present()

Key factors:

• Use order to repair class sorting
• Use col_wrap when you could have one side dimension with many ranges
• Add a suptitle to summarize the comparability; hold axis labels constant throughout sides

// PairGrid and pairplot

Pairwise plots reveal relationships throughout many numeric variables. pairplot is the quick path. PairGrid offers you per-region management. For dense datasets, restrict variables and take into account nook=True to drop redundant higher panels.

Earlier than the code: select variables which can be informative collectively. Combine scales solely when you could have a purpose, then standardize or log-transform first.

# Fast pairwise view
num_cols = ["bill_length_mm", "bill_depth_mm", "flipper_length_mm", "body_mass_g"]
sns.pairplot(
    information=penguins[num_cols + ["species"]].dropna(),
    vars=num_cols,
    hue="species",
    nook=True,           # solely decrease triangle + diagonal
    diag_kind="hist",      # or "kde"
    plot_kws=dict(s=18, alpha=0.6),
    diag_kws=dict(bins=20, factor="step")
)
plt.present()

Suggestions:

• nook=True reduces litter and hastens rendering
• Hold marker measurement modest so overlaps stay readable
• For very completely different scales, apply np.log10 to skewed measures earlier than plotting

// Combined layers on a PairGrid

A combined mapping helps you evaluate scatter patterns and density construction in a single view. Use scatter on the higher triangle, bivariate KDE on the decrease triangle, and histograms on the diagonal. This mixture is compact and informative.
Earlier than the code: density layers can get heavy. Scale back ranges and keep away from too many bins. Add a legend as soon as and hold it exterior the grid if house is tight.

from seaborn import PairGrid

g = PairGrid(
    information=penguins[num_cols + ["species"]].dropna(),
    vars=num_cols,
    hue="species",
    peak=2.6, facet=1
)

# Higher triangle: scatter
g.map_upper(
    sns.scatterplot,
    s=16, alpha=0.65, linewidth=0.3, edgecolor="w"
)

# Decrease triangle: bivariate KDE
g.map_lower(
    sns.kdeplot,
    fill=True, thresh=0.05, ranges=5
)

# Diagonal: histograms
g.map_diag(
    sns.histplot,
    bins=18, factor="step"
)

g.add_legend(title="Species")
for ax in g.axes.flat:
    if ax is just not None:
        ax.tick_params(axis="x", labelrotation=30)

g.fig.suptitle("Pairwise construction of penguin measurements", y=1.02)
plt.present()

Tips:

• Begin with 4 numeric variables. Add extra provided that every provides a definite sign
• For uneven group sizes, give attention to proportions quite than uncooked counts while you evaluate distributions
• If rendering slows down, pattern rows earlier than plotting or drop fill from the KDE layer

# Correlation, Heatmaps, and Matrices

 
Correlation heatmaps are a compact technique to scan relationships throughout many numeric variables. The purpose is a readable matrix that highlights actual sign, retains noise out of the way in which, and exports cleanly.

// Construct a correlation matrix and masks redundant cells

Begin by deciding on numeric columns and selecting a correlation technique. Pearson is customary for linear relationships. Spearman is best for ranked or monotonic patterns. A triangular masks removes duplication so the attention focuses on distinctive pairs.

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

# Knowledge
penguins = sns.load_dataset("penguins").dropna()

# Select numeric columns and compute correlation
num_cols = penguins.select_dtypes(embody="quantity").columns
corr = penguins[num_cols].corr(technique="pearson")

# Masks the higher triangle (hold decrease + diagonal)
masks = np.triu(np.ones_like(corr, dtype=bool))

# Heatmap with diverging palette centered at zero
ax = sns.heatmap(
    corr,
    masks=masks,
    annot=True,
    fmt=".2f",
    cmap="vlag",
    heart=0,
    vmin=-1, vmax=1,
    sq.=True,
    cbar_kws={"shrink": 0.8, "label": "Pearson r"},
    linewidths=0.5, linecolor="white"
)

ax.set_title("Correlation matrix of penguin measurements")
plt.tight_layout()
plt.present()

Notes:

• Use technique="spearman" when variables should not on comparable scales or comprise outliers that have an effect on Pearson
• Hold vmin and vmax symmetric so the colour scale treats unfavorable and optimistic values equally

// Management visibility with scale and colorbar choices

As soon as the matrix is in place, tune what the reader sees. Symmetric limits, a centered palette, and a labeled colorbar stop misreads. It’s also possible to conceal weak correlations or the diagonal to scale back litter.

# Non-compulsory: conceal weak correlations beneath a threshold
threshold = 0.2
weak = corr.abs() < threshold
mask2 = np.triu(np.ones_like(corr, dtype=bool)) | weak  # mix masks

ax = sns.heatmap(
    corr,
    masks=mask2,
    annot=False,                 # let sturdy colours carry the message
    cmap="vlag",
    heart=0,
    vmin=-1, vmax=1,
    sq.=True,
    cbar_kws={"shrink": 0.8, "ticks": [-1, -0.5, 0, 0.5, 1], "label": "Correlation"},
    linewidths=0.4, linecolor="#F5F5F5"
)

ax.set_title("Robust correlations solely (|r| ≥ 0.20)")
plt.tight_layout()
plt.present()

Suggestions:

• cbar_kws controls readability of the legend. Set ticks that match your viewers
• Flip annot=True again on while you want precise values for a report. Hold it off for dashboards the place form and coloration are sufficient

// Giant matrices: hold labels and edges readable

Huge matrices want self-discipline. Skinny or rotate tick labels, add grid strains between cells, and take into account reordering variables to group associated blocks. If the matrix could be very large, present each nth tick to keep away from label collisions.

# Artificial large instance: 20 numeric columns
rng = np.random.default_rng(0)
large = pd.DataFrame(rng.regular(measurement=(600, 20)),
                    columns=[f"f{i:02d}" for i in range(1, 21)])

corr_wide = large.corr()

fig, ax = plt.subplots(figsize=(10, 8), dpi=150)

hm = sns.heatmap(
    corr_wide,
    cmap="vlag",
    heart=0,
    vmin=-1, vmax=1,
    sq.=True,
    cbar_kws={"shrink": 0.7, "label": "Correlation"},
    linewidths=0.3, linecolor="white"
)

# Rotate x labels and skinny ticks
ax.set_xticklabels(ax.get_xticklabels(), rotation=40, ha="proper")
ax.set_yticklabels(ax.get_yticklabels(), rotation=0)
ax.tick_params(axis="each", labelsize=8)

# Present each 2nd tick on each axes
xt = ax.get_xticks()
yt = ax.get_yticks()
ax.set_xticks(xt[::2])
ax.set_yticks(yt[::2])

ax.set_title("Correlation matrix with tick thinning and grid strains")
plt.tight_layout()
plt.present()

When construction issues greater than precise order, attempt a clustered view that teams related variables:

# Clustered matrix for sample discovery
g = sns.clustermap(
    corr_wide,
    cmap="vlag",
    heart=0,
    vmin=-1, vmax=1,
    linewidths=0.2, linecolor="white",
    figsize=(10, 10),
    cbar_kws={"shrink": 0.6, "label": "Correlation"},
    technique="common",  # linkage
    metric="euclidean" # distance on correlations
)
g.fig.suptitle("Clustered correlation matrix", y=1.02)
plt.present()

Tips:

• Improve determine measurement quite than shrinking font till it turns into unreadable
• Add linewidths and linecolor to outline cell boundaries on dense matrices
• Use clustering while you need to floor block construction. Hold a plain ordered matrix while you want steady positions throughout reviews

# Precision Management with Matplotlib Hooks

 
Seaborn handles the heavy lifting, however last polish comes from Matplotlib. These hooks allow you to set clear titles, management axes exactly, handle legends in tight areas, and annotate vital factors with out litter.

// Titles, labels, legends

Good plots learn themselves. Set titles that state the query, label axes with models, and hold the legend compact and informative. Place the legend the place it helps the attention, not the place it hides information.

Earlier than the code: want axis-level strategies over plt.* so settings keep hooked up to the proper subplot. Use a legend title and take into account transferring the legend exterior the axes when you could have many teams.

import seaborn as sns
import matplotlib.pyplot as plt

penguins = sns.load_dataset("penguins").dropna()

ax = sns.scatterplot(
    information=penguins,
    x="bill_length_mm",
    y="bill_depth_mm",
    hue="species",
    type="intercourse",
    s=60,
    alpha=0.8,
    edgecolor="w",
    linewidth=0.5
)

# Titles and labels
ax.set_title("Invoice size vs depth by species")
ax.set_xlabel("Invoice size (mm)")
ax.set_ylabel("Invoice depth (mm)")

# Legend with title, positioned exterior to the proper
leg = ax.legend(
    title="Species",
    loc="heart left",
    bbox_to_anchor=(1.02, 0.5),   # exterior the axes
    frameon=True,
    borderaxespad=0.5
)

# Non-compulsory legend styling
for textual content in leg.get_texts():
    textual content.set_fontsize(9)
leg.get_title().set_fontsize(10)

plt.tight_layout()
plt.present()

Notes

• bbox_to_anchor offers you fantastic management over legend placement exterior the axes
• Hold legend fonts barely smaller than axis tick labels to scale back visible weight
• In case you want a customized legend order, cross hue_order= within the plotting name

// Axis management

Axis limits, ticks, and rotation enhance readability greater than any coloration selection. Set solely the ticks your viewers wants. Use rotation when labels collide. Add small margins to cease markers from touching the body.

Earlier than the code: resolve which ticks matter. For time or evenly spaced integers, present fewer ticks. For skewed information, take into account log scales and customized formatters.

import numpy as np
flights = sns.load_dataset("flights")  # columns: 12 months, month, passengers

ax = sns.lineplot(
    information=flights,
    x="12 months",
    y="passengers",
    estimator=None,
    errorbar=None,
    marker="o",
    dashes=False
)

ax.set_title("Airline passengers by 12 months")
ax.set_xlabel("12 months")
ax.set_ylabel("Passengers")

# Present a tick each 5 years
years = np.kind(flights["year"].distinctive())
ax.set_xticks(years[::5])

# Tidy the view
ax.margins(x=0.02, y=0.05)   # small padding inside axes
ax.set_ylim(0, None)         # begin at zero for clearer development

# Rotate if wanted
plt.xticks(rotation=0)
plt.tight_layout()
plt.present()

Extras you’ll be able to add when required

• Symmetric limits: ax.set_xlim(left, proper) and ax.set_ylim(backside, prime) for honest comparisons
• Log scaling: ax.set_xscale("log") or ax.set_yscale("log") for lengthy tails
• Fewer ticks: ax.xaxis.set_major_locator(matplotlib.ticker.MaxNLocator(nbins=6))

// Annotations, strains, and spans

Annotations name out the explanation the plot exists. Use a brief label, a transparent arrow, and constant styling. Strains and spans mark thresholds or intervals that matter.

Earlier than the code: place annotations close to the info they seek advice from, however keep away from masking factors. Think about using a semi-transparent span for ranges.

import matplotlib as mpl
suggestions = sns.load_dataset("suggestions")

ax = sns.regplot(
    information=suggestions,
    x="total_bill",
    y="tip",
    ci=None,
    scatter_kws=dict(s=28, alpha=0.6),
    line_kws=dict(linewidth=2)
)

ax.set_title("Tip vs complete invoice with callouts")
ax.set_xlabel("Whole invoice ($)")
ax.set_ylabel("Tip ($)")

# Threshold line for a tipping rule of thumb
ax.axhline(3, coloration="#444", linewidth=1, linestyle="--")
ax.textual content(ax.get_xlim()[0], 3.1, "Reference: $3 tip", fontsize=9, coloration="#444")

# Spotlight a invoice vary with a span
ax.axvspan(20, 40, coloration="#fde68a", alpha=0.25, linewidth=0)  # delicate spotlight

# Annotate a consultant level
pt = suggestions.loc[tips["total_bill"].between(20, 40)].iloc[0]
ax.annotate(
    "Instance examine",
    xy=(pt["total_bill"], pt["tip"]),
    xytext=(pt["total_bill"] + 10, pt["tip"] + 2),
    arrowprops=dict(
        arrowstyle="->",
        coloration="#111",
        shrinkA=0,
        shrinkB=0,
        linewidth=1.2
    ),
    fontsize=9,
    bbox=dict(boxstyle="spherical,pad=0.2", fc="white", ec="#ddd", alpha=0.9)
)

plt.tight_layout()
plt.present()

Tips:

• Hold annotations brief. The plot ought to nonetheless learn with out them
• Use axvline, axhline, axvspan, and axhspan for thresholds and ranges
• If labels overlap, regulate with small offsets or scale back font measurement, not by eradicating the annotation that carries which means

# Wrapping Up

 
You now have a whole baseline for quick, constant Seaborn work: pattern or combination when scale calls for it, management legends and axes with Matplotlib hooks, hold colours steady throughout figures, and repair labels earlier than export. Mix these with the grid patterns and statistical plots from earlier sections and you’ll cowl most evaluation wants with out customized subplot code.

The place to study extra:

Shittu Olumide is a software program engineer and technical author keen about leveraging cutting-edge applied sciences to craft compelling narratives, with a eager eye for element and a knack for simplifying complicated ideas. It’s also possible to discover Shittu on Twitter.