Data Visualization with Matplotlib

The 3-Tier Architecture of Matplotlib

To understand how Matplotlib transforms floating-point numbers into anti-aliased vector curves, one must grasp its internal three-tiered stack:

1. The Backend Layer (Low-Level Drawing Engine): Contains the concrete rendering machinery that talks to physical output devices. It handles rasterization (converting vectors into pixels) and window events. Key components include FigureCanvas (drawing surface), Renderer (draws objects on canvas), and Event (captures keyboard/mouse events). Output formats include raster (Agg, PNG) and vector (PDF, SVG, PostScript).
2. The Artist Layer (The Hierarchy of Visual Objects): Represents everything you visually perceive on the screen. The Artist hierarchy consists of Primitive Artists (e.g., Line2D, Rectangle, Circle, Text) and Composite Artists (e.g., Axis, Axes, and Figure). Over 95% of data visualization programming operates within this layer.
3. The Scripting Layer (`matplotlib.pyplot`): A stateful procedural wrapper designed to mimic MATLAB's global command syntax. It automatically instantiates figures, tracks active axes, and executes plotting commands without requiring users to manually configure artist trees.

+-------------------------------------------------------------------------+
| SCRIPTING LAYER: matplotlib.pyplot                                      |
| Stateful procedural interface for rapid prototyping (MATLAB style).     |
+-------------------------------------------------------------------------+
                                   |
                                   v
+-------------------------------------------------------------------------+
| ARTIST LAYER (Object Tree):                                              |
|   Figure (Root container)                                               |
|     └── Axes (Plot coordinate system)                                    |
|           ├── Axis (X & Y number lines, Ticks, TickLabels)               |
|           ├── Primitives: Line2D, Rectangle (Bars), Circle, Text        |
|           └── Collections: PathCollection (Scatter), PolyCollection     |
+-------------------------------------------------------------------------+
                                   |
                                   v
+-------------------------------------------------------------------------+
| BACKEND LAYER (Device Rendering):                                       |
|   ├── FigureCanvas: Canvas area (Base / GUI Widget: QtAgg, TkAgg)        |
|   ├── Renderer: Vector/raster rasterizer (Agg, PDF, SVG, PS)            |
|   └── Graphics Context (GC): Color, line width, dash pattern properties |
+-------------------------------------------------------------------------+

Pyplot API vs Object-Oriented (OO) Paradigm

Matplotlib provides two fundamentally distinct operational paradigms. Novices often confuse them, producing fragile scripts with unintended side effects:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

# RECOMMENDED: Explicit Object-Oriented Approach
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(x, y, label="sin(x)", color="#2563eb", linewidth=2)
ax.set_title("Harmonic Oscillation (OO Paradigm)", fontsize=12)
ax.set_xlabel("Time (seconds)")
ax.set_ylabel("Amplitude")
ax.grid(True, linestyle="--", alpha=0.5)
ax.legend(loc="upper right")
plt.show()

Anatomy of a Figure: Canvas, Axes, Ticks & Spines

A precise understanding of Matplotlib requires distinguishing between the major structural components of a visualization:

• Figure (The Window Canvas): The top-level bounding container holding all axes, titles, legends, and colorbars.
• Axes (The Actual Plot Area): The bounding box where data is plotted. A Figure can contain one or dozens of Axes.
• Axis (The Number Lines): The individual X and Y scale lines that establish data limits and generate ticks.
• Ticks and TickLabels: The small tick indicators (major and minor) and their text labels positioned along the Axis.
• Spines: The four boundary lines delimiting the plot area (top, bottom, left, right).

