Skip to main content

NLP (2026): Complete Guide with Python Code

Type "running shoes" into a search box and you expect results that mention "run", "runner" and "runs" too. Behind that small convenience sits one of the oldest and most practical tricks in Natural Language Processing: stemming . In this guide you will learn exactly what stemming is, how the famous algorithms work step by step, how to use them in Python, where they fail, and whether stemming still matters in an age of large language models. This is a hands-on guide. Every Python snippet below has been run, and the outputs shown are real. By the end you will be able to choose the right stemmer for your project, plug it into a scikit-learn pipeline, and explain the difference between stemming and lemmatization confidently in an interview, a viva, or a code review. Table of Contents What Is Stemming in NLP? Why Stemming Matters in Text Preprocessing Stemming vs Lemmatization How Stemming Works Under the Hood Over-Stemming and Under-Stemming...

Matplotlib Guide: Mastering Data Visualization in Python (2026)

 


Matplotlib: The Complete Guide to Data Visualization in Python

Introduction

Long before Seaborn, Plotly, or any of the modern data visualization tools existed, there was Matplotlib. First released in 2003 by John D. Hunter, it was built to bring MATLAB-style plotting capabilities to Python — and in doing so, it became the foundational visualization library on which nearly the entire Python data science ecosystem is built. Seaborn, pandas' built-in plotting methods, and many other tools are, quite literally, built directly on top of Matplotlib.

More than two decades later, Matplotlib remains an essential tool — not because it's the newest or the flashiest option, but because it offers something few other libraries can match: complete, granular control over every visual element of a plot. This guide takes an in-depth look at Matplotlib: its underlying architecture, the core plot types every practitioner should know, and the techniques needed to produce clean, publication-quality figures for data analysis, model evaluation, and reporting.


1. What Is Matplotlib, and Why Does It Still Matter?

Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python. It supports a huge range of plot types — line charts, bar charts, scatter plots, histograms, heatmaps, 3D plots, and far more — and gives developers direct control over virtually every visual detail: colors, fonts, line styles, axis limits, tick marks, annotations, and layout.

Why Learn Matplotlib When Newer Libraries Exist?

It's a fair question. Libraries like Seaborn and Plotly offer more attractive defaults and require less code for common statistical plots. But Matplotlib remains essential for several reasons:

  • It's the foundation. Seaborn is built directly on top of Matplotlib, and understanding Matplotlib makes it far easier to customize Seaborn plots beyond their defaults when needed.
  • Unmatched control. When you need to produce a very specific visual — for a research paper, a detailed dashboard, or a report with exact formatting requirements — Matplotlib's low-level API gives you the tools to get there precisely.
  • Universal compatibility. Matplotlib works everywhere: Jupyter notebooks, standalone scripts, web applications (via various backends), and embedded within GUI applications.
  • Stability and maturity. With over two decades of development, Matplotlib is extraordinarily well-documented, thoroughly tested, and unlikely to introduce breaking changes that disrupt existing code.

2. The Two Interfaces: pyplot and Object-Oriented

One of the first things that can confuse newcomers to Matplotlib is that there are two different ways to create plots: the pyplot interface (state-based, MATLAB-inspired) and the object-oriented interface (explicit, more Pythonic). Understanding the difference — and when to use each — is foundational to using Matplotlib effectively.

The pyplot Interface

The pyplot module provides a simple, state-based interface where each function call implicitly acts on "the current figure" and "the current axes."

import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.xlabel("x")
plt.ylabel("y")
plt.title("Simple Plot")
plt.show()

This interface is quick and convenient for simple, one-off plots, which is why it's what most tutorials and quick data exploration snippets use.

The Object-Oriented Interface

For anything beyond the simplest plot — multiple subplots, precise customization, or code that will be reused in functions — the object-oriented interface is the better choice. Here, you explicitly create and work with Figure and Axes objects.

