PCA in Python with scikit-learn: Complete Step-by-Step Tutorial (2026)

You’ve read the theory. You know PCA finds directions of maximum variance. But when you sit down to write the code, you hit a wall: which function do I call first? Do I scale the data before or after? What does explained_variance_ratio_ actually mean?

This tutorial answers all of that. In 2026, scikit-learn reached 208 million PyPI downloads per month (pypistats.org, June 2026) — making it the most-downloaded ML library on the planet. sklearn.decomposition.PCA is one of its most-reached-for tools. Here’s the exact workflow, start to finish, with every output shown so you can follow along.

If you want the mathematical intuition behind PCA before running the code, start with our PCA solved example with step-by-step calculations. This post is the code companion to that one — same algorithm, but now in Python.

Prerequisites

As of June 2026, scikit-learn pulls in roughly 208 million downloads per month, which means pip install works on virtually every Python setup without conflicts. You need:

• Python 3.9 or later
• scikit-learn 1.3+ — pip install scikit-learn
• NumPy, pandas, matplotlib — pip install numpy pandas matplotlib
• Basic Python familiarity; no prior sklearn experience needed
• Approximately 20 minutes to complete

Tested on Python 3.12, scikit-learn 1.5, macOS 14 / Windows 11 / Ubuntu 22.04.

What We’re Building

We’ll use the classic Iris dataset — 150 samples, 4 numeric features, 3 species. By the end you’ll have reduced it from 4 dimensions to 2 while keeping 95.8% of the variance, plotted a colour-coded scatter of the result, and wired the whole thing into a Pipeline that scores 96.67% accuracy with a logistic regression classifier.

Step 1: Load and Prepare the Dataset

In this step you load the Iris dataset and inspect its shape so you know exactly what PCA is being asked to compress. The dataset ships inside scikit-learn, so no download is needed.

# pca_tutorial.py

from sklearn.datasets import load_iris
import pandas as pd

iris = load_iris()
X = iris.data          # shape: (150, 4)
y = iris.target        # 0=setosa, 1=versicolor, 2=virginica

df = pd.DataFrame(X, columns=iris.feature_names)
df['species'] = y
print(df.head())
print(f"nDataset shape: {X.shape}")

Expected output:

   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)  species
0                5.1               3.5                1.4               0.2        0
1                4.9               3.0                1.4               0.2        0
2                4.7               3.2                1.3               0.2        0
3                4.6               3.1      2         1.5               0.2        0
4                5.0               3.6                1.4               0.2        0

Dataset shape: (150, 4)

Four features, 150 rows. PCA will compress those 4 features into 2 principal components that still explain the vast majority of the variance. If you’re working with your own data, swap load_iris() for pd.read_csv() and pass the numeric columns as X.

Step 2: Standardize Features with StandardScaler

Standardizing is the step most beginners skip — and it’s the step that breaks everything if skipped. PCA works by computing the covariance of your features. If one feature is in centimetres and another in kilometres, the kilometre feature will dominate the first principal component simply because its numeric values are larger, not because it carries more information. StandardScaler removes that bias by shifting every feature to mean 0 and standard deviation 1.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

print("Original mean:", X.mean(axis=0).round(2))
print("Scaled mean: ", X_scaled.mean(axis=0).round(2))
print("Scaled std:  ", X_scaled.std(axis=0).round(2))

Expected output:

Original mean: [5.84 3.06 3.76 1.2 ]
Scaled mean:  [-0.  0. -0.  0.]
Scaled std:   [1.  1.  1.  1.]

Step 3: Apply PCA with scikit-learn

With the data scaled, applying PCA is straightforward. You pass n_components to tell PCA how many dimensions to reduce to. A 2025 PMC comprehensive review of dimensionality reduction algorithms found that practitioners typically choose the number of components that retain 90–95% of total variance (PMC12453773, July 2025), though the review notes this heuristic “frequently fails in sparse or noisy datasets” — something to keep in mind for real-world work beyond Iris.

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

print(f"Original shape: {X_scaled.shape}")
print(f"Reduced shape:  {X_pca.shape}")

Expected output:

Original shape: (150, 4)
Reduced shape:  (150, 2)