+-----------------------------------------------------------------------+
| FIGURE (Canvas Container: fig.suptitle("Dashboard Title"))             |
|                                                                       |
|   +-- TOP SPINE (ax.spines['top']) -------------------------------+   |
|   | AXES TITLE (ax.set_title("Subplot 1"))                        |   |
|   |                                                               |   |
| L | Y-AXIS LABEL                                      LEGEND      | R |
| E | (ax.set_ylabel)                                 [Line A]      | I |
| F |   |                                             [Line B]      | G |
| T |   |                                                           | H |
|   | 10+-------*-----------------------*----------- GRID           | T |
| S |   |        \                     /             (ax.grid)      |   |
| P | 5 +---------*-------------------*                             | S |
| I |   |          \                 /               LINE ARTIST    | P |
| N | 0 +-----------*---------------*-------------- (ax.plot)       | I |
| E |   |            \             /                                | N |
|   |   +--+----+----+----+----+----+----+----+----+----+           | E |
|   |      0    1    2    3    4    5    6    7    8    9           |   |
|   |      ^         ^                                              |   |
|   |      MAJOR     MINOR TICK                                     |   |
|   |      TICK                                                     |   |
|   +-- BOTTOM SPINE (ax.spines['bottom']) -------------------------+   |
|                                                                       |
|       X-AXIS LABEL (ax.set_xlabel("Time (s)"))                        |
+-----------------------------------------------------------------------+

Simple Plot, Line Styles, Markers & Customization

The line plot is the fundamental tool for continuous data. The ax.plot() method accepts parameters controlling color, geometry, and marker points:

• Linestyles (`linestyle` or `ls`): '-' (solid), '--' (dashed), '-.' (dash-dot), ':' (dotted).
• Markers (`marker`): 'o' (circle), 's' (square), '^' (triangle), '*' (star), 'D' (diamond).
• Color Formats (`color` or `c`): Named colors ('red'), Hex codes ('#2563eb'), or RGBA tuples.
• Shorthand String Syntax: ax.plot(x, y, 'r--o') combines red color, dashed line, and circle marker in one compact token.

import matplotlib.pyplot as plt
import numpy as np

months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
mca_attendance = [78, 82, 85, 80, 92, 88]
csit_attendance = [70, 75, 74, 82, 85, 81]

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

# Plot series with explicit styling
ax.plot(months, mca_attendance, color="#d8b979", linestyle="-", 
        linewidth=2.5, marker="o", markersize=7, label="MCA Cohort")

ax.plot(months, csit_attendance, color="#38bdf8", linestyle="--", 
        linewidth=2.0, marker="s", markersize=6, label="B.Sc. CSIT Cohort")

ax.set_title("Student Attendance Trend Comparison", fontsize=13, pad=12)
ax.set_xlabel("Academic Month", fontsize=10)
ax.set_ylabel("Average Attendance (%)", fontsize=10)
ax.set_ylim(60, 100)

ax.grid(True, linestyle=":", alpha=0.6)
ax.legend(loc="lower right", frameon=True)

plt.tight_layout()
plt.show()

Multi-Plots on a Single Canvas & Dual Y-Axes (`twinx`)

When plotting two related variables that share an identical X-axis domain but occupy vastly different numeric magnitudes (e.g., Monthly Temperature in °C vs Rainfall in mm), overlaying them on a single Y-axis distorts the smaller series into an unreadable flat line.

Matplotlib resolves this with `ax.twinx()`: creating an overlay twin Axes that shares the original X-axis while establishing a secondary Y-axis on the right spine.

PRIMARY Y-AXIS: ax1 (Temperature °C)          SECONDARY Y-AXIS: ax2 (Rainfall mm)
Scale: 0 to 40 °C                             Scale: 0 to 500 mm
                +---------------------------------------+
   40 °C -------|                                       |------- 500 mm
                |          ax1.plot() (Line)            |
   30 °C -------|          [Temperature Curve]          |------- 375 mm
                |                                       |
   20 °C -------|          ax2.bar() (Bars)             |------- 250 mm
                |          [Rainfall Volume]            |
   10 °C -------|                                       |------- 125 mm
                |                                       |
    0 °C -------+---------------------------------------+------- 0 mm
                   Jan   Feb   Mar   Apr   May   Jun
                   SHARED X-AXIS: ax1 and ax2 share domain

import matplotlib.pyplot as plt

months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul"]
temperature = [12, 15, 20, 26, 29, 28, 27]       # °C (Scale 0-35)
rainfall = [20, 35, 45, 90, 180, 360, 420]         # mm (Scale 0-500)

fig, ax1 = plt.subplots(figsize=(8, 4.5))