fig, ax = plt.subplots(figsize=(8, 5))
ax.plot([1, 2, 3, 4], [1, 4, 9, 16])
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_title("Simple Plot")
plt.show()

The key conceptual distinction: a Figure is the entire window or page that everything is drawn on, while an Axes is a single plot within that figure — the thing that actually contains the data, labels, and ticks. A figure can contain multiple axes (multiple subplots), which is where the object-oriented approach becomes genuinely necessary.

fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(10, 8))

axes[0, 0].plot(x, y1)
axes[0, 0].set_title("Plot 1")

axes[0, 1].bar(categories, values)
axes[0, 1].set_title("Plot 2")

axes[1, 0].scatter(x, y2)
axes[1, 0].set_title("Plot 3")

axes[1, 1].hist(data, bins=20)
axes[1, 1].set_title("Plot 4")

plt.tight_layout()
plt.show()

The plt.tight_layout() call automatically adjusts spacing between subplots to prevent titles and labels from overlapping — a small but frequently necessary detail when working with multiple plots in one figure.

Recommendation: for quick, throwaway exploration, the pyplot interface is fine. For anything you'll reuse, share, or need precise control over — which describes most real work — the object-oriented interface is the better long-term habit to build.


3. Core Plot Types

Matplotlib supports a vast range of plot types. Here are the ones that come up most often in data analysis and machine learning work.

Line Plots

Line plots are the natural choice for showing how a value changes over a continuous variable — most commonly time, or, in machine learning, training epochs.

fig, ax = plt.subplots()
ax.plot(epochs, train_loss, label="Training Loss", color="blue")
ax.plot(epochs, val_loss, label="Validation Loss", color="orange")
ax.set_xlabel("Epoch")
ax.set_ylabel("Loss")
ax.set_title("Training Progress")
ax.legend()
plt.show()

This exact pattern — plotting training and validation loss curves side by side — is one of the most common visualizations in any machine learning project, and Matplotlib is very often the tool used to produce it.

Bar Charts

Bar charts compare quantities across discrete categories.

fig, ax = plt.subplots()
ax.bar(categories, values, color="steelblue")
ax.set_xlabel("Category")
ax.set_ylabel("Count")
ax.set_title("Category Distribution")
plt.xticks(rotation=45)
plt.show()

Horizontal bar charts (ax.barh()) are often a better choice when category labels are long, since they avoid the need to rotate text labels to fit.

Scatter Plots

Scatter plots reveal the relationship between two continuous variables, and are especially useful for spotting correlations, clusters, or outliers.

fig, ax = plt.subplots()
scatter = ax.scatter(x, y, c=labels, cmap="viridis", alpha=0.7)
ax.set_xlabel("Feature 1")
ax.set_ylabel("Feature 2")
plt.colorbar(scatter, label="Class")
plt.show()

Here, the c=labels argument colors each point according to its class label, and cmap="viridis" specifies the color map used — a common pattern for visualizing classification results or clustering output.

Histograms

Histograms show the distribution of a single continuous variable by dividing its range into bins and counting how many observations fall into each.

fig, ax = plt.subplots()
ax.hist(data, bins=30, color="skyblue", edgecolor="black")
ax.set_xlabel("Value")
ax.set_ylabel("Frequency")
ax.set_title("Distribution of Values")
plt.show()

Choosing an appropriate number of bins matters: too few bins can hide meaningful structure in the data, while too many can make the histogram look noisy and hard to interpret.

Heatmaps with imshow

While Seaborn's heatmap function is more commonly used for this purpose, Matplotlib can produce heatmaps directly using imshow, useful for visualizing matrices like a confusion matrix.

fig, ax = plt.subplots()
cax = ax.imshow(confusion_matrix, cmap="Blues")
ax.set_xlabel("Predicted Label")
ax.set_ylabel("True Label")
plt.colorbar(cax)

