Chapter 3 — Plotting With Pyplot

What is Pyplot?
Pyplot is a module in the matplotlib library that provides a MATLAB-like interface to create 2D plots easily in Python. It converts arrays or lists of data points into visual graphs (line plots, bar charts, scatter plots, histograms, etc.) and provides functions to label axes, add titles, legends, grids and save figures.

Why use Pyplot?
Visualisation helps to understand trends, patterns, distributions and relationships in data quickly — essential for data analysis in Informatics Practices.

Basic workflow
1. Import pyplot: import matplotlib.pyplot as plt.
2. Prepare data (lists, tuples or NumPy arrays).
3. Call a plotting function (e.g., plt.plot, plt.bar, plt.scatter, plt.hist, plt.pie).
4. Add labels/title/legend: plt.xlabel, plt.ylabel, plt.title, plt.legend.
5. Display figure: plt.show(). Optionally save: plt.savefig('file.png').

Key functions (examples)

import matplotlib.pyplot as plt
x = [1,2,3,4]
y = [10,20,25,30]
plt.plot(x, y, marker='o', color='b', linestyle='-')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.title('Simple Line Plot')
plt.grid(True)
plt.show()

Customization options
You can change color, marker, line style, linewidth, axis limits (plt.xlim, plt.ylim), tick labels, font sizes and figure size (plt.figure(figsize=(w,h))). Use plt.subplot or plt.subplots to draw multiple plots in one figure.

Common plot types and when to use
- Line plot: time series or continuous change.
- Bar chart: comparisons between categories (sales per month).
- Scatter plot: relationship/correlation between two numeric variables.
- Histogram: distribution of a numeric variable (frequency of score ranges).
- Pie chart: parts of a whole (percentage share).
- Box plot: spread, median and outliers.

Good practice
Always label axes, add a title and legend for multiple series, use grid lines for readability and choose appropriate plot type for the data. Keep plots simple and informative.

Overview
matplotlib.pyplot (commonly imported as plt) is the state-machine interface of Matplotlib. It provides functions to create, customize and display 2D plots (line, bar, scatter, histogram, pie, etc.). Typical workflow: prepare data, call plotting functions, customize (labels, title, legend), then display with plt.show() or save with plt.savefig().

Basic steps

• Import libraries: import matplotlib.pyplot as plt and often import numpy as np for numeric arrays.
• Prepare x and y data (lists or NumPy arrays). Length of x and y must match for most plots.
• Call a plotting function, e.g. plt.plot(x, y, fmt, label='...').
• Add labels and title: plt.xlabel(), plt.ylabel(), plt.title().
• Add legend and grid: plt.legend(), plt.grid(True).
• Show or save: plt.show() or plt.savefig('plot.png').

Common pyplot functions

• plt.plot() — line plot; accepts format string (color/marker/linestyle) and label.
• plt.scatter() — scatter plot (x vs y points).
• plt.bar(), plt.barh() — vertical/horizontal bar charts.
• plt.hist() — histogram for distribution of values.
• plt.pie() — pie chart for proportional data.
• plt.figure(), plt.subplots(), plt.subplot() — create figures and subplots.
• plt.xlim(), plt.ylim() — set axis limits.
• plt.savefig() — save the current figure to a file.

Simple code example

import matplotlib.pyplot as plt
x = [1, 2, 3, 4, 5]
y = [10, 15, 13, 17, 20]
plt.plot(x, y, 'o-', color='blue', label='Sales')
plt.xlabel('Month')
plt.ylabel('Sales (units)')
plt.title('Monthly Sales')
plt.grid(True)
plt.legend()
plt.show()

Tips for good plots

• Always label axes and add a meaningful title.
• Use a legend if multiple series are plotted.
• Choose appropriate plot type for the data (time series → line, categories → bar, distribution → histogram, proportions → pie, relationships → scatter).
• Use plt.subplots() to compare multiple plots side-by-side.
• Keep visuals simple and readable: avoid too many colors or markers.

What is a line plot? A line plot is a basic 2-D chart that connects data points with straight line segments. It is used to show how a numeric variable changes continuously or sequentially (e.g., over time, distance, or ordered categories). Line plots emphasize trends, slopes (rates of change), and patterns.

When to use: use line plots for time series, measurements over an ordered index, or to compare trends among multiple series.

Key elements in matplotlib.pyplot: the main call is plt.plot(x, y, ...). Common parameters: x and y (data), label, color, linestyle, marker, linewidth. Other important functions: plt.title(), plt.xlabel(), plt.ylabel(), plt.legend(), plt.grid(), plt.xlim()/plt.ylim().

Multiple series: call plt.plot() more than once (or pass multiple x,y pairs) to draw multiple lines on the same axes; use label and plt.legend() to identify them.

Interpreting a line plot: slope between two points gives rate of change; upward slope = increase, downward slope = decrease. Watch for overplotting, noisy data, and uneven x spacing (use proper x values or interpolation).

Best practices: label axes and units, give a descriptive title, choose distinguishable colors/markers for multiple lines, add gridlines or ticks for readability, and avoid connecting points when data are categorical or non-continuous (use markers or step plots instead).

What is a scatter plot?
A scatter plot (or scatter chart) is a type of plot that shows the relationship between two numeric variables by drawing a point for each pair of values (x, y). It is used to observe patterns, trends, correlation, clusters and outliers.

When to use: Use a scatter plot when you want to examine the association between two continuous variables (for example, study hours vs. marks, height vs. weight).

Basic Pyplot syntax
matplotlib.pyplot.scatter(x, y, s=..., c=..., marker=..., cmap=..., alpha=..., edgecolors=...)