# Primary Axis: Temperature Line
color1 = "#f87171" # Warm Red
ax1.set_xlabel("Month")
ax1.set_ylabel("Temperature (°C)", color=color1)
line1 = ax1.plot(months, temperature, color=color1, marker="o", linewidth=2.5, label="Avg Temp")
ax1.tick_params(axis="y", labelcolor=color1)
ax1.set_ylim(0, 35)

# Secondary Axis: Rainfall Bars
ax2 = ax1.twinx()
color2 = "#38bdf8" # Sky Blue
ax2.set_ylabel("Precipitation (mm)", color=color2)
bars = ax2.bar(months, rainfall, color=color2, alpha=0.35, width=0.4, label="Rainfall")
ax2.tick_params(axis="y", labelcolor=color2)
ax2.set_ylim(0, 500)

ax1.set_title("Kathmandu Climate: Temperature vs Monsoon Precipitation", pad=12)
fig.tight_layout()
plt.show()

`subplots()` Function & Axis Sharing

The plt.subplots(nrows, ncols) function serves as the workhorse for creating uniform grid arrays of subplots in a single invocation. It returns a tuple containing the Figure and a NumPy array of Axes objects:

• 2D Array Indexing: For a 2x2 grid, subplots are addressed as axes[0, 0] (top-left), axes[0, 1] (top-right), axes[1, 0] (bottom-left), and axes[1, 1] (bottom-right).
• Flattening with `axes.flatten()`: When iterating over subplots programmatically, flattening the 2D array into a 1D sequence simplifies the loop structure.
• Axis Sharing (`sharex=True`, `sharey=True`): Synchronizes zooming and eliminates redundant duplicate tick markings on interior plots.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2 * np.pi, 200)

fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(9, 6), sharex=True)

# Panel (0, 0): Sine Wave
axes[0, 0].plot(x, np.sin(x), color="#d8b979")
axes[0, 0].set_title("Sine: sin(x)")
axes[0, 0].grid(True, linestyle=":")

# Panel (0, 1): Cosine Wave
axes[0, 1].plot(x, np.cos(x), color="#38bdf8")
axes[0, 1].set_title("Cosine: cos(x)")
axes[0, 1].grid(True, linestyle=":")

# Panel (1, 0): Tangent Wave
axes[1, 0].plot(x, np.tan(x), color="#f87171")
axes[1, 0].set_title("Tangent: tan(x)")
axes[1, 0].set_ylim(-5, 5)
axes[1, 0].grid(True, linestyle=":")

# Panel (1, 1): Damped Sine Wave
axes[1, 1].plot(x, np.exp(-x/3) * np.sin(3*x), color="#4ade80")
axes[1, 1].set_title("Damped Oscillation")
axes[1, 1].grid(True, linestyle=":")

fig.suptitle("Trigonometric Signal Matrix", fontsize=14, y=0.98)
fig.tight_layout()
plt.show()

`subplot2grid()` for Asymmetrical Executive Dashboards

While plt.subplots() generates rigid, equal-sized grid cells, modern analytical dashboards require asymmetrical layouts: a dominant primary chart spanning multiple rows or columns, accompanied by smaller subordinate diagnostic widgets.

The `plt.subplot2grid(shape, loc, rowspan=1, colspan=1)` function provides this capability:

• `shape`: A tuple (nrows, ncols) establishing the underlying virtual grid resolution.
• `loc`: A tuple (row, col) pinpointing the top-left anchor coordinate of the subplot.
• `rowspan`: Number of vertical rows the subplot expands across.
• `colspan`: Number of horizontal columns the subplot expands across.

VIRTUAL GRID: (3, 3) -> 3 Rows x 3 Columns
Col 0                     Col 1                     Col 2
+-----------------------------------------------------------------------+
| Row 0: PRIMARY HERO CHART                                              |
| loc=(0, 0), rowspan=2, colspan=3                                      |
| (Spans 2 full rows and all 3 horizontal columns)                      |
|                                                                       |
| Row 1: (Continues hero chart area)                                    |
+-------------------------+-------------------------+-------------------+
| Row 2: WIDGET 1         | Row 2: WIDGET 2         | Row 2: WIDGET 3   |
| loc=(2, 0)              | loc=(2, 1)              | loc=(2, 2)        |
| rowspan=1, colspan=1    | rowspan=1, colspan=1    | rowspan=1, colspan=1|
+-------------------------+-------------------------+-------------------+

