Python for GIS: What It Is and When to Use It

On this page

Problem statement

If you already work in QGIS or ArcGIS, "Python for GIS" raises the same questions:

Is Python only for developers?
Is it useful if you already use QGIS or ArcGIS?
When is scripting better than clicking through tools manually?
Which GIS tasks are worth automating?

The syntax is the easy part. The real question is which of your tasks a script does better than a dialog.

This page explains what Python for GIS means, which problems it solves well, and when it is a better choice than doing everything manually in desktop GIS.

Quick answer

Python for GIS means using Python to read, clean, transform, analyze, and export spatial data.

In practice, Python is most useful for:

automating repetitive GIS tasks
batch processing many files
cleaning attribute data
reprojecting and standardizing layers
running repeatable spatial analysis
converting between formats such as Shapefile and GeoJSON
combining spatial data with CSV, Excel, APIs, or databases

Use Python when a task repeats often, needs consistent documented steps, or becomes slow and error-prone in a manual GIS workflow. For one-off visual tasks, QGIS or ArcGIS may still be faster.

Automate or not?

Deciding when to automate a GIS task in Python versus using desktop GIS.

A specific task, repeated and structured, then the tool

Six libraries cover almost everything; knowing which is which saves a lot of searching.

Step 1: Define the exact GIS task

Start with one specific problem.

Good examples:

convert 200 shapefiles to GeoJSON
reproject all parcel layers to a single CRS
filter road features where status = 'active'
join inspection results from CSV to a parcel layer

Avoid vague goals like “automate GIS.” Python is easier to evaluate when the task is clear.

Step 2: Check whether the task repeats

Python is most valuable when the same workflow happens:

across many files
every week or month
for multiple clients or projects
as part of a standard reporting process

If you only need to fix one file once, desktop GIS may be faster.

Step 3: Check whether the inputs are structured

Automation works best when the input data is predictable. Look for:

consistent file names
expected columns
known geometry types
a valid and known CRS
stable folder structure

If every dataset arrives in a different format with different field names, you may need some manual cleanup before automation works reliably.

Step 4: Choose the right Python tool

Use the library that matches the data and task:

GeoPandas: vector data reading, writing, filtering, joins, reprojection
Shapely: geometry objects and geometry-based operations
Rasterio: raster reading, writing, masking, transformations
PyQGIS: automation inside QGIS

For most beginner vector workflows, GeoPandas is the best starting point.

Step 5: Test the workflow on a small sample

Before processing a full folder, test your script on a few files.

This helps you catch:

missing fields
CRS problems
invalid geometries
export issues
unexpected file naming patterns

A small test run is much safer than finding problems after processing 500 files.

Step 6: Automate the stable version of the workflow

Once the manual steps are clear and the sample works, turn the workflow into a script.

This is where Python helps most:

the same logic runs every time
the process is documented in code
new files can be processed with minimal manual work
the workflow is easier to review and reuse

Rutland shapefiles read, reprojected, filtered and batched

The extract Example 4 converts: one zip, 18 shapefiles, and a loop that does not care which is which.

The data used on this page

Two open downloads for Rutland, England's smallest county: Geofabrik's OpenStreetMap extract of 1 January 2026, which arrives as a zip of shapefiles (© OpenStreetMap contributors, ODbL), and HM Land Registry's INSPIRE Index Polygons, a GML file of every registered freehold parcel (© Crown copyright and database rights, HM Land Registry; Open Government Licence).

import time
import zipfile
from pathlib import Path

import geopandas as gpd
import requests

data = Path("data")
data.mkdir(exist_ok=True)
downloads = {
    "rutland-osm.zip": "https://download.geofabrik.de/europe/united-kingdom/england/rutland-260101-free.shp.zip",
    "Rutland.zip": "https://use-land-property-data.service.gov.uk/datasets/inspire/download/Rutland.zip",
}
session = requests.Session()
for name, url in downloads.items():
    if not (data / name).exists():
        (data / name).write_bytes(session.get(url, timeout=300).content)
with zipfile.ZipFile(data / "rutland-osm.zip") as z:
    z.extractall(data / "input_layers")
print(len(list((data / "input_layers").glob("*.shp"))), "shapefiles in the OSM extract")

18 shapefiles in the OSM extract

Example 1: Read a shapefile with GeoPandas

gdf = gpd.read_file("data/input_layers/gis_osm_roads_free_1.shp")

print(gdf.head(3))
print(gdf.crs)
print(list(gdf.columns))
print(len(gdf), "road features")

    osm_id  code  ... tunnel                                           geometry
