Data Classification

In the previous sections, we learned how to generate new spatial datasets, engineer new columns, and combine geometries. You now have a GeoDataFrame packed with precise, raw numbers.

However, if you try to plot these raw numbers directly, the resulting map can be confusing. This section marks the transition from spatial analysis to spatial communication. You will learn why we must normalize our data and how to use Python rules and statistical algorithms to categorize (classify) your data into readable groups.

1. Why Classify Data?¶

When visualizing data within geographic boundaries (like cantons or municipalities), we create what is called a Choropleth Map or a thematic map.

Before we assign colors to our polygons, we must overcome two fundamental problems: The Area Bias and The Continuous Brain Limit.

The Area Bias (Why we need Ratios)¶

When creating a choropleth map (where entire polygons are filled with color), you must be very careful about mapping raw counts, such as the total population or the total number of crimes.

Raw counts are spatially extensive variables, meaning their values are directly correlated with the physical size of the observational unit. Everything else being equal, a larger municipality will naturally have more houses, more people, and more total crimes simply because it has more space. If you map total population, the largest polygons will almost always appear the darkest, misleading the viewer into thinking they are the most crowded or dangerous areas.

To fix this area bias, we must convert our counts into spatially intensive variables by creating a ratio or density. By dividing the raw count by a measure of size (like total area or total population at risk), we reveal the intrinsic variation of the data, regardless of how large or small the municipal borders happen to be.

Let us load the Swiss municipalities and prove this visually by comparing the extensive total population to the intensive population density.

Click through the tabs below to see how plotting a spatially extensive variable creates a visual illusion, and how a spatially intensive ratio fixes it.

1. Raw Population

2. Raw Area

3. Population Density

Concept Check: The CO2 Map¶

Scenario: You have been asked to create a map showing the carbon footprint of European countries. You have two columns of data: total_co2_emissions (Total tons of CO2) and co2_per_capita (Tons of CO2 per person).

If your goal is to show which country’s citizens have the least sustainable lifestyle, which column should you map, and why?

A) total_co2_emissions, because it is a spatially intensive variable.
B) total_co2_emissions, because it is a spatially extensive variable.
C) co2_per_capita, because it is a spatially intensive variable.

The Continuous Brain Limit (Why we need Bins)¶

Even after fixing the area bias, we have another problem. Our pop_density column contains thousands of unique, continuous decimal values. If we pass this continuous data to a map, the computer will generate thousands of slightly different shades of red.

The human eye cannot distinguish between 100 different shades of red. To make the map more readable, we can simplify our thousands of unique values into a small set of five logical categories (e.g., “Very Low”, “Low”, “Medium”, “High”, “Very High”).

2. Rule-based Classification¶

The most straightforward way to classify data is to write your own custom logic. This is highly effective when you have specific, scientifically meaningful thresholds (e.g., an environmental safety limit, or legal zoning density rules).

We can write a simple Python function to evaluate each row and assign a text label based on the population density. We then use the Pandas .apply() method to run this function across the entire dataset.

Once the data is classified into text labels (categories), there is a common trap beginners fall into: if you just plot the text strings, Python will automatically sort your legend alphabetically (High, Low, Medium, Very High, Very Low), which completely breaks the visual logic of a color ramp!

To fix this, we can quickly convert the new column into a Pandas Categorical data type to enforce a strict, logical order before plotting.

3. Classification Schemes¶

Writing custom rules is great, but what if you do not know the data well enough to guess the best threshold values?

Spatial data science relies on statistical grouping algorithms to automatically slice data into logical bins. In Python, GeoPandas integrates directly with a library called mapclassify to handle this seamlessly behind the scenes.

Here are the four most common statistical classification schemes:

1. Equal Intervals (equal_interval): Divides the data range into equal-sized sub-ranges (e.g., 0-25, 25-50, 50-75). Warning: Highly sensitive to extreme outliers; most of your data might end up stuffed into a single bin.

2. Quantiles (quantiles): Divides the data so that every class contains the exact same number of polygons (e.g., the top 20% of municipalities, the next 20%, etc.). Excellent for showing relative rankings, but visually distorts the true numerical gaps between values.

3. Natural Breaks / Fisher-Jenks (natural_breaks): A smart algorithm that looks for “valleys” in the data distribution histogram. It minimizes variance within classes and maximizes variance between classes. This is often the best default choice for geographic data.

4. Pretty Breaks (prettybreaks): Attempts to round the class break values to numbers that look “nice” to humans (like 10, 20, 30 instead of 11.4, 19.8, 32.1).

You do not even need to write the complex mathematical code for these. GeoPandas allows you to pass the scheme directly into the .plot() command, along with k to define the number of bins!