# Adding text annotations to each cell
for i in range(confusion_matrix.shape[0]):
    for j in range(confusion_matrix.shape[1]):
        ax.text(j, i, confusion_matrix[i, j], ha="center", va="center")

plt.show()

This kind of annotated confusion matrix is a staple visualization for evaluating classification model performance.


4. Customizing Plots: Making Figures Communicate Clearly

A plot's real job is to communicate information clearly, and Matplotlib provides extensive tools for refining a visualization until it does that job well.

Labels, Titles, and Legends

fig, ax = plt.subplots()
ax.plot(x, y, label="Series A")
ax.set_xlabel("Time (seconds)", fontsize=12)
ax.set_ylabel("Value", fontsize=12)
ax.set_title("Sensor Reading Over Time", fontsize=14, fontweight="bold")
ax.legend(loc="upper right")
plt.show()

Clear axis labels and a descriptive title aren't optional extras — a plot without them forces the viewer to guess at what they're looking at, which undermines the entire point of visualizing data in the first place.

Colors and Styles

Matplotlib gives fine control over color, line style, and marker style, which is particularly useful when a plot needs to remain legible in grayscale printing, or needs to follow a specific brand's color palette.

ax.plot(x, y1, color="#1f77b4", linestyle="-", marker="o", label="Model A")
ax.plot(x, y2, color="#ff7f0e", linestyle="--", marker="s", label="Model B")

Annotations

Annotations let you draw attention to specific points or features in a plot — a peak value, an anomaly, or a threshold that matters for interpretation.

ax.annotate(
    "Peak value",
    xy=(peak_x, peak_y),
    xytext=(peak_x + 1, peak_y + 5),
    arrowprops=dict(facecolor="black", shrink=0.05)
)

Styling with Built-In Themes

Matplotlib includes a number of built-in styles that instantly change the overall visual appearance of a plot, useful for quickly achieving a more polished look without manually setting every style parameter.

plt.style.use("seaborn-v0_8-darkgrid")

fig, ax = plt.subplots()
ax.plot(x, y)
plt.show()

Available styles include options mimicking Seaborn's aesthetics, ggplot's look (popular in the R community), and various dark and light themes — a convenient shortcut when you want an attractive plot without extensive manual customization.


5. Working with Multiple Subplots

Real-world reports and analyses frequently need to show several related plots together. Matplotlib's subplot system makes this manageable, even for fairly complex layouts.

Basic Grid Layouts

fig, axes = plt.subplots(2, 3, figsize=(15, 8))

for i, ax in enumerate(axes.flat):
    ax.plot(x, y[i])
    ax.set_title(f"Subplot {i+1}")

plt.tight_layout()
plt.show()

GridSpec for Complex, Irregular Layouts

For layouts that don't fit neatly into a uniform grid — for example, one large plot alongside several smaller ones — GridSpec provides more flexible control.

import matplotlib.gridspec as gridspec

fig = plt.figure(figsize=(12, 8))
gs = gridspec.GridSpec(3, 3, figure=fig)

ax1 = fig.add_subplot(gs[0, :])      # Spans the entire top row
ax2 = fig.add_subplot(gs[1:, 0])     # Spans the bottom-left two rows
ax3 = fig.add_subplot(gs[1, 1:])     # Middle-right section
ax4 = fig.add_subplot(gs[2, 1:])     # Bottom-right section

plt.tight_layout()
plt.show()

This kind of layout flexibility is what makes Matplotlib capable of producing dashboard-style figures — combining a main chart with several supporting plots, all within one cohesive image.


6. Matplotlib in Machine Learning Workflows

Matplotlib appears constantly throughout the machine learning workflow, well beyond simple exploratory charts.

Visualizing Training Progress

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

ax1.plot(history["loss"], label="Train")
ax1.plot(history["val_loss"], label="Validation")
ax1.set_title("Loss")
ax1.legend()

ax2.plot(history["accuracy"], label="Train")
ax2.plot(history["val_accuracy"], label="Validation")
ax2.set_title("Accuracy")
ax2.legend()

