Distance Metrics — Euclidean, Manhattan, Minkowski & Hamming

The Story That Explains Distance Metrics

Euclidean Distance — The Straight Line

Let us work through a complete example. Point A = (1, 2) and Point B = (4, 6).

Properties of Euclidean Distance

Manhattan Distance — The City Grid

Manhattan vs Euclidean — Key Differences

Minkowski Distance — The Unifying Formula

Minkowski distance is not a new metric — it is a parameterised family of metrics that includes both Euclidean and Manhattan as special cases. By tuning a single parameter p, you slide between different geometries of distance.

The Unit Ball — Visualising What Each p "Looks Like"

Hamming Distance — Comparing Sequences

Side-by-Side — All Four Metrics on the Same Data

Let us apply all four distance metrics to the same two numeric points A = (1, 2, 3) and B = (4, 6, 3) — a 3-dimensional example.

Python Implementation

All Four Distances — From Scratch

import numpy as np
from collections import Counter

# ── Euclidean Distance ────────────────────────────────────────
def euclidean(a, b):
    """L2 norm — straight-line distance between two vectors."""
    a, b = np.array(a, dtype=float), np.array(b, dtype=float)
    return np.sqrt(np.sum((a - b) ** 2))

# ── Manhattan Distance ────────────────────────────────────────
def manhattan(a, b):
    """L1 norm — sum of absolute differences (taxicab distance)."""
    a, b = np.array(a, dtype=float), np.array(b, dtype=float)
    return np.sum(np.abs(a - b))

# ── Minkowski Distance ────────────────────────────────────────
def minkowski(a, b, p=2):
    """Lp norm — generalised distance. p=1→Manhattan, p=2→Euclidean."""
    a, b = np.array(a, dtype=float), np.array(b, dtype=float)
    if p == float('inf'):
        return np.max(np.abs(a - b))
    return np.sum(np.abs(a - b) ** p) ** (1 / p)

# ── Hamming Distance ──────────────────────────────────────────
def hamming(a, b, normalise=False):
    """Count of differing positions between two equal-length sequences."""
    if len(a) != len(b):
        raise ValueError("Sequences must be the same length")
    count = sum(x != y for x, y in zip(a, b))
    return count / len(a) if normalise else count

A = [1, 2, 3]
B = [4, 6, 3]

print(f"Euclidean    : {euclidean(A, B):.4f}")
print(f"Manhattan    : {manhattan(A, B):.4f}")
print(f"Minkowski p=1: {minkowski(A, B, p=1):.4f}")
print(f"Minkowski p=2: {minkowski(A, B, p=2):.4f}")
print(f"Minkowski p=3: {minkowski(A, B, p=3):.4f}")
print(f"Chebyshev p=∞: {minkowski(A, B, p=float('inf')):.4f}")

s1, s2 = "KAROLIN", "KATHRIN"
print(f"\nHamming (raw):        {hamming(s1, s2)}")
print(f"Hamming (normalised): {hamming(s1, s2, normalise=True):.4f}")

Using scipy — Production-Grade Implementations

from scipy.spatial.distance import (
    euclidean, cityblock, minkowski, hamming,
    chebyshev, pdist, cdist, squareform
)
import numpy as np

A = np.array([1, 2, 3], dtype=float)
B = np.array([4, 6, 3], dtype=float)

print(f"Euclidean  : {euclidean(A, B):.4f}")
print(f"Manhattan  : {cityblock(A, B):.4f}")
print(f"Minkowski 3: {minkowski(A, B, p=3):.4f}")
print(f"Chebyshev  : {chebyshev(A, B):.4f}")

b1 = np.array([1, 0, 1, 1, 1, 0, 1])
b2 = np.array([1, 0, 0, 1, 0, 0, 1])
print(f"Hamming    : {hamming(b1, b2):.4f}")
print(f"Hamming raw: {hamming(b1, b2) * len(b1):.0f} positions differ")

Distance Matrix — All Pairs at Once

import numpy as np
from scipy.spatial.distance import pdist, squareform
import pandas as pd

X = np.array([
    [25, 80,  22.0],
    [35, 150, 28.5],
    [45, 180, 33.0],
    [28, 90,  23.5],
    [50, 200, 35.5],
])

for metric in ['euclidean', 'cityblock', 'chebyshev']:
    dist_matrix = squareform(pdist(X, metric=metric))
    df = pd.DataFrame(
        dist_matrix.round(1),
        index=[f"P{i+1}" for i in range(5)],
        columns=[f"P{i+1}" for i in range(5)]
    )
    print(f"\n{metric.upper()} distance matrix:")
    print(df.to_string())

Comparing Metrics in KNN — Effect on Classification

from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

iris = load_iris()
X, y = iris.data, iris.target

metrics = {
    'Euclidean':    dict(metric='euclidean'),
    'Manhattan':    dict(metric='manhattan'),
    'Minkowski p3': dict(metric='minkowski', metric_params={'p': 3}),
    'Chebyshev':    dict(metric='chebyshev'),
}

print(f"{'Metric':15s} {'CV Accuracy':>12} {'Std Dev':>10}")
print("-" * 40)

for name, kwargs in metrics.items():
    pipe = Pipeline([
        ('scaler', StandardScaler()),
        ('knn',    KNeighborsClassifier(n_neighbors=5, **kwargs))
    ])
    scores = cross_val_score(pipe, X, y, cv=5, scoring='accuracy')
    print(f"{name:15s}  {scores.mean():.4f}       ±{scores.std():.4f}")

Choosing the Right Distance Metric

Complete Reference Table — All Metrics

Real-World Applications

Golden Rules