0  2484492  5112  ...      F  LINESTRING (-0.72461 52.59642, -0.72452 52.596...
1  2484493  5112  ...      F  LINESTRING (-0.64671 52.59353, -0.6459 52.5934...
2  2956385  5113  ...      F  LINESTRING (-0.63426 52.59321, -0.63372 52.593...

[3 rows x 11 columns]
EPSG:4326
['osm_id', 'code', 'fclass', 'name', 'ref', 'oneway', 'maxspeed', 'layer', 'bridge', 'tunnel', 'geometry']
7292 road features

This is a basic example of working with spatial data directly in Python. You can inspect attributes, geometry, and CRS without opening a desktop GIS project — and you can see at once that there is no status column to filter on, only OSM's fclass.

Example 2: Reproject vector data

parcels = gpd.read_file("/vsizip/data/Rutland.zip/Land_Registry_Cadastral_Parcels.gml")
print(parcels.crs.name, "->", parcels.total_bounds.round(0))

parcels_4326 = parcels.to_crs("EPSG:4326")
print(parcels_4326.crs.name, "->", parcels_4326.total_bounds.round(4))

Path("output").mkdir(exist_ok=True)
parcels_4326.to_file("output/parcels_4326.gpkg", layer="parcels")
print(len(parcels_4326), "parcels written")

OSGB36 / British National Grid -> [479001. 292381. 506878. 319201.]
WGS 84 -> [-0.835  52.5223 -0.4198 52.7623]
21253 parcels written

Read, transform, write: GML straight out of the zip in British National Grid metres, GeoPackage out in longitude and latitude. The GML is read without unzipping it first, through GDAL's /vsizip/ path.

Example 3: Filter features by attribute

roads = gpd.read_file("data/input_layers/gis_osm_roads_free_1.shp")

main_roads = roads[roads["fclass"].isin(["trunk", "primary"])]
main_roads.to_file("output/main_roads.geojson", driver="GeoJSON")

km = main_roads.to_crs(27700).length.groupby(main_roads["fclass"]).sum() / 1000
print(km.round(1))

fclass
primary    19.4
trunk      99.6
dtype: float64

This replaces a manual select-and-export step in desktop GIS. The lengths are measured after reprojecting to British National Grid; in the extract's own longitude and latitude, .length would be in degrees.

Example 4: Batch process every shapefile in a folder

input_folder = Path("data/input_layers")
output_folder = Path("output/reprojected_geojson")
output_folder.mkdir(parents=True, exist_ok=True)

start = time.perf_counter()
features = 0
for shp_file in sorted(input_folder.glob("*.shp")):
    gdf = gpd.read_file(shp_file)
    gdf = gdf.to_crs("EPSG:27700")

    output_file = output_folder / f"{shp_file.stem}.geojson"
    gdf.to_file(output_file, driver="GeoJSON")
    features += len(gdf)

written = sorted(output_folder.glob("*.geojson"))
print(f"{len(written)} layers, {features:,} features, {time.perf_counter() - start:.1f} s")

18 layers, 18,637 features, 0.5 s

This is the case where Python is clearly better than repeating the same steps by hand: every layer in the extract, reprojected and converted in one loop that takes the same few lines for 200 files as for these.

Example 5: Check the data before trusting the result

import warnings

print("parcels:", parcels.crs.to_epsg(), " main roads:", main_roads.crs.to_epsg())
with warnings.catch_warnings(record=True) as caught:
    warnings.simplefilter("always")
    naive = gpd.sjoin(parcels, main_roads, predicate="intersects")
print(f"joined as delivered: {naive.index.nunique()} parcels touch a main road")
print("warning:", str(caught[0].message).splitlines()[0] if caught else None)

fixed = gpd.sjoin(parcels, main_roads.to_crs(parcels.crs), predicate="intersects")
print(f"after to_crs:        {fixed.index.nunique():,} parcels touch a main road")
print(f"invalid geometries:  {(~parcels.is_valid).sum()} of {len(parcels):,} parcels")

parcels: 27700  main roads: 4326
joined as delivered: 0 parcels touch a main road
warning: CRS mismatch between the CRS of left geometries and the CRS of right geometries.
after to_crs:        168 parcels touch a main road
invalid geometries:  0 of 21,253 parcels

The join ran, warned, and returned nothing: metres and degrees never overlap, so every parcel appeared to be nowhere near a road. The warning is the only sign, and in a script that runs unattended nobody reads it. The geometry check, on the other hand, came back clean — Land Registry's polygons are all valid — and it is still worth the moment it takes, because the next delivery may not be.

What Python for GIS means, and when not to start there

What Python for GIS means in practice

They are complements: the GUI is for seeing, the script is for repeating.

In GIS work, Python usually means one of three things:

Automating repetitive GIS tasks

Common examples include:

renaming fields across many layers
clipping many files to the same boundary
reprojecting datasets to one CRS
converting shapefiles to GeoJSON
exporting cleaned outputs to a standard folder structure

If you repeat the same process often, scripting usually saves time and reduces mistakes.

Working with spatial data directly

Python can read and manipulate many common spatial data formats without opening a desktop GIS project.

With tools like GeoPandas and Shapely, you can:

load shapefiles and GeoJSON
inspect columns and CRS
filter records
edit attributes
calculate geometry-based results
write outputs to new files

This is useful when you want a reproducible data workflow instead of a manual GUI process.

Building repeatable workflows

A script gives you repeatable steps. If a workflow runs regularly, Python makes it easier to:

keep the process consistent
document what was done
rerun the same logic on new data
scale from a few files to hundreds

That is the main reason many GIS users start using Python.

Common GIS problems Python is good at solving

Each heading below is one of the rows where Python wins.

Python is a good fit for tasks such as:

Batch processing many files

Instead of opening each file manually, you can loop through a folder and apply the same operation to all of them.

Cleaning attribute tables

You can standardize column names, fix missing values, trim text, and convert field types before spatial analysis.

Reprojecting and standardizing data

If incoming layers arrive in mixed coordinate systems, Python can convert them to one target CRS.

Joining tabular data to spatial layers

Python works well when you need to combine a spatial layer with CSV, Excel, API results, or database tables.

Repeating the same analysis

If you run the same buffer, overlay, filter, or dissolve process often, Python removes much of the manual repetition.

Exporting outputs for other systems

You can write results to Shapefile, GeoJSON, GeoPackage, or CSV as part of one script.

When to use Python for GIS

Use Python when:

the task is repetitive
the workflow needs to be documented
the same logic must run on many files
the process needs to connect with non-GIS data sources
manual desktop work is becoming slow or inconsistent

When not to use Python first

Python is not always the best first choice.

Desktop GIS is often better when:

the task is a one-off operation
you need visual inspection and manual editing
the workflow is still being explored and is not stable enough to automate
the work is mainly cartographic layout or visual QA

A practical approach is to test a workflow manually first, then automate it once the steps are clear.

Core Python GIS tools to know

GeoPandas

GeoPandas is the most practical entry point for vector workflows. It handles shapefiles, GeoJSON, CRS conversion, filtering, joins, and exports.

Shapely

Shapely focuses on geometry objects and operations such as intersections, buffers, and other geometry-based operations.

Rasterio

Rasterio is used for raster reading, writing, masking, and transformations.

PyQGIS

PyQGIS is useful when you want to automate work inside QGIS itself.

GIS knowledge, dirty inputs and small scripts

Python does not replace GIS knowledge

You still need to understand layers, attributes, geometry types, and coordinate reference systems. Python automates GIS work, but it does not remove the need for GIS basics.

CRS problems still matter

A script will not fix an incorrectly assigned CRS automatically. Always check gdf.crs before reprojecting data.

Invalid geometries can break workflows

Some spatial operations fail when geometries are invalid. If overlays, buffers, or exports behave unexpectedly, inspect geometry validity before assuming the code is wrong.

Dirty input data can break automation

Missing fields, inconsistent column names, mixed formats, and unexpected null values can cause scripts to fail. Predictable input data makes automation much easier.

Small scripts are often enough

You do not need a large application. Many useful GIS workflows are solved with short scripts that handle one repetitive task well.

Internal links

FAQ

What does Python for GIS actually mean?

It means using Python to automate GIS tasks and work directly with spatial data. That includes reading files, cleaning attributes, reprojecting layers, filtering features, running analysis, and exporting results.

When should I use Python instead of QGIS tools?

Use Python when the task is repetitive, needs consistent documented steps, or must run on many files. For one-off visual tasks, QGIS may be faster.

Do I need to be a developer to use Python for GIS?

No. Many GIS users start with small scripts for tasks like reprojection, file conversion, or filtering records. Beginner to intermediate Python is enough for many real workflows.

What Python libraries are most useful for GIS beginners?

For vector data, start with GeoPandas and Shapely. For raster data, use Rasterio. If you want to automate QGIS directly, use PyQGIS.

Do I need ArcGIS or arcpy to use Python for GIS?

No. GeoPandas, Shapely, and Rasterio are open-source and run without any Esri licence. arcpy is only needed when you specifically want to automate ArcGIS Pro tools.

What is the easiest way to install the Python GIS stack?

Using conda or mamba from the conda-forge channel is usually the smoothest, because it resolves the underlying GDAL, GEOS, and PROJ libraries for you: conda install -c conda-forge geopandas rasterio. Plain pip install geopandas also works on most current platforms.

Can Python handle large spatial datasets that are too big for memory?

Yes, with the right approach. You can read subsets using the bbox, rows, or where arguments of gpd.read_file, process data in chunks, or move to tools like Dask-GeoPandas or a PostGIS database for datasets larger than memory.