Key parameters:
- x, y: sequences of values for horizontal and vertical coordinates.
- s: size of points (can be a single value or array for bubble charts).
- c: color or sequence of values to map to colors (works with cmap).
- marker: point style (e.g., 'o', 'x', '^').
- cmap: colormap (e.g., 'viridis', 'coolwarm') used when c is numeric.
- alpha: transparency (helps with overplotting).
- edgecolors: color of marker borders.

Interpretation:
- Positive correlation: points slope upward (as x increases, y tends to increase).
- Negative correlation: points slope downward.
- No correlation: points scattered randomly.
- Clusters: groups of points indicate subgroups.
- Outliers: isolated points that deviate from the pattern.

Extensions:
- Bubble chart: scale point sizes (s) to represent a third numeric variable.
- Color mapping: use c + cmap to show a fourth dimension (e.g., temperature).
- Regression line: fit and draw a line to summarize trend (e.g., least squares line).
- Jitter: add tiny random noise to discrete x or y values to reduce overlap.

Small example (Pyplot)

import matplotlib.pyplot as plt
x = [1,2,3,4,5]
y = [2,4,1,3,5]
plt.scatter(x, y, s=50, c='blue', alpha=0.7, edgecolors='k')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Simple scatter plot')
plt.show()

Tips: use alpha when points overlap; add a colorbar when using numeric color mapping; use descriptive axis labels and legend when representing categories.

What is a bar chart?

A bar chart is a categorical plot that represents data with rectangular bars whose lengths are proportional to the values they represent. It is used to compare discrete categories or groups. In Matplotlib (Pyplot) the main functions are plt.bar() for vertical bars and plt.barh() for horizontal bars.

When to use: Use bar charts when you have a small-to-moderate number of categories and you want to compare their numeric values (counts, sums, averages, percentages).

Key components:

• Categories (x-axis): names or labels for each bar.
• Values (y-axis): height (or length) of each bar.
• Bar width and position: control spacing and grouping of bars.
• Colors, edge colors, labels, legend and annotations for readability.

How to create a basic bar chart (steps):

1. Prepare data: categories = ['A','B','C'], values = [10, 20, 15].
2. Create x positions: x = np.arange(len(categories)).
3. Plot bars: plt.bar(x, values, width=0.6).
4. Label ticks: plt.xticks(x, categories).
5. Add title/labels/legend and show: plt.title(...); plt.xlabel(...); plt.show().

Special types and techniques:

• Grouped (side-by-side) bars: use offsets for x positions (e.g. x + i*width) to compare multiple series across the same categories.
• Stacked bars: use the bottom parameter to stack one series on top of another.
• Horizontal bars: use plt.barh() for long category names or better readability.
• Error bars: add uncertainty with yerr parameter.
• Annotations: use plt.text() to show numeric values on bars.

Example code snippets (Pyplot):

Basic vertical bar:

import matplotlib.pyplot as plt
import numpy as np
categories = ['Math', 'Physics', 'Chem']
values = [78, 85, 72]
x = np.arange(len(categories))
plt.bar(x, values, color='teal')
plt.xticks(x, categories)
plt.ylabel('Score')
plt.title('Student Scores')
plt.show()

Grouped bars (two series):

width = 0.35
x = np.arange(len(categories))
plt.bar(x - width/2, male_scores, width, label='Male')
plt.bar(x + width/2, female_scores, width, label='Female')
plt.xticks(x, categories)
plt.legend()

Stacked bars:

plt.bar(x, part1)
plt.bar(x, part2, bottom=part1)
# bottom can be cumulative sums for more than two layers

Good practices:

• Sort bars when order matters (descending/ascending) to emphasize differences.
• Keep category names readable (rotate x-tick labels if needed: rotation=45).
• Use colors consistently and add a legend for multiple series.
• Annotate values if precise numbers matter.

Note for CBSE Class 12: understand how to prepare data arrays, calculate positions, use width and bottom parameters, and interpret grouped and stacked bar charts.

What is a histogram?
A histogram is a graphical representation of the distribution of numerical (continuous or discrete) data. Data are grouped into contiguous intervals called bins or classes; the height of each bar shows the frequency (count) or density of observations in that bin. Histograms reveal shape (symmetry, skewness), spread, central tendency, gaps, outliers and modality (unimodal, bimodal).

Histogram vs Bar Chart
Histograms are for continuous numerical data and use adjacent bars (no gaps). Bar charts are for categorical data and have gaps between bars.

Key components
- Bins: contiguous intervals that partition the data range.
- Counts/frequencies: number of observations per bin.
- Bin edges: numeric boundaries for each bin.
- Density/normalization: whether heights show raw counts or probability density (area sums to 1).

Using matplotlib (pyplot)
Typical call: plt.hist(data, bins=..., range=..., density=..., cumulative=..., histtype=..., rwidth=..., color=..., alpha=..., edgecolor=...). The function returns (counts, bin_edges, patches) or you can use np.histogram to get counts and edges without plotting.

Interpreting histograms
- Tall bars indicate intervals with many observations.
- The shape indicates distribution (normal, skewed left/right, uniform, multimodal).
- Changing number/width of bins can reveal or hide features; choose bins carefully.

Choosing number/width of bins
- Sturges' rule: k = 1 + log2(n) (simple, often used for smaller n).
- Square-root rule: k ≈ sqrt(n).
- Freedman–Diaconis rule (robust): bin width h = 2 * IQR / n^(1/3), then k ≈ (max - min) / h. IQR is interquartile range.

Common histogram options
- bins: integer or sequence of edges.
- range: (min, max) to limit the plotted range.
- density=True: plot probability density (area=1).
- cumulative=True: cumulative histogram.
- histtype: 'bar', 'barstacked', 'step', 'stepfilled'.
- rwidth: bar width relative to bin width.
- alpha, color, edgecolor: styling.

