How to Plot a World Map Using Python and GeoPandas

Lately I’ve been exploring EM-DAT, an international database of approximately 26,000 major natural disasters from the year 1900 to present day.

During my exploration, I’ve wanted a way to:

1. Use Python and Pandas to process the EM-DAT dataset
2. Analyze natural disasters on a per-country basis
3. Plot a map of the world
4. Overlay a heatmap of the number of natural disasters for each country, thereby giving a visual representation of where in the world natural disasters occur

I’ve already covered a basic exploration of the EM-DAT dataset in the following articles:

1. Getting Started with the International Disaster Database (EM-DAT) using Python and Pandas
2. Exploring Natural Disaster Types in the EM-DAT Dataset with Python and Pandas
3. Decoding the EM-DAT Natural Disaster Dataset Hierarchy

The next step is to move on to plotting a map of the world with Python.

My explorations led me to a fantastic article by Jonathan Cutrer where he demonstrated how to use GeoPandas library to create a map of the United States.

I’ve taken his implementation and modified it to plot a map of the world.

This article covers plotting a basic world map with Python and GeoPandas.

I’ll then extend this implementation in future experiments.

Download the code

• All code published on NaturalDisasters.ai can be found in the official GitHub repo.
• The code for this specific article can be found here.

Plotting a map of the world with Python and GeoPandas

The easiest way to plot a map of the world with Python is to use GeoPandas:

# import the necessary packages
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt
import seaborn as sns
import geopandas as gpd

# load the low resolution world map
world = gpd.read_file(gpd.datasets.get_path("naturalearth_lowres"))