150 samples, 4 features → 150 samples, 2 features. PCA has done its job. The two new columns are principal components — linear combinations of the original features that maximise variance. They don’t have the same units or names as the originals; that’s expected. For a worked numerical example of what PCA is computing under the hood, see our PCA solved example with step-by-step calculations.

Step 4: Read the Explained Variance

The explained_variance_ratio_ attribute tells you what fraction of the dataset’s total information each principal component captures. In December 2025, an arXiv hyperspectral imaging study compressed 150 spectral bands into just 2 principal components while retaining over 99% of total variance, with a Random Forest on the PCA-reduced data achieving R² of 94.7% (arXiv 2512.15544, December 2025). On Iris you’ll see similar efficiency.

print("Explained variance ratio per component:")
for i, ratio in enumerate(pca.explained_variance_ratio_, 1):
    print(f"  PC{i}: {ratio:.4f}  ({ratio * 100:.2f}%)")

cumulative = pca.explained_variance_ratio_.cumsum()
print(f"nCumulative variance (2 components): {cumulative[-1] * 100:.2f}%")

Expected output:

Explained variance ratio per component:
  PC1: 0.7277  (72.77%)
  PC2: 0.2303  (23.03%)

Cumulative variance (2 components): 95.80%

PC1 alone captures 72.77% of the variance. PC2 adds another 23.03%. Together they hold 95.80% — comfortably above the 90–95% practical threshold. The chart below shows all four components including the tiny remainder:

Notice how steeply the bars drop. This “elbow” shape is typical and confirms that 2 components are sufficient for Iris. If you were running PCA to choose n for a full ML pipeline, you’d look for where adding another component gives diminishing returns — usually where the cumulative curve passes 90–95%.

Want to check variance for all possible component counts at once? Run:

import numpy as np

pca_full = PCA()
pca_full.fit(X_scaled)

cumulative = np.cumsum(pca_full.explained_variance_ratio_)
for n, v in enumerate(cumulative, 1):
    print(f"  {n} components: {v * 100:.2f}% variance")

  1 components: 72.77% variance
  2 components: 95.80% variance
  3 components: 99.48% variance
  4 components: 100.00% variance

Step 5: Visualize PCA in 2D

The real payoff of reducing to 2 components is that you can plot the data. Here’s how to build a colour-coded scatter plot that makes the cluster structure instantly visible:

import matplotlib.pyplot as plt

species_names = iris.target_names
colors = ['#e74c3c', '#2ecc71', '#3498db']

fig, ax = plt.subplots(figsize=(8, 6))
for i, (name, color) in enumerate(zip(species_names, colors)):
    mask = y == i
    ax.scatter(X_pca[mask, 0], X_pca[mask, 1],
               c=color, label=name, alpha=0.75, s=60, edgecolors='white', linewidths=0.5)

ax.set_xlabel('Principal Component 1 (72.77%)', fontsize=12)
ax.set_ylabel('Principal Component 2 (23.03%)', fontsize=12)
ax.set_title('PCA of Iris Dataset — 2 Components', fontsize=14)
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

When you run the plot you’ll see three clear clusters: setosa (red) is completely separated along PC1, while versicolor (green) and virginica (blue) overlap slightly. That overlap reflects genuinely similar petal measurements in those two species — PCA didn’t lose information, it revealed it.

Here’s a video walkthrough of PCA implementation in scikit-learn that complements this step:

Step 6: Build a PCA Pipeline That Prevents Data Leakage

Running PCA manually — as we’ve done above — works for exploration. But the moment you run cross-validation, a hidden bug can appear: if you fit the scaler and PCA on the full training set before splitting folds, test-set information leaks into your model. scikit-learn’s Pipeline eliminates this. In December 2024, an arXiv study on time series models found that PCA preprocessing improved Informer training speed by up to 40% and reduced TimesNet GPU memory by 30%, with no accuracy loss (arXiv 2412.19423, December 2024). A proper Pipeline makes it easy to reproduce those gains safely.

from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import accuracy_score

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