Returned arrays
From counts, bin_edges = np.histogram(data, bins=...): counts[i] is count in interval [bin_edges[i], bin_edges[i+1]). For plotting, use edges to position bars.

Applications / why it matters
Histograms are widely used in statistics, data analysis, quality control, and machine learning for exploratory data analysis, feature understanding, detecting skewness, and selecting transformations (e.g., log) or binning schemes.

What is a Pie Chart?

A pie chart is a circular statistical graphic divided into slices to illustrate numerical proportions. Each slice's angle (and area) is proportional to the quantity it represents relative to the whole. Pie charts are best for showing part-to-whole relationships when there are a small number of categories (typically < 6).

When to use

• To display percentage or proportion of categories that sum to a whole (100%).
• When categories are few and differences are easily distinguishable visually.
• Avoid when there are many categories, values are similar, or precise comparisons are needed — use bar charts instead.

Creating a pie chart with Matplotlib (pyplot)

Basic call: plt.pie(sizes, labels=labels). Common useful parameters:

• labels: list of category names.
• autopct: string like '%1.1f%%' or a function to show percentages or values on slices.
• explode: list of offsets (floats) to "pull" slices out for emphasis.
• startangle: rotation of start angle in degrees (e.g., 90 to start at top).
• shadow=True: draw a shadow under the pie.
• colors: list of colors for slices.
• pctdistance and labeldistance: control placement of percentage text and labels.
• counterclock: False to draw clockwise.
• Call plt.axis('equal') to ensure the pie is drawn as a circle.

Simple example code

import matplotlib.pyplot as plt

sizes = [40, 25, 20, 15]
labels = ['A', 'B', 'C', 'D']
explode = [0.1, 0, 0, 0]  # pull out the first slice

plt.pie(sizes, labels=labels, explode=explode, autopct='%1.1f%%', startangle=90, shadow=True)
plt.axis('equal')  # keep the pie circular
plt.show()

Advanced tips

• Donut chart: draw a white circle at center or use wedgeprops={'width': 0.3} (Matplotlib >= 3.4) to create a ring.
• Exploded slice: emphasize a category with a nonzero value in explode.
• Show absolute values with a custom autopct function that receives percentage and can compute absolute values from total.
• Use colors and legend for better readability; keep color palettes consistent and colorblind-friendly.
• For nested/stacked proportions (hierarchical data), draw concentric pies (multiple calls to plt.pie with different radii).

Limitations

• Hard to compare slices of similar size.
• Not suitable for many categories or precise value comparison.

What is a box plot? A box plot (box-and-whisker plot) is a compact graphical summary of a numeric dataset that shows its central tendency, spread, and potential outliers. It is commonly used in Exploratory Data Analysis (EDA) to compare distributions across groups.

• Components:
  • Box: spans from the first quartile (Q1, 25th percentile) to the third quartile (Q3, 75th percentile).
  • Median line: Q2 (50th percentile) shown inside the box.
  • Whiskers: lines extending from the box to the most extreme data points within the fences (usually Q1 - 1.5·IQR and Q3 + 1.5·IQR).
  • Outliers (fliers): points beyond the whiskers plotted individually.
  • IQR (interquartile range): Q3 - Q1, measure of spread for the middle 50% of data.
• How to compute (brief):
  1. Sort the data.
  2. Find the median (Q2). Split data into lower and upper halves (exclude the median if odd n).
  3. Q1 is median of lower half; Q3 is median of upper half.
  4. Compute IQR = Q3 - Q1. Whiskers extend to the smallest/largest points within [Q1 - 1.5·IQR, Q3 + 1.5·IQR]. Points outside are outliers.
• Interpretation: Box height shows spread of middle 50%. Median position inside the box indicates skewness (median closer to Q1 implies positive skew). Whisker lengths and outliers indicate tails and extreme values. Comparing boxes across groups reveals differences in center, spread and outliers.
• Using matplotlib.pyplot: use plt.boxplot(data) to draw a box plot. Useful parameters: notch (show median confidence notch), vert (vertical/horizontal), showmeans/showfliers, labels, widths, and custom properties (boxprops, whiskerprops, flierprops, medianprops). Combine with jittered scatter (stripplot) for raw points.

Definition: Area plots and stack plots are visualization techniques that display quantitative data as filled areas. They are useful to show how a value changes over a continuous variable (usually time) and how multiple components contribute to a whole.

Area Plot: An area plot fills the region between a curve and a baseline (often the x-axis). It emphasizes magnitude of change over the x-axis while keeping the display similar to a line chart but with the area shaded to show volume.

Stack Plot: A stack plot (stacked area plot) layers multiple area plots on top of each other so that the vertical extent shows the cumulative total and each band shows a component's contribution. It is useful to compare parts-to-whole over time.

When to use:

• Area plot: highlight total magnitude or trend of a single series (e.g., monthly sales).
• Stack plot: show composition and how components change and contribute to the total (e.g., energy production by source).

Key Pyplot functions (Matplotlib):

• plt.fill_between(x, y1, y2) — fills area between two curves or between curve and baseline (y2 often 0).
• plt.stackplot(x, y1, y2, y3, ...) — creates stacked areas for multiple series.
• Common options: color, alpha (transparency), labels, linewidth, baseline (in stackplot).

How to read and interpret:

• In an area plot the vertical height at x gives the value of the series; the filled region makes trends and total magnitude clear.
• In a stack plot the top edge of the stacked areas gives the cumulative total; the thickness of each colored band shows each component's magnitude.

Design tips:

• Use transparency (alpha) so overlapping areas remain readable.
• Use contrasting but harmonious colors and a legend for components.
• For many components, consider an alternative (like small multiples) because stacked plots can become cluttered.