GeoPandas ships with a built-in dataset named naturalearth_lowres (meaning “Natural Earth - Low Resolution”, which is effectively just a Pandas dataframe:

The world dataframe has six columns:

1. pop_est: Estimated population of the country
2. continent: Name of the continent the country belongs to
3. name: Human-readable name of the country
4. iso_a3: Standardized ISO 3166-1 alpha-3 code used as an abbreviated way to represent the country (e.g,. “United States of America” is “USA”, “Tanzania” is “TZA”, etc.)
5. gdp_md_est: Gross Domestic Product (GDP) in millions of dollars
6. geometry: A polygon of points/coordinates used to represent the country on a map

The geometry column is the data we are specifically interested in here, as it will allow us to plot each of the countries with Python.

Speaking of which, the following code creates a basic world map with Python:

# initialize an empty figure and add an axis
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot()

# plot a basic map of the world
world.plot(
    ax=ax,
    color="lightgray",
    edgecolor="black",
    alpha=0.5
)

# turn off axis ticks
ax.set_xticks([])
ax.set_yticks([])

# set the plot title
plt.title("Basic Map of World with GeoPandas")
plt.show()

Which results in the following image:

I personally like to turn off the plot ticks as it makes the resulting figure a bit less “busy” and easier to read.

Plotting a map of a continent with GeoPandas

Admittedly, it’s been a long time since my elementary school geography class, so I couldn’t remember all the names of the continents (I know, quite embarrassing).

I was also curious which continents had the most countries – I found out by using the value_counts() method on the continent column of the dataframe:

# display the continents, along with the number of countries per continent
world["continent"].value_counts()

Which gives the following output:

continent
Africa                     51
Asia                       47
Europe                     39
North America              18
South America              13
Oceania                     7
Seven seas (open ocean)     1
Antarctica                  1
Name: count, dtype: int64

Turns out that Africa has the most countries, followed closely by Asia.

To plot a single continent with GeoPandas, all you need to do is filter the world dataframe on the continent of Africa:

# initialize a new figure
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot()

# grab all African countries
africa = world[world["continent"] == "Africa"]

# plot a basic map of Asia
africa.plot(
    ax=ax,
    cmap="Pastel1",
    edgecolor="black",
    alpha=0.5
)

# turn off axis ticks
ax.set_xticks([])
ax.set_yticks([])

# set the plot title
plt.title("Map of Africa with GeoPandas")
plt.show()

Which results in the following plot of the African continent:

I used a cmap here to give a unique visual distinction to each country on the African continent.

Note: The matplotlib library has a huge number of cmap’s built-into it. You aren’t limited to just one.

Plotting a map of a single country with GeoPandas

Just like we can plot a single continent with GeoPandas, you can also plot a single country.

Here I am filtering out the country of Kenya from the africa dataframe:

# initialize a new figure
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot()

# grab the country of Kenya
kenya = africa[africa["name"] == "Kenya"]

# plot a basic map of Kenya
kenya.plot(
    ax=ax,
    cmap="Pastel1",
    edgecolor="black",
    alpha=0.5
)

# turn off axis ticks
ax.set_xticks([])
ax.set_yticks([])

# set the plot title
plt.title("Map of Kenya with GeoPandas")
plt.show()

Which results in the following plot of Kenya:

Plotting multiple countries with GeoPandas

Now, let’s say I wanted to plot multiple countries with GeoPandas and Python.

All I need to do is:

1. Define a list of country_names that I want to plot
2. Use the isin() method to filter on the name column (which is the name of the country within a given continent)

The following code does the trick:

# initialize a new figure
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot()

# define the names of the countries we want to plot
country_names = [
    "Kenya",
    "Somalia",
    "Uganda",
    "Ethiopia",
    "Sudan",
    "South Sudan",
    "Chad",
    "Cameroon",
]

# grab multiple countries from the continent of Africa
countries = africa[
    africa["name"].isin(country_names)
]

# plot a map of the countries
countries.plot(
    ax=ax,
    cmap="Pastel1",
    edgecolor="black",
    alpha=0.5
)

# turn off axis ticks
ax.set_xticks([])
ax.set_yticks([])

# set the plot title
plt.title("Plotting Multiple Countries with GeoPandas")
plt.show()

Notice how multiple countries have been plotted with GeoPandas:

Visualizing continents with GeoPandas

One final experiment I played with was visualizing each of the continents with GeoPandas by creating a unique color overlay of the countries belonging to each of the respective continents (i.e., quickly visualizing the countries that make up North America, South America, Europe, etc.).

To start, I dropped “Antarctica” and the “Seven seas” from the world dataframe, which resulted in a prettier world map:

# initialize a final empty figure
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot()

# drop "Antarctica" and "Seven seas" from the dataframe (which will make our
# world map visualization a bit prettier)
drop_idxs = world["continent"].isin([
    "Antarctica",
    "Seven seas (open ocean)"
])
world = world.drop(world[drop_idxs].index)

I then plotted a boundary map of the world:

# start by plotting a map of the world
world.boundary.plot(
    ax=ax,
    color="black",
    linewidth=0.5
)

A boundary map (as opposed to a normal map) is effectively just an outline of the countries/continents of the world:

Finally, I was ready to create the color overlay for each of the continents.

There were a number of ways to accomplish this task, but the easiest way I found was to:

1. Use Seaborn’s color_palette function to generate a unique color for each continent
2. Loop over the continents (and respective visualization colors)
3. Filter on the current continent
4. Use the .plot method of the continent dataframe, along with the axis (ax) from the boundary plot, to draw the continent overlay

Here is the code I used to create the continent visualization:

# grab the unique set of continents, generate a unique color for each one,
# and initialize the list of patches
continents = world["continent"].unique()
colors = sns.color_palette("Set3", len(continents))
patches = []

# loop over the continent names and corresponding colors
for (continent_name, color) in list(zip(continents, colors)):
    # grab all countries that belong to the continent, then plot each of the
    # continents, giving each a unique color
    continent = world[world["continent"] == continent_name]
    continent.plot(ax=ax, color=color, alpha=0.5)

    # generate a patch for the current continent
    patch = mpatches.Patch(label=continent_name, color=color)
    patches.append(patch)

# add the patches to the map
ax.legend(handles=patches, loc="lower left")

# turn off axis ticks
ax.set_xticks([])
ax.set_yticks([])

# set the plot title
plt.title("Continents of the World with GeoPandas")
plt.show()

And here is the resulting world map:

At this point I feel comfortable plotting geographical regions, specifically countries and continents, with GeoPandas.

I’ll be building on this code in future experiments where I:

• Plot a map of the United States with GeoPandas
• Visualize Tornado Alley and Dixie Alley with GeoPandas
• Analyze major tornadoes in the United States and plot them

I’ll share those results once I get around to coding them.

Takeaways

• EM-DAT Exploration: The motivation to explore geographical plotting originated from my interest in the EM-DAT database which holds records of major natural disasters since 1900.
• GeoPandas Basics: To plot a map of the world, I found GeoPandas to be immensely helpful. It offers an in-built dataset naturalearth_lowres that provides a low-resolution map of the world, ready for visualization.
• Plotting a World Map: A few lines of Python code with GeoPandas can produce a basic world map. The world dataframe in GeoPandas contains columns detailing each country’s population, GDP, ISO codes, and crucially, their geographical boundaries.
• Zooming into Continents and Countries: I demonstrated how you can visualize a specific continent (like Africa) or even a single country (like Kenya). GeoPandas makes it easy to filter and plot regions of interest.
• Multiple Countries Visualization: By defining a list of countries of interest, we can visualize multiple countries in one go.
• Boundary Maps and Continent Overlays: Beyond just plotting standard maps, we also delved into creating boundary maps, which are essentially the outlines of countries. We even overlaid each continent with unique colors for a more striking visual.
• Future Work: Building on this foundational knowledge, I plan to delve deeper into visualizing specific regions like Tornado Alley and Dixie Alley. I’ll also analyze and plot major tornado events in the U.S.

Citation information

Adrian Rosebrock. “How to Plot a World Map Using Python and GeoPandas”, NaturalDisasters.ai, 2023, https://naturaldisasters.ai/posts/python-geopandas-world-map-tutorial/.

@incollection{ARosebrock_PlotWorldMapGeoPandas,
    author = {Adrian Rosebrock},
    title = {How to Plot a World Map Using Python and GeoPandas},
    booktitle = {NaturalDisasters.ai},
    year = {2023},
    url = {https://naturaldisasters.ai/posts/python-geopandas-world-map-tutorial/},
}

AI generated content disclaimer: I’ve used a sprinkling of AI magic in this blog post, namely in the “Takeaways” section, where I used AI to create a concise summary of this article. Don’t fret, my human eyeballs have read and edited every word of the AI generated content, so rest assured, what you’re reading is as accurate as I possibly can make it. If there are any discrepancies or inaccuracies in the post, it’s my fault, not that of our machine assistants.

Header photo by Andrew Stutesman on Unsplash