import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure(figsize=(10, 7))

# 1. Master Hero Chart: Spans Top 2 Rows across all 3 Columns
ax_master = plt.subplot2grid((3, 3), (0, 0), rowspan=2, colspan=3)
x = np.linspace(0, 10, 100)
ax_master.plot(x, np.sin(x), color="#d8b979", linewidth=2)
ax_master.set_title("Master Performance Timeline (rowspan=2, colspan=3)")
ax_master.grid(True, linestyle=":")

# 2. Bottom-Left Mini Chart
ax_sub1 = plt.subplot2grid((3, 3), (2, 0), rowspan=1, colspan=1)
ax_sub1.bar(["A", "B", "C"], [10, 24, 18], color="#38bdf8")
ax_sub1.set_title("Category Distribution")

# 3. Bottom-Middle Mini Chart
ax_sub2 = plt.subplot2grid((3, 3), (2, 1), rowspan=1, colspan=1)
ax_sub2.hist(np.random.randn(200), bins=15, color="#4ade80", edgecolor="black")
ax_sub2.set_title("Residual Variance")

# 4. Bottom-Right Mini Chart
ax_sub3 = plt.subplot2grid((3, 3), (2, 2), rowspan=1, colspan=1)
ax_sub3.pie([65, 35], labels=["Pass", "Fail"], autopct="%1.0f%%", colors=["#d8b979", "#f87171"])
ax_sub3.set_title("Pass Ratio")

fig.suptitle("TU MCA Executive Analytical Dashboard", fontsize=14, y=0.98)
fig.tight_layout()
plt.show()

Formatting Axes, Ticks, Limits & Grids

Visual polish separates amateur sketches from publication-grade scientific graphics:

• Setting Limits: ax.set_xlim(min, max) and ax.set_ylim(min, max) clamp visible domains to eliminate misleading blank borders.
• Custom Ticks & Labels: ax.set_xticks([0, 25, 50, 75, 100]) and ax.set_xticklabels(['0%', '25%', ...], rotation=45) prevent label overlaps.
• Logarithmic Scales: ax.set_yscale('log') transforms power-law or exponential distributions into readable linear slopes.
• Spine Manipulation: Hiding non-essential spines produces clean, modern graphics:

  ax.spines['top'].set_visible(False)
  ax.spines['right'].set_visible(False)

Bar Plots: Vertical, Horizontal, Grouped & Stacked

Bar plots encode numerical values as rectangular lengths across discrete categorical classes. Matplotlib supports four configurations:

1. Vertical Bar (`ax.bar`): Standard configuration for comparing quantities across discrete categories.
2. Horizontal Bar (`ax.barh`): Recommended when categorical labels have long string names, avoiding unreadable vertical tilts.
3. Grouped Bar Chart: Compares multiple sub-metrics per category side-by-side by computing mathematical offsets along the X-axis (x - width/2 and x + width/2).
4. Stacked Bar Chart: Uses the bottom parameter to stack one category directly atop another, illustrating both total volume and sub-component contributions.

import matplotlib.pyplot as plt
import numpy as np

departments = ["MCA", "CSIT", "BCA", "BBM"]
theory_pass = [42, 38, 45, 30]
practical_pass = [48, 45, 46, 35]

x = np.arange(len(departments))
bar_width = 0.35

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4.5))

# 1. Grouped Bar Chart (Side-by-Side)
ax1.bar(x - bar_width/2, theory_pass, width=bar_width, label="Theory", color="#d8b979")
ax1.bar(x + bar_width/2, practical_pass, width=bar_width, label="Practical", color="#38bdf8")
ax1.set_title("Grouped Bar Chart: Exam Mode")
ax1.set_xticks(x)
ax1.set_xticklabels(departments)
ax1.set_ylabel("Students Passed")
ax1.legend()
ax1.grid(axis="y", linestyle=":", alpha=0.6)