What are subplots? Subplots let you place multiple plots (axes) inside a single figure so related visualizations can be compared side-by-side. In matplotlib there are two common styles: the state-machine (pyplot) style with plt.subplot and the object-oriented style with fig, ax = plt.subplots(). The latter is recommended for clarity and control.

Basic ideas:

• plt.subplot(nrows, ncols, index) creates or selects the axes at position index (1-based) in an nrows by ncols grid.
• fig, ax = plt.subplots(nrows, ncols) returns a figure and an array (or single object) of Axes objects that you can iterate over and configure independently.
• Figure management functions: plt.figure() to create a new figure, fig.set_size_inches() or figsize=(w,h) to set size, plt.tight_layout() or fig.tight_layout() to avoid overlaps, plt.savefig() to save, and plt.close() to release memory.

Figure and axes control options: sharex/sharey to align axes scales, gridspec or GridSpec for custom span of rows/columns, constrained_layout=True for automatic spacing, suptitle for a figure-level title, and dpi to control output resolution.

Recommended workflow (object-oriented):

import matplotlib.pyplot as plt
fig, axes = plt.subplots(2, 2, figsize=(10, 6), constrained_layout=True)
# axes is a 2x2 array; plot on each axis
axes[0, 0].plot(x1, y1)
axes[0, 0].set_title('Plot A')
axes[0, 1].scatter(x2, y2)
# share x-axis example
fig.suptitle('Comparison of four charts')
plt.savefig('four_charts.png', dpi=150)
plt.close(fig)

Practical tips:

• Use figsize=(width_inches, height_inches) with appropriate dpi to get desired pixel size for exports.
• Flatten axes arrays with axes.ravel() or axes.flatten() when iterating.
• Use sharex=True or sharey=True when comparing the same quantity across subplots to align ticks and zooms.
• Call plt.close(fig) in scripts or loops to free memory and avoid display of intermediate figures.

The Object-Oriented (OO) interface in matplotlib separates the concepts of a Figure (the whole drawing area or canvas) and one or more Axes (individual plots inside the Figure). Using the OO interface is recommended for clarity and control, especially when creating multiple plots, subplots or embedding figures in applications.

Key concepts:

• Figure: the overall window or page. It can contain multiple Axes, titles, legends and other artists. Created by plt.figure() or returned by plt.subplots().
• Axes: a single plot area with x and y axes (note: despite the name, an Axes is one plot). You call plotting methods on the Axes object, for example ax.plot(), ax.bar(), ax.set_title() and ax.set_xlabel().
• Why OO? Avoids global state used by plt, easier to make multiple independent plots, clearer code for functions and GUIs.

Basic creation patterns:

import matplotlib.pyplot as plt
# Single Axes
fig, ax = plt.subplots(figsize=(6,4))
ax.plot(x, y)
ax.set_title('Title')

# Multiple subplots (2 rows, 2 cols)
fig, axes = plt.subplots(2, 2, figsize=(10,8))
axes[0,0].plot(x1, y1)
axes[1,1].bar(x2, h2)

# Alternative: create Figure then add Axes
fig = plt.figure(figsize=(6,4))
ax = fig.add_subplot(111)  # 1x1 grid, first subplot

Typical Axes methods you will use: ax.plot, ax.scatter, ax.bar, ax.hist, ax.set_title, ax.set_xlabel, ax.set_ylabel, ax.set_xlim, ax.set_ylim, ax.legend, ax.grid, ax.annotate. For saving use fig.savefig('name.png').

Why customize? Customizing plot appearance makes charts clearer, highlights important patterns, matches presentation styles, and improves readability for different audiences (reports, slides, dashboards).

Main elements to customize

• Figure size and resolution: control space and clarity using plt.figure(figsize=(w,h), dpi=...).
• Colors and palettes: choose colors (named, hex, or tab colors) and palettes to convey meaning and ensure accessibility (color-blind friendly palettes).
• Lines and markers: change linestyle, linewidth, marker, and markersize to emphasize points or trends.
• Labels, title, and fonts: add plt.title, plt.xlabel, plt.ylabel, and control font size, weight and family for readability.
• Axes limits and ticks: set plt.xlim, plt.ylim, and custom ticks/rotation (plt.xticks(..., rotation=...)) to improve interpretation.
• Grid and background: use plt.grid and style themes (e.g., plt.style.use('seaborn-darkgrid')) for context.
• Legends: place and style legends with plt.legend and parameters like loc and fontsize.
• Annotations and text: call out values using plt.annotate or plt.text.
• Layouts and subplots: adjust spacing with plt.tight_layout() and use plt.subplots for multi-panel plots.
• Saving figures: export with plt.savefig('name.png', dpi=300, bbox_inches='tight') for publication quality.

Short code example

import matplotlib.pyplot as plt

x = [1,2,3,4]
y = [10, 15, 13, 17]

plt.figure(figsize=(8,4), dpi=100)
plt.plot(x, y, color='tab:blue', linestyle='--', linewidth=2, marker='o', markersize=6, alpha=0.8, label='Sales')
plt.title('Monthly Sales', fontsize=14)
plt.xlabel('Month', fontsize=12)
plt.ylabel('Sales (units)', fontsize=12)
plt.grid(True, linestyle=':', alpha=0.7)
plt.legend()
plt.tight_layout()
plt.show()

Best practices

• Use clear, descriptive axis labels including units.
• Limit the number of colors/markers for clarity.
• Prefer high contrast for text and lines; use color-blind friendly palettes when needed.
• Annotate only key points to avoid clutter.
• Test figures at final size (slide, print) and export at appropriate DPI.

What are line and marker styles?