pipe = Pipeline([
    ('scaler', StandardScaler()),     # Step 1: scale
    ('pca',    PCA(n_components=2)),  # Step 2: reduce
    ('clf',    LogisticRegression(max_iter=1000))  # Step 3: classify
])

pipe.fit(X_train, y_train)
y_pred = pipe.predict(X_test)

print(f"Test accuracy:         {accuracy_score(y_test, y_pred):.2%}")

cv_scores = cross_val_score(pipe, X, y, cv=5)
print(f"5-fold CV accuracy:    {cv_scores.mean():.2%} (+/- {cv_scores.std():.2%})")

Expected output:

Test accuracy:         96.67%
5-fold CV accuracy:    96.00% (+/- 2.45%)

The Pipeline applies the scaler and PCA inside each cross-validation fold — the scaler is fit only on the fold’s training portion. No leakage. You can swap in any classifier at the end; PCA doesn’t care. After building your model, you’ll want to evaluate it properly — see our guide on reading a confusion matrix for multiclass classifiers for the next step.

PCA vs t-SNE vs UMAP: Which Should You Use?

PCA isn’t the only dimensionality reduction algorithm in Python. t-SNE and UMAP are popular alternatives, especially for visualisation. The key difference is speed and interpretability: at 100,000 samples, PCA finishes in under one second; t-SNE can take several minutes. That makes PCA the only practical choice for preprocessing large datasets before training, while t-SNE and UMAP are better suited to exploratory cluster visualisation on smaller samples.

Feature	PCA (sklearn)	UMAP	t-SNE
Type	Linear	Non-linear	Non-linear
Speed (100K samples)	< 1 second	Tens of seconds	Minutes to hours
Preserves	Global variance structure	Local + global structure	Local cluster structure
Interpretable axes	Yes (variance %)	No	No
Works in ML pipelines	Yes (sklearn Pipeline)	Yes (umap-learn)	No (not invertible)
Best for	Preprocessing, speed, noise removal	Visualisation, cluster exploration	Visualisation of small datasets

If you’re preprocessing data before a classifier — use PCA. If you’re exploring a dataset visually to understand cluster structure — use UMAP. If you have fewer than 10K samples and want the sharpest possible cluster visualisation — use t-SNE. For understanding relationships between the original features before deciding whether to run PCA at all, start with our guide to Pandas corr() for correlation analysis.

Troubleshooting Common PCA Errors

Here are the five errors that catch most beginners — and the exact fixes.

Problem	Symptom	Fix
Forgot to scale	PC1 captures nearly 100% of variance; features with large units dominate	Add StandardScaler().fit_transform(X) before PCA().fit_transform()
n_components too large	ValueError: n_components must be between 1 and min(n_samples, n_features)	Set n_components to a value ≤ min(rows, columns); for Iris: ≤ 4
Fitting scaler on test set	Suspiciously high accuracy that drops in production	Call .fit_transform(X_train) and .transform(X_test), or use a Pipeline
PCA on categorical data	PCA produces nonsense components or silent wrong results	One-hot encode categoricals first; PCA is only valid on numeric features
Components don’t match between runs	Signs of components flip between runs (PC1 looks positive/negative)	Normal — PCA eigenvectors are sign-ambiguous. Multiply by -1 to flip if needed; it doesn’t change the geometry

Frequently Asked Questions

How many PCA components should I choose?

Choose the number of components that captures 90–95% of total variance, per the 2025 PMC comprehensive review of dimensionality reduction (PMC12453773). Run PCA().fit(X_scaled) first, then check np.cumsum(pca.explained_variance_ratio_) to find the threshold. The review cautions this heuristic can fail on sparse or noisy data — validate with a downstream metric like cross-val accuracy.

Do I have to standardize data before PCA?

Yes — always. PCA measures variance, and variance is scale-dependent. A feature measured in kilometres has numerically larger values than one measured in metres, so it will dominate the first component even if it carries less real information. StandardScaler (mean 0, std 1) removes that bias. Skip it and your components are wrong.

What is the difference between PCA and t-SNE in Python?

PCA is linear, completes in under a second on 100K samples, and is safe to use inside ML pipelines. t-SNE is nonlinear, can take minutes on the same data, and is only useful for 2D/3D visualisation — you can’t use t-SNE output as features in a classifier. Use PCA for preprocessing and dimensionality reduction; use t-SNE or UMAP for exploratory scatter plots.