# 2. Stacked Bar Chart (Cumulative using 'bottom')
ax2.bar(departments, theory_pass, label="Theory Pass", color="#d8b979")
ax2.bar(departments, practical_pass, bottom=theory_pass, label="Practical Pass", color="#4ade80")
ax2.set_title("Stacked Bar Chart: Aggregate Total")
ax2.set_ylabel("Total Clearances")
ax2.legend()
ax2.grid(axis="y", linestyle=":", alpha=0.6)

plt.tight_layout()
plt.show()

Histograms: Bins, Density & Probability Distributions

A histogram approximates the probability distribution of a continuous variable by dividing the entire range into consecutive, non-overlapping intervals called bins.

• Continuous vs Discrete: While Bar charts display discrete categorical counts with artificial spacing, Histograms display continuous data where bar widths represent interval ranges and bar touching reflects continuity.
• `bins` Parameter: Can accept an integer count (e.g., bins=20) or an explicit list of boundary edges.
• `density=True`: Normalizes bin heights so the total integrated area equals 1.0, representing a valid Probability Density Function (PDF).

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(42)
mca_scores = np.random.normal(loc=72, scale=10, size=500) # Normal dist: mean=72, std=10

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

counts, bins, patches = ax.hist(
    mca_scores,
    bins=15,
    density=False,
    color="#d8b979",
    edgecolor="#0a0a0d",
    alpha=0.85
)

# Mean and standard deviation marker lines
ax.axvline(np.mean(mca_scores), color="#ef4444", linestyle="--", linewidth=2, label="Mean (72)")
ax.axvline(np.median(mca_scores), color="#38bdf8", linestyle="-.", linewidth=2, label="Median")

ax.set_title("Distribution of Student Exam Scores (N=500)", fontsize=13, pad=12)
ax.set_xlabel("Marks Obtained (0-100)")
ax.set_ylabel("Frequency (Student Count)")
ax.legend()
ax.grid(axis="y", linestyle=":", alpha=0.5)

plt.tight_layout()
plt.show()

Scatter Plots: Sizing, Colormaps & Multi-Dimensionality

Scatter plots display relationships between two continuous variables. With Matplotlib's ax.scatter(), a 2D sheet of paper can represent up to 4 dimensions of data simultaneously:

1. Dimension 1 (X position): Variable 1 (e.g., Study Hours per Week).
2. Dimension 2 (Y position): Variable 2 (e.g., Final Semester GPA).
3. Dimension 3 (Point Size `s`): Variable 3 (e.g., Lab Project Scores scaled to bubble radii).
4. Dimension 4 (Color `c` & Colormap `cmap`): Variable 4 (e.g., Attendance percentage mapped to a color spectrum).

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(101)
n_students = 60
study_hours = np.random.uniform(5, 35, n_students)
gpa = 2.0 + (study_hours * 0.055) + np.random.normal(0, 0.25, n_students)
gpa = np.clip(gpa, 2.0, 4.0)

project_score = np.random.uniform(20, 100, n_students)  # Size dimension
attendance = np.random.uniform(60, 100, n_students)     # Color dimension

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

scatter = ax.scatter(
    study_hours,
    gpa,
    s=project_score * 2.5,   # Bubble size
    c=attendance,            # Continuous color
    cmap="viridis",          # Perceptually uniform colormap
    alpha=0.75,
    edgecolors="white",
    linewidth=0.8
)

# Add Colorbar bound to scatter object
cbar = fig.colorbar(scatter, ax=ax)
cbar.set_label("Attendance Percentage (%)")

ax.set_title("Multivariate Student Analytics (X: Hours, Y: GPA, Size: Project, Color: Attendance)")
ax.set_xlabel("Weekly Study Hours")
ax.set_ylabel("Graduation GPA (Scale 4.0)")
ax.grid(True, linestyle=":", alpha=0.5)

plt.tight_layout()
plt.show()

Pie Charts: Autopct, Explode & Shadows

Pie charts illustrate proportional parts-of-a-whole compositions. In Matplotlib, ax.pie() provides parameters for precision formatting:

• `autopct`: String formatter (e.g., '%1.1f%%') calculating and displaying percentage text automatically.
• `explode`: Fractional tuple (e.g., (0, 0.1, 0, 0)) physically detaching selected slices for emphasis.
• `startangle`: Rotates the initial pie slice counter-clockwise from the X-axis (typically 90° for vertical symmetry).
• Academic Critique: Data science literature cautions against pie charts when slices exceed 5 or have similar percentages, as human perception judges lengths (Bar plots) far more accurately than angles and areas.

