Putz, se eu pudesse voltar pra 2014 e me dar um conselho como engenheiro ambiental começando, seria esse: aprende Python pra GIS, agora. Naquela época eu fazia tudo no QGIS clicando em botão, e perdia tarde inteira pra rodar uma análise que hoje resolvo em 8 linhas de código. Sou Leonardo Marques, doutor em saneamento ambiental, fundador do Clube do GIS, e já formei mais de 10.000 profissionais. Vou te mostrar as bibliotecas Python GIS que de fato importam em 2026, com exemplo de código real pra cada uma, quando usar e quando NÃO usar. Não é lista genérica de Stack Overflow. É o stack que eu uso no dia a dia em licenciamento, georreferenciamento e análise espacial. Bora?
1. GeoPandas, o “pandas pra geo”
Se você já mexeu com pandas em ciência de dados, GeoPandas é literalmente a versão geoespacial. Cada linha do DataFrame tem uma geometria associada (ponto, linha, polígono), e você opera tudo de forma vetorizada. É a porta de entrada moderna pro GIS em Python e, na minha opinião, deveria ser a primeira biblioteca que todo geoprofissional aprende.
Lê shapefile, GeoPackage, GeoJSON, PostGIS. Faz join espacial, dissolve, buffer, intersect, tudo com sintaxe limpa. Por baixo dos panos usa Shapely pra geometria, Fiona pra IO e pyproj pra reprojeção, então é praticamente o canivete suíço.
import geopandas as gpd
# Lendo shapefile de municípios
municipios = gpd.read_file("municipios_sp.shp")
# Reprojetando pra SIRGAS 2000 / UTM 23S
municipios = municipios.to_crs(epsg=31983)
# Calculando área em hectares
municipios["area_ha"] = municipios.geometry.area / 10_000
# Filtrando municípios maiores que 50 mil ha
grandes = municipios[municipios["area_ha"] > 50_000]
grandes.to_file("grandes_municipios.gpkg", driver="GPKG")
Por que importa: o que você faz em 30 cliques no QGIS, GeoPandas resolve em 4 linhas, e ainda dá pra rodar em loop pra 1.000 arquivos.
Quando NÃO usar: análises com raster pesado (use Rasterio ou rioxarray) ou bases gigantes que não cabem em memória (aí parte pra Dask-GeoPandas ou PostGIS).
2. Shapely, a base geométrica de tudo
Shapely é a biblioteca que cuida das geometrias 2D em si: criar pontos, linhas, polígonos, fazer interseção, união, buffer, calcular distância, verificar se um ponto está dentro de um polígono. Quase todo o ecossistema Python GIS depende dela por baixo dos panos. Quando você usa GeoPandas, está usando Shapely sem perceber.
A versão 2.0 (de 2022) reescreveu tudo em cima do GEOS com operações vetorizadas, deixando absurdamente mais rápida. Em 2026 já é padrão consolidado.
from shapely.geometry import Point, Polygon
from shapely.ops import unary_union
# Criando pontos de poços
pocos = [Point(-46.63, -23.55), Point(-46.65, -23.56), Point(-46.62, -23.54)]
# Buffer de 500 metros (em graus, simplificado)
buffers = [p.buffer(0.005) for p in pocos]
# Unindo todos os buffers
area_influencia = unary_union(buffers)
print(f"Área de influência: {area_influencia.area:.6f} graus²")
Por que importa: entender Shapely é entender como o Python pensa o espaço. Sem isso, você só decora função de GeoPandas sem saber o que tá rolando por baixo.
Quando NÃO usar: operações que envolvem tabela de atributos (vai de GeoPandas) ou geometria 3D complexa (parte pra PyVista).
3. Fiona, o leitor universal de formatos vetoriais
Fiona é a biblioteca que faz a leitura e escrita de praticamente qualquer formato vetorial: shapefile, GeoJSON, GeoPackage, KML, GML, MapInfo. Ela é wrapper Python pro OGR (parte do GDAL), só que com API pythônica e limpa.
Você raramente vai usar Fiona diretamente porque o GeoPandas usa ela por baixo. Mas quando precisa de controle fino, tipo ler um shapefile de 5 milhões de feições sem carregar tudo na memória, Fiona brilha.
import fiona
# Lendo shapefile feição por feição (streaming, sem estourar RAM)
with fiona.open("imoveis_rurais_brasil.shp") as src:
print(f"CRS: {src.crs}")
print(f"Total de feições: {len(src)}")
for i, feature in enumerate(src):
if i >= 3: # só pra mostrar
break
print(feature["properties"]["nome"])
Por que importa: quando você lida com base do INCRA inteira, com milhões de imóveis rurais, GeoPandas trava. Fiona em streaming não.
Quando NÃO usar: análise vetorial completa (vai de GeoPandas, mais alto nível) ou IO de raster (usa Rasterio).
4. Rasterio, manipulação raster moderna
Rasterio é o GeoPandas dos rasters. API limpa, pythônica, em cima do GDAL. Lê GeoTIFF, MrSID, JPEG2000, NetCDF, COG, e te dá array NumPy direto pra trabalhar. É padrão pra análise raster em Python desde 2018, e em 2026 continua sendo a escolha óbvia pra raster 2D.
Eu uso muito pra extrair NDVI, recortar imagem Sentinel-2 por área de estudo, calcular estatísticas zonais, fazer mosaico.
import rasterio
from rasterio.mask import mask
import geopandas as gpd
# Lendo área de interesse
aoi = gpd.read_file("fazenda.gpkg")
# Recortando raster Sentinel pelo polígono
with rasterio.open("sentinel_b08.tif") as src:
out_image, out_transform = mask(src, aoi.geometry, crop=True)
out_meta = src.meta.copy()
out_meta.update({"height": out_image.shape[1],
"width": out_image.shape[2],
"transform": out_transform})
with rasterio.open("recorte_b08.tif", "w", **out_meta) as dst:
dst.write(out_image)
Por que importa: pra quem trabalha com sensoriamento remoto, é o feijão com arroz. Recortar, mascarar, calcular índice, tudo bonito.
Quando NÃO usar: raster multidimensional (séries temporais, cubos de dados): use rioxarray.
5. Pyproj, sistemas de coordenadas sem dor de cabeça
Pyproj é a biblioteca que cuida de transformação de CRS (Coordinate Reference System). Reprojeção, conversão de coordenadas, cálculo de distância geodésica. Por baixo é o PROJ, o motor de projeção que tudo no GIS usa.
Você raramente chama Pyproj direto porque GeoPandas e Rasterio fazem por você. Mas quando você precisa converter um par de coordenadas avulso, ou calcular distância real entre dois pontos no globo, é Pyproj.
from pyproj import Transformer, Geod
# Convertendo lat/lon (WGS84) pra UTM 23S (SIRGAS 2000)
transformer = Transformer.from_crs("EPSG:4674", "EPSG:31983", always_xy=True)
x, y = transformer.transform(-46.63, -23.55)
print(f"UTM: {x:.2f}, {y:.2f}")
# Distância geodésica entre São Paulo e Rio
geod = Geod(ellps="WGS84")
_, _, dist = geod.inv(-46.63, -23.55, -43.17, -22.90)
print(f"Distância real: {dist/1000:.1f} km")
Por que importa: errar CRS é o erro número 1 de quem começa em GIS. Pyproj te tira da areia movediça.
Quando NÃO usar: se você só precisa reprojetar uma camada inteira, deixa o GeoPandas (gdf.to_crs(...)) fazer o trabalho.
6. Folium, mapas interativos pro navegador
Folium gera mapas interativos em HTML usando Leaflet.js por baixo. É o jeito mais rápido de você pegar um GeoDataFrame e mostrar pro cliente um mapa que ele abre no navegador, dá zoom, clica e vê atributos. Sem servidor, sem complicação.
Em 2026 ainda é a escolha mais simples pra apresentação. Pra dashboards mais sofisticados existem alternativas (Kepler.gl, Lonboard), mas Folium continua sendo o “abre e usa” do Python GIS.
import folium
import geopandas as gpd
# Lendo bairros e centralizando o mapa
bairros = gpd.read_file("bairros.gpkg").to_crs(epsg=4326)
centroide = bairros.geometry.unary_union.centroid
m = folium.Map(location=[centroide.y, centroide.x], zoom_start=12)
folium.GeoJson(
bairros,
tooltip=folium.GeoJsonTooltip(fields=["nome", "populacao"])
).add_to(m)
m.save("mapa_bairros.html")
Por que importa: entrega cliente em mapa interativo, sem precisar publicar geoserver. Manda o HTML por email e tá resolvido.
Quando NÃO usar: milhões de feições (Folium trava no navegador, parte pra Lonboard ou Deck.gl) ou produção em larga escala (vai de webGIS de verdade).
7. GDAL/OGR, a base universal
GDAL/OGR é o motor que tá por baixo de TUDO no GIS open source. Rasterio, Fiona, GeoPandas, QGIS, ArcGIS Pro (sim), todos usam GDAL no fundo. A biblioteca em Python tem fama de ter API meio crua, herança do C++, mas é potente. Quando uma operação não está exposta nas bibliotecas mais altas, você desce pro GDAL direto.
Eu uso muito pra conversão de formatos exóticos, manipulação de metadados, criação de pirâmides em raster gigante.
from osgeo import gdal, ogr
# Convertendo shapefile pra GeoPackage via OGR
src = ogr.Open("entrada.shp")
driver = ogr.GetDriverByName("GPKG")
dst = driver.CopyDataSource(src, "saida.gpkg")
dst = None # fecha
# Construindo overviews (pirâmides) num GeoTIFF gigante
ds = gdal.Open("imagem_grande.tif", gdal.GA_Update)
ds.BuildOverviews("AVERAGE", [2, 4, 8, 16])
ds = None
Por que importa: quando o problema é estranho ou o arquivo é exótico, GDAL resolve. Saber o básico te tira de muita encrenca.
Quando NÃO usar: trabalho cotidiano com vetor ou raster comum. Use as bibliotecas de nível mais alto, sua produtividade triplica.
8. PyQGIS, automação dentro do QGIS
PyQGIS é a API Python que roda dentro do próprio QGIS, no Console (Ctrl+Alt+P). Te dá acesso a tudo: camadas do projeto, simbologia, layout, processing, expressões. É a forma de transformar o QGIS numa máquina de automação.
Diferente das outras bibliotecas que rodam fora do QGIS, PyQGIS é íntima da interface. Você abre o projeto, roda o script no Console, e ele manipula o que tá lá na tela.
from qgis.core import QgsProject, QgsVectorLayer
import processing
# Listando todas as camadas vetoriais do projeto aberto
projeto = QgsProject.instance()
camadas_vetoriais = [c for c in projeto.mapLayers().values()
if isinstance(c, QgsVectorLayer)]
# Aplicando buffer em cada uma usando o processing
for camada in camadas_vetoriais:
processing.run("native:buffer", {
"INPUT": camada,
"DISTANCE": 100,
"OUTPUT": f"memory:{camada.name()}_buffer"
})
print(f"{len(camadas_vetoriais)} camadas processadas")
Por que importa: se você já trabalha no QGIS, PyQGIS é multiplicador absurdo. O que você faz em 50 cliques vira 1 botão.
Quando NÃO usar: scripts standalone fora do QGIS (vai de GeoPandas/Rasterio, sem dependência do QGIS instalado).
9. xarray + rioxarray, raster multidimensional pra séries temporais
Quando você sai do raster simples (uma banda, uma data) e entra em cubos de dados (várias bandas, várias datas, Sentinel-2 ao longo do tempo), Rasterio começa a ficar limitado. Aí entra xarray, biblioteca de array N-dimensional rotulada, com extensão rioxarray pra dar superpoderes geoespaciais.
É padrão em climatologia, Earth Engine offline, análise de série temporal. Em 2026, com o boom de dados Sentinel e Landsat em STAC, é praticamente obrigatório.
import rioxarray as rxr
import xarray as xr
# Empilhando 12 imagens NDVI mensais de 2025
arquivos = [f"ndvi_2025_{m:02d}.tif" for m in range(1, 13)]
ndvi_stack = xr.concat(
[rxr.open_rasterio(f) for f in arquivos],
dim="tempo"
)
# Calculando NDVI médio anual e exportando
ndvi_medio = ndvi_stack.mean(dim="tempo")
ndvi_medio.rio.to_raster("ndvi_medio_2025.tif")
Por que importa: série temporal de satélite é o presente do GIS. Quem não souber lidar com cubo de dados vai ficar pra trás.
Quando NÃO usar: raster simples, único, 2D. É overkill, fica com Rasterio.
10. OSMnx, OpenStreetMap em 3 linhas
OSMnx é a biblioteca que baixa, modela e analisa redes viárias e dados do OpenStreetMap. Em vez de você baixar arquivo .osm gigante e processar manualmente, você passa o nome de uma cidade e ela te entrega a malha viária pronta como grafo NetworkX, com tudo: ruas, edificações, parques, bairros.
Pra projeto urbano, mobilidade, estudo de acessibilidade, é praticamente cheat code. O autor (Geoff Boeing) é pesquisador de mobilidade urbana, e a biblioteca é referência mundial.
import osmnx as ox
# Baixando malha viária de uma cidade
grafo = ox.graph_from_place("Florianópolis, Brasil", network_type="drive")
# Salvando como shapefile
gdf_arestas = ox.graph_to_gdfs(grafo, nodes=False)
gdf_arestas.to_file("ruas_floripa.gpkg", driver="GPKG")
# Calculando estatísticas básicas da malha
stats = ox.basic_stats(grafo)
print(f"Total de intersecções: {stats['n']}")
print(f"Comprimento total da malha: {stats['edge_length_total']/1000:.1f} km")
Por que importa: dado de OSM em segundos, sem precisar mexer com Overpass API na mão. Pra estudo de mobilidade, ouro puro.
Quando NÃO usar: quando você precisa de dado oficial de cadastro (IBGE, INCRA, prefeitura). OSM é colaborativo, então a precisão varia muito por região.
Como sair do “manjo Python básico” pro “automatizo GIS profissionalmente”
Olha, dominar essas 10 bibliotecas individualmente é uma coisa. Saber combinar elas pra resolver problema real (ler shapefile do INCRA, recortar imagem Sentinel pelo polígono, calcular NDVI, exportar relatório) é outro nível. E é exatamente nessa ponte que muita gente trava.
E é exatamente isso que ensino no Descomplica Geo-Python: 40 horas, 74 aulas, do básico ao avançado em PyQGIS, GeoPandas, Rasterio, Shapely, automação de processos. Sai do “fiz o tutorial do GeoPandas” pro “monto pipeline completo de processamento espacial”.
Quem ainda está começando do zero em Python pode dar uma olhada também no Mini-Curso Introdutório Python GIS, que prepara a base de sintaxe, lógica e ambiente antes de você cair de cabeça no Descomplica Geo-Python.
Conheça o Descomplica Geo-Python aqui
Perguntas frequentes
Preciso saber Python antes de aprender essas bibliotecas?
Sim, idealmente. Não precisa ser fera, mas saber variável, lista, dicionário, loop e função básica ajuda muito. Se está no zero, faz o Mini-Curso Introdutório Python GIS antes.
Qual biblioteca aprender primeiro?
GeoPandas. Ela é a porta de entrada moderna, cobre 70% do que você vai fazer com vetor, e como usa Shapely, Fiona e pyproj por baixo, você acaba aprendendo as três indiretamente.
PyQGIS substitui o QGIS?
Não. PyQGIS roda DENTRO do QGIS, é a forma de automatizar o QGIS. Você precisa ter o QGIS instalado pra usar.
GeoPandas ou ArcPy?
ArcPy é proprietário (precisa de licença ArcGIS), GeoPandas é open source. Pro mercado brasileiro, GeoPandas ganha de longe em adoção e custo. Se você trabalha em órgão público com licença ArcGIS, vale saber os dois.