In Matplotlib's pyplot, line and marker styles control how data points and the lines connecting them are drawn on a plot. Line styles determine the appearance of connecting lines (solid, dashed, dotted, etc.). Marker styles determine the symbol used at each data point (circle, square, triangle, cross, etc.). These options help distinguish multiple series, highlight important points, and improve readability.

Key parameters (pyplot.plot)

• color or c: color of line/marker (e.g. 'r', 'g', '#1f77b4').
• linestyle or ls: style of connecting line (e.g. '-' , '--' , '-.' , ':').
• linewidth or lw: thickness of the line (float).
• marker: symbol for each data point (e.g. 'o', 's', '^', 'x', '+', 'D').
• markersize or ms: size of marker (float).
• markeredgecolor (mec), markerfacecolor (mfc), markeredgewidth (mew)
• alpha: transparency (0.0 transparent to 1.0 opaque).

Shorthand format string

Matplotlib accepts a compact format string fmt combining color, marker and line style: plot(x, y, 'g--o') means green dashed line with circle markers. Order of components is flexible but must be valid.

Common line styles and markers

• Line styles: '-' (solid), '--' (dashed), '-.' (dash-dot), ':' (dotted), 'None'/ '' (no line).
• Markers: 'o' (circle), 's' (square), '^' (triangle_up), 'v' (triangle_down), 'D' (diamond), '+', 'x', '*', etc.

Why use different styles?

• Differentiate multiple series when color alone may not be enough (printed B/W or for color-blind readers).
• Emphasize particular data points (peaks, outliers) using markers and contrasting edge/fill colors.
• Improve clarity: use thin dotted lines for reference trends and bold solid lines for main data.

Practical tips

• Use markers only when number of data points is moderate; many markers can clutter dense plots—use markersize accordingly.
• Combine markerfacecolor and markeredgecolor to make markers readable on any background.
• Use alpha to reduce visual dominance of less important series.

Small code examples

# Basic: red solid line with circle markers
plt.plot(x, y, color='r', linestyle='-', marker='o', linewidth=2, markersize=6)

# Shorthand: blue dashed line with triangle-up markers
plt.plot(x, y, 'b--^')

# Custom marker edge and face
plt.plot(x, y, marker='s', mfc='white', mec='black', mew=1.0)

Accessibility

Combine line styles (dashed/dotted) with markers so that plots remain understandable in grayscale or to viewers with color-vision deficiency.

What are colors in matplotlib?
In Pyplot (matplotlib) a 'color' tells the renderer how to paint markers, lines, bars, text and pixels. Colors can be given in several ways: named color strings (eg. 'red', 'blue'), single-letter shortcuts ('r','g'), hex codes ('#1f77b4'), RGB/RGBA tuples with values 0-1 (eg. (0.12, 0.47, 0.71)) or 0-255 integers scaled to 0-1, and greyscale strings ('0.5'). RGBA adds an alpha channel for transparency where alpha ranges 0 (transparent) to 1 (opaque).

What is a colormap?
A colormap (cmap) is a predefined mapping from scalar values to colors. Colormaps are used when you color points/pixels according to data values (eg. temperature, elevation, intensity). Matplotlib provides many colormaps designed for different purposes and perceptual properties.

Types of colormaps

• Sequential: for data that goes from low to high (eg. 'viridis', 'plasma', 'magma').
• Diverging: for data with a meaningful center (eg. deviations around zero) (eg. 'RdBu', 'seismic').
• Qualitative (categorical): for discrete categories where ordering is not important (eg. 'tab10', 'Set1').

How it works in code
Most plotting functions accept a 'c' (color data) and a 'cmap' argument. Matplotlib normalizes the 'c' values (mapping them to 0..1 via vmin/vmax or a Normalize instance) and then looks up colors from the colormap. You can add a colorbar to show the mapping.

import matplotlib.pyplot as plt
import numpy as np
x = np.random.rand(100)
y = np.random.rand(100)
values = x + y  # scalar used for color
plt.scatter(x, y, c=values, cmap='viridis')
plt.colorbar(label='x + y')
plt.show()

Normalization and explicit control
To control mapping use vmin/vmax or matplotlib.colors.Normalize. For example:

from matplotlib import colors
norm = colors.Normalize(vmin=0, vmax=10)
plt.scatter(x, y, c=values, cmap='plasma', norm=norm)

Good practices

• Use perceptually uniform colormaps (eg. 'viridis', 'cividis') so differences in color correspond to perceived data differences.
• Avoid rainbow-like 'jet' for continuous data (it distorts perception and is not colorblind-friendly).
• For categorical data use ListedColormap or built-in qualitative cmaps like 'tab10'.
• Always include a colorbar or legend and label units where relevant.

Accessibility
Consider colorblind-safe palettes and ensure contrast for viewers with low vision. 'cividis' and 'viridis' are good default choices.

Overview: In Pyplot (matplotlib) a legend explains plotted elements (lines, markers, patches) by showing labels for them; an annotation adds explanatory text tied to a point in the plot, optionally with an arrow. Together they improve readability and highlight important features.

Legends: Create legends by giving plot calls a label and calling plt.legend(). Control position with loc (e.g. 'best', 'upper right', 0..10), or use bbox_to_anchor for exact placement. Customize title, number of columns, font size, frame, and transparency.

# example
plt.plot(x1, y1, label='Sensor A')
plt.plot(x2, y2, label='Sensor B')
plt.legend(loc='upper left', title='Sensors', fontsize=10, frameon=True)

If you need specific handles/labels, fetch them with handles, labels = ax.get_legend_handles_labels() and pass to ax.legend(handles, labels). To avoid duplicate labels (e.g., scatter + line), set label='_nolegend_' or supply unique labels.