import matplotlib.pyplot as plt

grades = ["Distinction", "First Division", "Second Division", "Failed"]
students = [45, 80, 25, 10]
colors = ["#d8b979", "#38bdf8", "#a8a29e", "#ef4444"]
explode = (0.1, 0, 0, 0)  # Emphasize top performers

fig, ax = plt.subplots(figsize=(6.5, 6.5))

wedges, texts, autotexts = ax.pie(
    students,
    labels=grades,
    autopct="%1.1f%%",
    startangle=140,
    explode=explode,
    colors=colors,
    shadow=True,
    textprops={"fontsize": 10}
)

# Enhance visibility of percentage labels inside wedges
for at in autotexts:
    at.set_color("#0b0d13")
    at.set_weight("bold")

ax.set_title("TU MCA Cohort Final Grading Breakdown", pad=20, fontsize=12)
plt.tight_layout()
plt.show()

Box Plots: Five-Number Summary, IQR & Outliers

The Box-and-Whisker plot (invented by John Tukey) is the gold standard for comparing distributions across groups without assuming normality. It visually encapsulates the Five-Number Summary:

1. Median ($Q_2$ / 50th Percentile): The central dividing line inside the box.
2. Lower Quartile ($Q_1$ / 25th Percentile): The bottom hinge of the rectangular box.
3. Upper Quartile ($Q_3$ / 75th Percentile): The top hinge of the rectangular box.
4. Interquartile Range ($IQR$): The vertical height of the box ($IQR = Q_3 - Q_1$), containing the middle 50% of observation records.
5. Whiskers: Extend to the furthest data point within $1.5 \times IQR$ from the hinges ($Q_1 - 1.5 \times IQR$ and $Q_3 + 1.5 \times IQR$).
6. Outliers (Fliers): Any observation falling strictly outside the $1.5 \times IQR$ fences, rendered as individual circular markers.

   o   <-- OUTLIER / FLIER (> Q3 + 1.5 * IQR)
   |
+--+--+  <-- UPPER WHISKER: Max value within (Q3 + 1.5 * IQR)
   |
   |
+--+--------------------+  <-- UPPER QUARTILE (Q3 / 75th Percentile)
|                       |
|                       |  <-- INTERQUARTILE RANGE (IQR = Q3 - Q1)
|  ===================  |  <-- MEDIAN (Q2 / 50th Percentile)
|                       |      (Middle 50% of all data)
|                       |
+--+--------------------+  <-- LOWER QUARTILE (Q1 / 25th Percentile)
   |
   |
+--+--+  <-- LOWER WHISKER: Min value within (Q1 - 1.5 * IQR)
   |
   o   <-- OUTLIER / FLIER (< Q1 - 1.5 * IQR)

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(42)
mca_marks = np.random.normal(75, 8, 100)
csit_marks = np.random.normal(70, 12, 100)
# Inject deliberate outliers
csit_marks = np.append(csit_marks, [30, 32, 99])

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

bp = ax.boxplot(
    [mca_marks, csit_marks],
    labels=["MCA Cohort", "CSIT Cohort"],
    patch_artist=True,   # Fill with color
    notch=False,
    showmeans=True
)

# Custom color styling
colors = ["#d8b979", "#38bdf8"]
for patch, color in zip(bp['boxes'], colors):
    patch.set_facecolor(color)
    patch.set_alpha(0.7)

ax.set_title("Cross-Department Exam Marks Variance & Outlier Detection")
ax.set_ylabel("Marks (0-100)")
ax.grid(axis="y", linestyle=":", alpha=0.5)

plt.tight_layout()
plt.show()

Exporting Graphics (`savefig`) & Memory Safety

In production environments (such as web microservices or automated reporting daemons), figures must be saved to disk rather than displayed interactively with plt.show():