Let us compare how these four different algorithms slice the exact same pop_density data into 5 classes. Click through the tabs below and pay close attention to the numbers in the legends!

Equal Intervals

Quantiles

Natural Breaks

Pretty Breaks

Visualizing the Class Breaks¶

To truly understand what the computer just did, examination of the data distribution is highly beneficial to see exactly where the mathematical rules chopped the numbers.

In the tabs below, we’ve plotted a simplified histogram of our population density values, with vertical dashed lines indicating the new class break points.

Equal Interval Breaks

Quantile Breaks

Natural Breaks

User Defined (Pretty) Breaks

Concept Check: The Top 20%¶

Scenario: A real estate company asks you to create a map of municipal housing prices. They want the legend to specifically highlight the “Top 20% most expensive municipalities” in dark red, the next 20% in medium red, and so on.

Which classification scheme must you use to guarantee that exactly 20% of the map’s polygons fall into each category?

A) Natural Breaks (natural_breaks)
B) Quantiles (quantiles)
C) Equal Intervals (equal_interval)

4. Exercise: Water Accessibility¶

It is time to practice engineering a ratio and classifying it statistically. We want to understand water accessibility across Switzerland by calculating how many people share each hectare of lake area in a given municipality. (Think of this as a rough proxy for how crowded the local beaches might be!)

However, geography is messy. Some municipalities have lakes but zero residents. Many municipalities have thousands of residents but zero lakes! You will need to handle these missing data points cleanly before classifying the results.

Tasks:

1. Load Data: If you have not already, load swissBoundaries3D_municipalities.gpkg and ensure it is in the metric EPSG:2056 projection.

2. Handle the Zeros: If a municipality has 0 lake area (see_flaeche == 0), dividing by it will cause a mathematical error (Infinity). Replace all 0 values in the see_flaeche column with np.nan (Not a Number) to safely ignore them.

3. Calculate the Ratio: Create a new column called water_ratio by dividing the population (einwohnerzahl) by the newly cleaned lake area (see_flaeche).

4. Plot and Classify: Plot the water_ratio column. Use the quantiles scheme with k=5 classes. Use the missing_kwds argument to color all the municipalities that had no lakes in lightgrey.

Sample solution

import geopandas as gpd
import numpy as np
import matplotlib.pyplot as plt

# 1. Ensure data is loaded and projected
muni_gdf = gpd.read_file("swissBoundaries3D_municipalities.gpkg").to_crs(epsg=2056)

# 2. Handle the Zeros to prevent division by zero errors
# We replace 0 with np.nan so Pandas knows it is "missing" data
muni_gdf["see_flaeche"] = muni_gdf["see_flaeche"].replace(0, np.nan)

# 3. Calculate the Ratio (Population per hectare of lake)
muni_gdf["water_ratio"] = muni_gdf["einwohnerzahl"] / muni_gdf["see_flaeche"]

# 4. Plot, Classify, and style the missing data
ax = muni_gdf.plot(
    figsize=(12, 8),
    column="water_ratio", 
    scheme="quantiles", 
    k=5, 
    cmap="Blues", 
    legend=True,
    legend_kwds={"loc": "upper left", "title": "Pop per Hectare of Lake"},
    missing_kwds={"color": "lightgrey", "label": "No Lake Area"},
    edgecolor="white",
    linewidth=0.1
)

ax.set_title("Water Accessibility: Municipalities with Lakes")
ax.axis("off")
plt.show()

5. Summary: Prepping for Visualization¶

In this section, you bridged the critical gap between raw spatial analysis and human readability. By transforming your numbers into organized classes, you have prepared your data for the final stage of geographic information systems: map making.

Key takeaways¶

• Always Normalize: Never map raw counts (like total population) on polygon maps, as it introduces severe area bias. Always convert counts into a ratio or density first.

• The Necessity of Bins: Human eyes cannot interpret continuous color ramps accurately. Grouping data into distinct classes makes patterns immediately readable.

• Rule-Based: Use custom Python logic (like if/elif statements combined with .apply()) when you have specific, meaningful thresholds you want to highlight.

• Statistical Schemes: Use mapclassify built directly into GeoPandas plotting (e.g., scheme="natural_breaks") to let algorithms find the best way to slice your data. Choose Quantiles for even color distribution, and Natural Breaks for mathematically accurate clustering.

What comes next?¶

You now know how to manage CRSs, manipulate geometries, join distinct layers together, and classify the resulting data into logical bins.

You have all the ingredients required to build professional maps. In the next lesson on Data Visualization, we will formally introduce the visualization libraries that will allow you to add titles, basemaps, scale bars, and interactive legends to turn your Python code into presentation-ready cartography!

But first, it is time to put the new concepts of this lesson to the test in the practical session.