How do I use PCA in a scikit-learn Pipeline?

Wrap it in Pipeline([('scaler', StandardScaler()), ('pca', PCA(n_components=2)), ('clf', LogisticRegression())]). The Pipeline ensures the scaler and PCA only see each fold’s training portion during cross-validation, preventing data leakage. A 2024 arXiv study found PCA preprocessing inside training pipelines improved model training speed by up to 40% (arXiv 2412.19423).

Can PCA be used for feature selection?

Not exactly. PCA is feature extraction, not feature selection — it creates new composite features (principal components) rather than picking which original features to keep. If you need to retain and interpret original features, use SelectKBest, SelectFromModel, or Lasso regularization instead. Use PCA when reducing dimensionality matters more than preserving original feature names. See our guide to numpy.linalg.norm for working with the linear algebra underlying these operations.

Complete Source Code

Here’s the full PCA implementation from start to finish in one copy-pasteable block:

# pca_complete.py — Full PCA workflow with scikit-learn

from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
import numpy as np

# 1. Load data
iris = load_iris()
X, y = iris.data, iris.target

# 2. Standardize
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 3. Fit PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

# 4. Explained variance
print("Explained variance ratio:")
for i, ratio in enumerate(pca.explained_variance_ratio_, 1):
    print(f"  PC{i}: {ratio * 100:.2f}%")
print(f"Total: {pca.explained_variance_ratio_.sum() * 100:.2f}%")

# 5. Scree plot (all components)
pca_full = PCA().fit(X_scaled)
plt.figure(figsize=(6, 4))
plt.bar(range(1, 5), pca_full.explained_variance_ratio_ * 100, color='#2563eb')
plt.xlabel('Principal Component')
plt.ylabel('Variance Explained (%)')
plt.title('Scree Plot — Iris PCA')
plt.tight_layout()
plt.show()

# 6. Scatter plot
colors = ['#e74c3c', '#2ecc71', '#3498db']
plt.figure(figsize=(8, 6))
for i, (name, c) in enumerate(zip(iris.target_names, colors)):
    mask = y == i
    plt.scatter(X_pca[mask, 0], X_pca[mask, 1], c=c, label=name, alpha=0.75, s=60)
plt.xlabel('PC1 (72.77%)')
plt.ylabel('PC2 (23.03%)')
plt.title('PCA of Iris Dataset')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# 7. Pipeline with cross-validation
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA(n_components=2)),
    ('clf', LogisticRegression(max_iter=1000))
])
pipe.fit(X_train, y_train)
print(f"nTest accuracy: {accuracy_score(y_test, pipe.predict(X_test)):.2%}")
cv = cross_val_score(pipe, X, y, cv=5)
print(f"5-fold CV:     {cv.mean():.2%} (+/- {cv.std():.2%})")

Next Steps

Now that you have a working PCA pipeline, here’s how to go further:

• Understand the math: See our PCA solved example with step-by-step calculations to see what the eigenvector decomposition is doing under the hood
• Evaluate your model: Learn to interpret classification results with our 3×3 confusion matrix guide
• Explore correlations first: Before running PCA, check feature relationships with pandas corr() — highly correlated features are where PCA gives the biggest compression gains
• Try Kernel PCA: For non-linear data, sklearn.decomposition.KernelPCA uses the same API but applies a kernel transformation first
• Scale up: For datasets that don’t fit in memory, swap to sklearn.decomposition.IncrementalPCA — it processes data in mini-batches

Conclusion

PCA in scikit-learn comes down to three essential steps: scale with StandardScaler, reduce with PCA(n_components=N), and check explained_variance_ratio_ to confirm you kept enough information. Wrap all three in a Pipeline and you get cross-validation safety for free. The Iris example in this tutorial shows 95.8% variance retention with just 2 components and 96.67% classifier accuracy — numbers that hold up in real-world use when the data is reasonably structured.

If something in the code didn’t work as expected, the troubleshooting table above covers the five most common mistakes. Drop a comment below if you hit something else and I’ll update the guide.