# High-Resolution Publication Export
fig.savefig(
    "mca_academic_report.png",
    dpi=300,                  # 300 Dots Per Inch for print quality
    bbox_inches="tight",      # Trims unnecessary blank whitespace padding
    transparent=False,        # Preserves opaque solid background
    format="png"              # Raster (PNG, JPG) or Vector (PDF, SVG, EPS)
)

# CRITICAL: Prevent Memory Leaks in Server Batch Pipelines!
plt.close(fig)

Full Exam Project: 4-Panel Executive Student Analytics Dashboard

A standard 10-mark long coding problem in TU MCA examinations states: "Write a complete Python script utilizing Matplotlib to construct a multi-panel visual dashboard displaying student performance across four diverse plot types: a grouped bar chart, a scatter correlation, a boxplot outlier detector, and an exploded pie chart."

import matplotlib.pyplot as plt
import numpy as np

def build_student_dashboard():
    # Simulated Examination Data
    semesters = ["Sem 1", "Sem 2", "Sem 3", "Sem 4"]
    theory_avg = [68, 72, 75, 80]
    practical_avg = [78, 82, 85, 89]

    np.random.seed(42)
    study_hours = np.random.uniform(10, 40, 50)
    gpa = 2.2 + (study_hours * 0.045) + np.random.normal(0, 0.2, 50)

    dept_a = np.random.normal(74, 6, 40)
    dept_b = np.random.normal(70, 10, 40)
    dept_c = np.random.normal(82, 5, 40)

    grade_labels = ["Distinction", "1st Div", "2nd Div", "Fail"]
    grade_shares = [35, 45, 15, 5]

    # Initialize Canvas
    fig = plt.figure(figsize=(12, 8))

    # PANEL 1: Grouped Bar Chart (Top-Left)
    ax1 = plt.subplot2grid((2, 2), (0, 0))
    x = np.arange(len(semesters))
    width = 0.35
    ax1.bar(x - width/2, theory_avg, width, label="Theory", color="#d8b979")
    ax1.bar(x + width/2, practical_avg, width, label="Practical", color="#38bdf8")
    ax1.set_title("1. Semester Mean Scores (Grouped Bar)")
    ax1.set_xticks(x)
    ax1.set_xticklabels(semesters)
    ax1.set_ylabel("Marks (%)")
    ax1.legend()
    ax1.grid(axis="y", linestyle=":", alpha=0.5)

    # PANEL 2: Scatter Plot (Top-Right)
    ax2 = plt.subplot2grid((2, 2), (0, 1))
    sc = ax2.scatter(study_hours, gpa, c=gpa, cmap="plasma", alpha=0.85, edgecolors="white")
    ax2.set_title("2. Hours vs GPA Correlation (Scatter)")
    ax2.set_xlabel("Weekly Study Hours")
    ax2.set_ylabel("GPA")
    fig.colorbar(sc, ax=ax2, label="GPA Scale")
    ax2.grid(True, linestyle=":", alpha=0.5)

    # PANEL 3: Box-and-Whisker Plot (Bottom-Left)
    ax3 = plt.subplot2grid((2, 2), (1, 0))
    ax3.boxplot([dept_a, dept_b, dept_c], labels=["Software", "Network", "AI"], patch_artist=True)
    ax3.set_title("3. Department Score Variance (Box Plot)")
    ax3.set_ylabel("Marks Distribution")
    ax3.grid(axis="y", linestyle=":", alpha=0.5)

    # PANEL 4: Exploded Pie Chart (Bottom-Right)
    ax4 = plt.subplot2grid((2, 2), (1, 1))
    ax4.pie(grade_shares, labels=grade_labels, autopct="%1.1f%%", explode=[0.1, 0, 0, 0],
            colors=["#d8b979", "#38bdf8", "#a8a29e", "#ef4444"], startangle=120)
    ax4.set_title("4. Grade Classification (Pie)")

    # Overall Polish
    fig.suptitle("TU MCA504 • Comprehensive Student Performance Dashboard", fontsize=15, y=0.98)
    fig.tight_layout()
    fig.savefig("tu_student_dashboard.png", dpi=300, bbox_inches="tight")
    print("[SUCCESS] Dashboard generated and exported to 'tu_student_dashboard.png'.")
    plt.show()

if __name__ == "__main__":
    build_student_dashboard()