plt.tight_layout()
plt.show()

Visualizing Model Predictions on Images

For computer vision tasks, Matplotlib is commonly used to display sample images alongside their true and predicted labels, which is invaluable for qualitatively spotting where a model is making mistakes.

fig, axes = plt.subplots(2, 5, figsize=(12, 5))

for i, ax in enumerate(axes.flat):
    ax.imshow(images[i], cmap="gray")
    ax.set_title(f"True: {true_labels[i]}, Pred: {predicted_labels[i]}")
    ax.axis("off")

plt.tight_layout()
plt.show()

Feature Importance Plots

fig, ax = plt.subplots(figsize=(8, 6))
ax.barh(feature_names, importances)
ax.set_xlabel("Importance")
ax.set_title("Feature Importance")
plt.tight_layout()
plt.show()

These kinds of plots — loss curves, prediction galleries, and feature importance charts — form the backbone of how machine learning practitioners actually understand and communicate what their models are doing, well beyond a single accuracy number.


7. Saving Figures for Reports and Publications

A visualization is often meant to end up somewhere beyond a Jupyter notebook — a report, a presentation, or a published paper. Matplotlib's savefig function handles this with fine control over output quality and format.

fig.savefig("training_curves.png", dpi=300, bbox_inches="tight")
  • dpi=300 sets a high resolution appropriate for print or publication; lower values (like 100) are often sufficient for on-screen use.
  • bbox_inches="tight" trims excess whitespace around the figure, which usually produces a cleaner result than the default output.
  • Matplotlib supports many output formats, including PNG, PDF, SVG, and EPS — vector formats like PDF and SVG are particularly valuable for print publications since they scale to any size without losing quality.
fig.savefig("figure.pdf", bbox_inches="tight")   # Vector format, ideal for print
fig.savefig("figure.svg", bbox_inches="tight")   # Vector format, ideal for web

8. 3D Plotting

While less commonly used than 2D plots, Matplotlib also supports 3D visualization through its mplot3d toolkit — useful for visualizing three-variable relationships, surface plots, or the results of dimensionality reduction into three components.

from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection="3d")
ax.scatter(x, y, z, c=labels, cmap="viridis")
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
plt.show()

9. Common Pitfalls and Best Practices

After two decades of widespread use, certain patterns and pitfalls have become well understood within the Matplotlib community.

Mixing the pyplot and object-oriented interfaces inconsistently. It's technically possible to mix plt.plot() calls with explicit ax objects in the same script, but this often leads to confusing bugs where a function call doesn't affect the axes you expect. Picking one interface — generally the object-oriented one for anything beyond a quick, single plot — and sticking with it consistently avoids this entirely.

Forgetting plt.tight_layout() with multiple subplots. Without it, titles, labels, and tick marks frequently overlap between adjacent subplots, producing a cluttered, hard-to-read figure.

Not closing figures in loops. When generating many plots in a loop (for example, one per item in a dataset), forgetting to call plt.close(fig) after saving each one can cause memory usage to grow steadily, since Matplotlib keeps all open figures in memory by default.

for i, data in enumerate(datasets):
    fig, ax = plt.subplots()
    ax.plot(data)
    fig.savefig(f"plot_{i}.png")
    plt.close(fig)  # Prevents memory buildup

Overcomplicating simple plots. Not every chart needs extensive customization. For quick exploratory analysis, the default styling is often perfectly adequate — save detailed customization effort for visualizations that will actually be shared or published.


10. Matplotlib's Role in the Broader Ecosystem

It's worth being explicit about how Matplotlib relates to other visualization tools in the Python ecosystem, since this often causes confusion for newcomers.

Seaborn is built directly on top of Matplotlib, providing higher-level functions with more attractive statistical visualization defaults. Every Seaborn plot can be further customized using Matplotlib's object-oriented API, since Seaborn returns standard Matplotlib Axes objects.