Annotations: Use plt.text(x, y, s) to place simple text at data coordinates. Use plt.annotate() to attach text to a point and draw an arrow from text to the point. Main parameters are xy (point being annotated), xytext (text position), arrowprops (arrow style), and textcoords (coordinate system for text).

# example
plt.scatter(x, y)
idx = y.argmax()
plt.annotate('Peak', xy=(x[idx], y[idx]), xytext=(x[idx]+1, y[idx]+5),
             arrowprops=dict(arrowstyle='->', color='red'),
             bbox=dict(boxstyle='round,pad=0.3', fc='yellow', alpha=0.4))

Coordinate systems: xycoords and textcoords control whether coords are in data units, axes fraction (0..1), figure fraction, or 'offset points' for pixel offsets. Example: textcoords='offset points' with xytext=(0,10) places text 10 points above the annotated point.

Best practices:

• Keep legend labels short and descriptive; use ncol to reduce legend height.
• Place legends where they don't obscure data (use loc='best' or manual bbox_to_anchor).
• Annotate only key points (peaks, thresholds, anomalies) to avoid clutter.
• Use contrasting colors and a semi-transparent bbox for annotation text to keep readability over busy plots.

What are ticks and tick labels?
In a plot, ticks are the small marks on the axes that indicate positions along the axis (numeric or categorical). Tick labels are the textual labels shown next to those marks (e.g., numbers, dates, category names). Ticks and their labels help readers interpret data scales and values.

Major vs. minor ticks
Major ticks are the principal marks shown by default (often with labels). Minor ticks subdivide the intervals between major ticks and usually do not carry labels. Using minor ticks improves readability for fine-grained reading of values.

Default behavior in matplotlib.pyplot
Matplotlib chooses tick positions automatically (AutoLocator) and formats labels to be readable. You can override this behavior using functions such as plt.xticks(), plt.yticks(), axis methods (ax.set_xticks, ax.set_xticklabels) and custom locators/formatters from matplotlib.ticker (e.g., MultipleLocator, MaxNLocator, LogLocator, FuncFormatter).

Common customizations

• Set explicit tick positions: ax.set_xticks([0,1,2,3])
• Set custom labels: ax.set_xticklabels(['Mon','Tue','Wed'])
• Rotate labels to avoid overlap: plt.xticks(rotation=45)
• Change font size, color, and padding: plt.xticks(fontsize=12, color='red') or ax.tick_params(axis='x', labelsize=10, labelcolor='blue', pad=6)
• Add minor ticks: ax.xaxis.set_minor_locator(MultipleLocator(0.5))
• Use log-scale ticks: ax.set_xscale('log') with LogLocator()

Why control ticks?
Clear tick placement and readable labels make graphs easier to interpret: choose tick spacing that matches the data granularity, rotate long category labels, and use appropriate tick formatting for dates, currency, or percentages.

Quick API reference (useful functions)

• plt.xticks(positions, labels, rotation=?, fontsize=? ) — set x ticks and labels
• ax.set_xticks([...]) / ax.set_xticklabels([...])
• ax.tick_params(axis='x'/'y', which='major'/'minor', length=?, width=?, direction='in'/'out', labelsize=?, labelrotation=? )
• from matplotlib.ticker import MultipleLocator, MaxNLocator, LogLocator, FuncFormatter

Practical tips

• For time-series, use date locators/formatters (AutoDateLocator/AutoDateFormatter) to get sensible tick spacing and readable date formats.
• For categorical x-axis (bar charts), pass category names as labels and set ticks at integer positions.
• When labels overlap, rotate them (e.g., 45° or 90°) and adjust bottom margin (plt.tight_layout()) or fig.subplots_adjust(bottom=…).

Time series are sequences of data points recorded at successive times (equally or unequally spaced). Plotting time series and dates means mapping numerical values against time on the x-axis to show trends, seasonality, cycles and anomalies. In Python, matplotlib.pyplot together with pandas and matplotlib.dates provides convenient tools to parse, index and format date/time values for clear visualisation.

Key steps when plotting time series with pyplot:

• Parse dates into a datetime type (use pandas.to_datetime or Python's datetime).
• Set the datetime column as the index (pandas) or convert dates to matplotlib date numbers (matplotlib.dates.date2num).
• Choose an appropriate plot (line plot for continuous series, bar for aggregated periods, scatter for irregular sampling).
• Format the x-axis ticks and labels using locators and formatters (AutoDateLocator, DateFormatter) so labels are readable.
• Use resampling/aggregation for different frequencies (daily -> monthly) and smoothing (moving average) to highlight patterns.

Common pyplot and matplotlib.dates functions/patterns:

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates

# parse and index
df['date'] = pd.to_datetime(df['date'])
df = df.set_index('date')

# simple time series plot
fig, ax = plt.subplots()
df['value'].plot(ax=ax)

# format x-axis for dates
ax.xaxis.set_major_locator(mdates.AutoDateLocator())
ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

Practical tips:

• For long ranges use monthly or yearly tick locators (MonthLocator, YearLocator).
• When sampling is irregular, use scatter or plot_date instead of a continuous line, or interpolate if appropriate.
• Annotate important dates (events, peaks) with ax.annotate to explain spikes or drops.
• Aggregate using df.resample('M').mean()/sum() to convert to monthly values before plotting.
• Use rolling().mean(n) for smoothing short-term noise (moving average).

Overview
In Matplotlib (pyplot), images and heatmaps are visualizations of 2D arrays where array values are mapped to colors. Images usually represent pixel data (grayscale or RGB) while heatmaps visualize numeric matrices (e.g., correlation, temperature) using a colormap.

Images as arrays

• A grayscale image: a 2D array of shape (H, W). Each element is an intensity (commonly 0–255, dtype uint8).
• An RGB image: a 3D array of shape (H, W, 3) with channels (R,G,B). Optionally RGBA (H, W, 4) includes alpha.
• To display: plt.imshow(array). For grayscale use cmap='gray'. To read/write images: matplotlib.image.imread/imsave or use image libraries (PIL, imageio).

Heatmaps
A heatmap displays a 2D numeric matrix where each cell's color indicates its value. Common uses: correlation matrices, confusion matrices, spatial data (temperature, population density), and any 2D scalar field.

Important parameters and options

• cmap — colormap name (e.g., 'viridis', 'plasma', 'hot', 'cool', 'gray').
• vmin, vmax — explicit value range mapped to colormap. Useful to keep consistent color scales across plots.
• interpolation — e.g., 'nearest' (no smoothing) or 'bilinear'. For pixel-accurate display use 'nearest'.
• origin — 'upper' or 'lower' determines y-axis direction. By default images put row 0 at top; set origin='lower' to place row 0 at bottom.
• aspect — 'equal' to preserve square pixels, or 'auto' to fill axes.
• plt.colorbar() — shows the mapping from values to colors (very important for heatmaps).
• Normalization — values are typically normalized to 0–1 before colormap mapping. Matplotlib also supports LogNorm for log-scale coloring.

Typical workflow

1. Obtain a 2D array: image read or computed data matrix.
2. Decide range: choose vmin/vmax or let library auto-scale.
3. Choose cmap and display with plt.imshow(..., cmap='name', origin='lower', interpolation='nearest').
4. Add plt.colorbar(), axis labels, and optionally annotations.

Short code examples (pyplot + numpy):

import numpy as np
import matplotlib.pyplot as plt

# synthetic heatmap
x = np.linspace(-3, 3, 200)
y = np.linspace(-3, 3, 200)
X, Y = np.meshgrid(x, y)
Z = np.exp(- (X**2 + Y**2) / (2*0.8**2))  # 2D Gaussian

plt.imshow(Z, cmap='hot', origin='lower', interpolation='nearest')
plt.colorbar()
plt.title('2D Gaussian Heatmap')
plt.show()

# display an RGB image array (arr shape H,W,3)
# plt.imshow(arr)
# plt.axis('off')

Best practices

• Always include a colorbar for heatmaps so values can be interpreted.
• Choose perceptually-uniform colormaps (e.g., 'viridis') for accurate perception of magnitude changes. Avoid rainbow colormap for quantitative data.
• Set vmin/vmax consistently when comparing multiple heatmaps.
• Annotate critical values (e.g., use text on a confusion matrix) when exact numbers matter.

What it is and why it matters
Saving and exporting figures means writing the plot you created in matplotlib/pyplot to a file so it can be used in reports, presentations, websites or publications. Proper export preserves quality, size and layout and chooses an appropriate file type (raster or vector) for the intended use.

File types
• Raster (pixel-based): PNG, JPEG — good for screens; quality depends on resolution (dpi).
• Vector (resolution independent): SVG, PDF, EPS — ideal for printing and scalable graphics (no pixelation).

Key functions and parameters
The main function is plt.savefig or the Figure method fig.savefig. Important parameters:

• fname: filename (extension selects format) e.g. 'plot.png' or 'plot.pdf'
• dpi: dots per inch; higher for print (300), lower for screens (72–150)
• bbox_inches='tight': trims whitespace around the figure
• format: explicitly set format if filename has no extension
• transparent=True: saves background transparent (useful for overlays)
• facecolor/edgecolor: set figure background colors
• pad_inches: padding around figure when bbox_inches='tight'

Typical workflow
1. Create figure and axes (optionally set size with figsize).
2. Draw plot(s) and adjust layout (use plt.tight_layout()).
3. Save using plt.savefig or fig.savefig before or after plt.show() (prefer saving before closing figures in scripts).
4. Optionally close the figure with plt.close() to free memory when creating many figures.

# Example (Python)
import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(8,4))
ax.plot(x, y)
plt.tight_layout()  # adjust spacing
fig.savefig('temperature_plot.png', dpi=300, bbox_inches='tight')
plt.close(fig)

Practical tips
• Use vector formats (PDF, SVG) for charts that will be printed or edited in vector programs.
• Use PNG for screenshots, slides and web images when transparency or lossless quality is needed.
• Use JPEG only for photos — not for charts with sharp lines and text (JPEG compression causes artifacts).
• Increase figsize and dpi for clearer labels when exporting to high-resolution media.

Overview
Handling multiple datasets and overlays in Pyplot means plotting two or more data series on the same figure so they can be compared visually. Common tasks include overlaying multiple line plots, combining scatter and line plots, plotting grouped or stacked bars, and using twin axes when datasets have different units or scales.

Why and when to overlay
Overlaying is useful to compare trends, correlations, relative magnitudes, or distributions — for example, comparing monthly sales of two products, temperature trends of two cities, or CPU utilization vs. temperature over time.

Best practices

• Use different colors, markers, and line styles for each dataset.
• Add a legend (plt.legend()) and axis labels (plt.xlabel(), plt.ylabel()).
• Keep plots readable: limit the number of series, use alpha (transparency) for overlapping fills, and avoid too many markers.
• When units differ significantly, use secondary y-axis via ax.twinx().
• For categorical comparisons use grouped or stacked bar charts instead of many overlapping lines.

Common Pyplot techniques (short code examples)

Overlaying multiple line plots:

import matplotlib.pyplot as plt
x = [1,2,3,4,5]
y1 = [2,3,5,6,7]
y2 = [1,4,4,5,6]
plt.plot(x, y1, label='Series A', color='tab:blue', marker='o')
plt.plot(x, y2, label='Series B', color='tab:orange', linestyle='--', marker='s')
plt.xlabel('X')
plt.ylabel('Value')
plt.title('Two series overlay')
plt.legend()
plt.show()

Scatter + trend line overlay:

import numpy as np
x = np.linspace(0, 10, 30)
y = 2*x + np.random.randn(30)
plt.scatter(x, y, alpha=0.7)
coef = np.polyfit(x, y, 1)
trend = np.poly1d(coef)
plt.plot(x, trend(x), color='red', label='Trend')
plt.legend()
plt.show()

Grouped bar chart (two categories across groups):

import numpy as np
labels = ['A','B','C']
men = [20, 34, 30]
women = [25, 32, 34]
x = np.arange(len(labels))
width = 0.35
plt.bar(x - width/2, men, width, label='Men')
plt.bar(x + width/2, women, width, label='Women')
plt.xticks(x, labels)
plt.legend()
plt.show()

Stacked bar chart:

plt.bar(x, men, label='Men')
plt.bar(x, women, bottom=men, label='Women')
plt.legend()
plt.show()

Dual y-axis for different units:

fig, ax1 = plt.subplots()
ax2 = ax1.twinx()
ax1.plot(time, temp, 'r-', label='Temperature (°C)')
ax2.plot(time, power, 'b--', label='Power (W)')
ax1.set_ylabel('Temperature (°C)')
ax2.set_ylabel('Power (W)')
ax1.legend(loc='upper left')
ax2.legend(loc='upper right')
plt.show()

Plot styling tips
Use label, color, linestyle, marker, linewidth, alpha (transparency), zorder (stack order), and markersize to improve clarity. Always call plt.legend() to identify series.

Interactivity in pyplot lets users explore and control plots dynamically—change parameters, inspect points, zoom/pan, or update plots in real time. Matplotlib supports interactive mode, event handling and GUI widgets (sliders, buttons), and animations.

Key interactive features

• Interactive mode: enable with plt.ion() so figures update without blocking the program; use plt.show() to display. For non-blocking display in scripts use plt.show(block=False) and plt.pause().
• Event handling: connect callbacks to events via fig.canvas.mpl_connect(event_name, handler). Common events: button_press_event, motion_notify_event, key_press_event, pick_event (requires a picker).
• Widgets: interactive controls from matplotlib.widgets such as Slider, Button, CheckButtons, and RadioButtons let users change plot parameters directly.
• Animations: use matplotlib.animation.FuncAnimation to update frames for live or simulated time-series visuals.

Plot utilities are helper functions and settings that improve readability and usability:

• Labels, title, legend, grid: plt.xlabel, plt.ylabel, plt.title, plt.legend(), plt.grid(True).
• Annotations: ax.annotate(text, xy=(x,y), xytext=(x2,y2), arrowprops=dict(...)) to mark points with arrows or labels.
• Layout and appearance: figsize, dpi, plt.style.use(), plt.tight_layout(), plt.subplots_adjust().
• Saving: plt.savefig('file.png', dpi=300, bbox_inches='tight') to export high-quality images.
• Pick and hover: allow clicking or hovering points to display metadata (use picker or external helper libraries like mplcursors).

Typical workflow for interactive plots:

1. Create figure and axes (fig, ax = plt.subplots()).
2. Enable interactive mode if needed (plt.ion()).
3. Plot initial data and create widgets/handlers.
4. Connect events with mpl_connect and implement handlers that update plot elements (e.g., line.set_ydata()) and redraw (fig.canvas.draw_idle()).

Educational note: interactivity helps students test 'what-if' scenarios (change a parameter and immediately see the result), inspect noisy data by zooming, or create small GUIs for demonstrations.

Good practices when plotting ensure clarity, honesty, and accessibility. A good plot communicates the message without misleading the reader. Key habits include choosing the right plot type for the data, labelling axes (including units), giving a descriptive title, adding a legend when multiple series exist, using readable fonts and sensible colours, providing gridlines or tick marks for reference, and annotating important points. Control figure size and resolution for the intended medium, save in an appropriate format, and prefer simple 2D representations unless 3D is necessary.

• Clarity: clear title, x/y labels with units, legend, readable tick labels.
• Accuracy and integrity: use appropriate axis ranges (avoid axis truncation that exaggerates differences), report sample size, include error bars or confidence intervals where relevant.
• Appropriate plot type: time series → line plot; relationship between two continuous variables → scatter plot + trendline; distribution → histogram/boxplot; categorical comparisons → bar chart.
• Accessibility: choose colourblind-friendly palettes, use markers/line styles in addition to color, add alt text and captions.
• Annotate & contextualize: highlight maxima/minima/outliers, mark thresholds, show regression equation and R² when presenting fits.
• Reproducibility: keep code/parameters (bins, smoothing window, axis limits) documented; save raw data and scripts.

Plot interpretation means extracting accurate, actionable information from visuals. Start by reading labels and units, then observe the overall pattern: increasing/decreasing, periodicity, plateaus, jumps. Look for shape (linear, exponential, cyclical), slope (rate of change), spread/variance, clusters, and outliers. For relationships, check strength and direction (positive/negative correlation) and whether the relationship looks linear or nonlinear. Use supporting summary statistics and fits (mean, median, SD, regression line, R²) to quantify observations. Be cautious: correlation is not causation; investigate confounders, data quality, and sample size before drawing conclusions.

• Identify trends (long-term increase/decrease), seasonality (regular cycles), and noise (random fluctuations).
• Detect outliers and ask whether they are measurement errors, rare events, or important signals.
• Compare groups with consistent scales; do not mislead by varying bar widths or inconsistent baselines.
• When fitting models, inspect residuals to validate assumptions (homoscedasticity, normality for many tests).

Following these practices and interpretation steps leads to plots that are informative, reproducible, and trustworthy.