pandas includes built-in `.plot()** methods on DataFrames and Series that use Matplotlib under the hood — a convenient shortcut for quick visualizations directly from a DataFrame without importing Matplotlib explicitly, though the underlying engine is the same.

Plotly and Bokeh offer interactive, browser-based visualizations — useful for dashboards and exploratory tools where users need to zoom, hover, and filter — but they're separate libraries with different APIs, not built on top of Matplotlib.

Understanding this relationship clarifies an important point: learning Matplotlib's fundamentals — figures, axes, and how to customize them — pays dividends well beyond Matplotlib itself, since that knowledge transfers directly to working with Seaborn and other tools built on the same foundation.


Conclusion

Matplotlib's longevity in a fast-moving field is a testament to just how well it solved the fundamental problem of visualizing data in Python. Its two interfaces — the quick, state-based pyplot module and the more powerful, explicit object-oriented API — give practitioners a path from simple, quick exploratory plots all the way to precisely customized, publication-ready figures.

Whether you're plotting a model's training curves, visualizing a confusion matrix, exploring the distribution of a dataset, or preparing a figure for a research paper, Matplotlib provides the tools to do it — and understanding its core concepts, particularly the Figure and Axes objects, gives you a foundation that carries over directly into Seaborn and much of the rest of the Python visualization ecosystem. For anyone doing serious data analysis or machine learning work in Python, Matplotlib remains a genuinely essential skill.

Comments

Popular posts from this blog

Multimodal AI Explained: How Text, Image & Voice Merge Into One Model

  The Rise of Multimodal AI: Text, Image, and Voice in One Model For most of the last decade, AI systems were narrow specialists: a language model that only understood text, an image classifier that only understood pictures, a speech recognition system that only understood audio. Getting these systems to work together meant stitching together separate pipelines, converting between formats at every handoff, and accepting the errors and awkwardness that came with each conversion step. That era is ending. Modern multimodal AI systems process text, images, audio, and increasingly video within a single unified model, reasoning across all of them together rather than treating each as a separate problem solved by a separate system. This guide explains what multimodal AI actually is, the real architectural difference between "bolted-together" and "natively unified" multimodal systems, where this technology is already changing real products, and an honest look at where it ...

PyTorch Explained: The Complete Guide to Deep Learning & Neural Networks in 2026

  PyTorch: The Complete Guide to Deep Learning's Most Popular Framework Introduction If you've trained a neural network, fine-tuned a language model, or experimented with a diffusion-based image generator in the last several years, there's a strong chance PyTorch was somewhere underneath it. Originally released by Facebook AI Research (now Meta AI) in 2016, PyTorch has grown from a research-focused alternative to established frameworks into the dominant tool in the deep learning world — powering everything from academic papers to some of the largest AI systems ever deployed in production. This guide takes a deep, practical look at PyTorch: what it is, why it was designed the way it was, how its core components fit together, and how to actually use it to build, train, and deploy real models. Whether you're completely new to deep learning or you've used other frameworks and want to understand what makes PyTorch different, this article will walk you through everythi...

AI Ethics Explained: Bias, Privacy, Safety & Laws (2026)

Responsible AI • Explained Deeply AI Ethics Explained: Bias, Privacy, Accountability, Safety and the Rules Shaping Our Future A clear, thorough guide to the moral and practical questions raised by artificial intelligence: what can go wrong, who is affected, what laws and frameworks exist, and how builders and everyday users can act responsibly. ⚖️ Beginners to practitioners In this guide What is AI ethics, and why now? A short history of AI ethics The core principles explained Bias and fairness in depth Transparency and explainability Privacy and data protection Accountability and liability Safety, robustness and security Generative AI: new ethical questions Work, inequality and hidden labor The environmental cost of AI Laws and global governance Ethical theories applied to AI How to build AI responsibly Case studies and lessons Using AI responsibly as an individual Open debates ...