Klimadaten spielen in mehreren Sektoren eine entscheidende Rolle und helfen bei Studien und Prognosen, die sich auf Bereiche wie Landwirtschaft, Stadtplanung und Management natürlicher Ressourcen auswirken.
Das Nationale Institut für Meteorologie (INMET) bietet monatlich die Meteorologische Datenbank (BDMEP) auf seiner Website an. Diese Datenbank enthält eine historische Reihe von Klimainformationen, die von Hunderten von in ganz Brasilien verteilten Messstationen gesammelt wurden. In BDMEP finden Sie detaillierte Daten zu Niederschlag, Temperatur, Luftfeuchtigkeit und Windgeschwindigkeit.
Mit stündlichen Aktualisierungen sind diese Daten recht umfangreich und bieten eine reichhaltige Grundlage für detaillierte Analysen und fundierte Entscheidungen.
In diesem Beitrag werde ich zeigen, wie man Klimadaten von INMET-BDMEP sammelt und verarbeitet. Wir sammeln die auf der INMET-Website verfügbaren Rohdatendateien und verarbeiten diese Daten dann, um die Analyse zu erleichtern.
Um die oben genannten Ziele zu erreichen, müssen Sie lediglich drei Pakete installiert haben:
Um die erforderlichen Pakete zu installieren, führen Sie den folgenden Befehl im Terminal aus:
pip install httpx pandas tqdm
Wenn Sie beispielsweise eine virtuelle Umgebung (venv) mit Poesie verwenden, verwenden Sie den folgenden Befehl:
poetry add httpx pandas tqdm
Die Adresse von BDMEP-Datendateien folgt einem sehr einfachen Muster. Das Muster ist wie folgt:
https://portal.inmet.gov.br/uploads/dadoshistoricos/{year}.zip
Der einzige Teil, der sich ändert, ist der Dateiname, der einfach das Referenzjahr der Daten ist. Monatlich wird die Datei für das letzte (laufende) Jahr durch aktualisierte Daten ersetzt.
Dadurch lässt sich ganz einfach Code erstellen, um automatisch Datendateien aus allen verfügbaren Jahren zu sammeln.
Tatsächlich beginnt die verfügbare historische Serie im Jahr 2000.
Um Datendateien von INMET-BDMEP zu sammeln, verwenden wir die httpx-Bibliothek, um HTTP-Anfragen zu stellen, und die tqdm-Bibliothek, um einen benutzerfreundlichen Fortschrittsbalken im Terminal anzuzeigen.
Zuerst importieren wir die notwendigen Pakete:
import datetime as dt from pathlib import Path import httpx from tqdm import tqdm
Wir haben das URL-Muster der INMET-BDMEP-Datendateien bereits identifiziert. Jetzt erstellen wir eine Funktion, die ein Jahr als Argument akzeptiert und die URL der Datei für dieses Jahr zurückgibt.
def build_url(year):
return f"https://portal.inmet.gov.br/uploads/dadoshistoricos/{year}.zip"
Um zu überprüfen, ob die URL-Datei aktualisiert wurde, können wir die Informationen im Header verwenden, der von einer HTTP-Anfrage zurückgegeben wird. Auf gut konfigurierten Servern können wir mit der HEAD-Methode genau diesen Header anfordern. In diesem Fall war der Server gut konfiguriert und wir können diese Methode verwenden.
Die Antwort auf die HEAD-Anfrage hat das folgende Format:
Mon, 01 Sep 2024 00:01:00 GMT
Um dieses Datum/diese Uhrzeit zu analysieren, habe ich die folgende Funktion in Python erstellt, die eine Zeichenfolge akzeptiert und ein Datum/Uhrzeit-Objekt zurückgibt:
def parse_last_modified(last_modified: str) -> dt.datetime:
return dt.datetime.strptime(
last_modified,
"%a, %d %b %Y %H:%M:%S %Z"
)
Wir können also das Datum/die Uhrzeit der letzten Änderung verwenden, um es mithilfe der String-Interpolation (F-Strings) in den Namen der Datei aufzunehmen, die wir herunterladen möchten:
def build_local_filename(year: int, last_modified: dt.datetime) -> str:
return f"inmet-bdmep_{year}_{last_modified:%Y%m%d}.zip"
Auf diese Weise können Sie ganz einfach überprüfen, ob die Datei mit den aktuellsten Daten bereits in unserem lokalen Dateisystem vorhanden ist. Wenn die Datei bereits existiert, kann das Programm beendet werden; Andernfalls müssen wir mit dem Sammeln der Datei fortfahren und die Anfrage an den Server stellen.
Die unten stehende Funktion „download_year“ lädt die Datei für ein bestimmtes Jahr herunter. Wenn die Datei bereits im Zielverzeichnis vorhanden ist, kehrt die Funktion einfach zurück, ohne etwas zu tun.
Beachten Sie, wie wir tqdm verwenden, um einen benutzerfreundlichen Fortschrittsbalken im Terminal anzuzeigen, während die Datei heruntergeladen wird.
def download_year(
year: int,
destdirpath: Path,
blocksize: int = 2048,
) -> None:
if not destdirpath.exists():
destdirpath.mkdir(parents=True)
url = build_url(year)
headers = httpx.head(url).headers
last_modified = parse_last_modified(headers["Last-Modified"])
file_size = int(headers.get("Content-Length", 0))
destfilename = build_local_filename(year, last_modified)
destfilepath = destdirpath / destfilename
if destfilepath.exists():
return
with httpx.stream("GET", url) as r:
pb = tqdm(
desc=f"{year}",
dynamic_ncols=True,
leave=True,
total=file_size,
unit="iB",
unit_scale=True,
)
with open(destfilepath, "wb") as f:
for data in r.iter_bytes(blocksize):
f.write(data)
pb.update(len(data))
pb.close()
Da wir nun alle notwendigen Funktionen haben, können wir die INMET-BDMEP-Datendateien sammeln.
Mithilfe einer for-Schleife können wir die Dateien für alle verfügbaren Jahre herunterladen. Der folgende Code macht genau das. Beginnend mit dem Jahr 2000 bis zum aktuellen Jahr.
destdirpath = Path("data")
for year in range(2000, dt.datetime.now().year + 1):
download_year(year, destdirpath)
Nachdem die INMET-BDMEP-Rohdatendateien heruntergeladen wurden, können wir die Daten nun lesen und verarbeiten.
Lassen Sie uns die notwendigen Pakete importieren:
import csv import datetime as dt import io import re import zipfile from pathlib import Path import numpy as np import pandas as pd from tqdm import tqdm
In der von INMET bereitgestellten ZIP-Datei finden wir mehrere CSV-Dateien, eine für jede Wetterstation.
Porém, nas primeiras linhas desses arquivos CSV encontramos informações sobre a estação, como a região, a unidade federativa, o nome da estação, o código WMO, as coordenadas geográficas (latitude e longitude), a altitude e a data de fundação. Vamos extrair essas informações para usar como metadados.
A leitura dos arquivos será feita em duas partes: primeiro, será feita a leitura dos metadados das estações meteorológicas; depois, será feita a leitura dos dados históricos propriamente ditos.
Para extrair os metadados nas primeiras 8 linhas do arquivo CSV vamos usar o pacote embutido csv do Python.
Para entender a função a seguir é necessário ter um conhecimento um pouco mais avançado de como funciona handlers de arquivos (open), iteradores (next) e expressões regulares (re.match).
def read_metadata(filepath: Path | zipfile.ZipExtFile) -> dict[str, str]:
if isinstance(filepath, zipfile.ZipExtFile):
f = io.TextIOWrapper(filepath, encoding="latin-1")
else:
f = open(filepath, "r", encoding="latin-1")
reader = csv.reader(f, delimiter=";")
_, regiao = next(reader)
_, uf = next(reader)
_, estacao = next(reader)
_, codigo_wmo = next(reader)
_, latitude = next(reader)
try:
latitude = float(latitude.replace(",", "."))
except:
latitude = np.nan
_, longitude = next(reader)
try:
longitude = float(longitude.replace(",", "."))
except:
longitude = np.nan
_, altitude = next(reader)
try:
altitude = float(altitude.replace(",", "."))
except:
altitude = np.nan
_, data_fundacao = next(reader)
if re.match("[0-9]{4}-[0-9]{2}-[0-9]{2}", data_fundacao):
data_fundacao = dt.datetime.strptime(
data_fundacao,
"%Y-%m-%d",
)
elif re.match("[0-9]{2}/[0-9]{2}/[0-9]{2}", data_fundacao):
data_fundacao = dt.datetime.strptime(
data_fundacao,
"%d/%m/%y",
)
f.close()
return {
"regiao": regiao,
"uf": uf,
"estacao": estacao,
"codigo_wmo": codigo_wmo,
"latitude": latitude,
"longitude": longitude,
"altitude": altitude,
"data_fundacao": data_fundacao,
}
Em resumo, a função read_metadata definida acima lê as primeiras oito linhas do arquivo, processa os dados e retorna um dicionário com as informações extraídas.
Aqui, finalmente, veremos como fazer a leitura do arquivo CSV. Na verdade é bastante simples. Basta usar a função read_csv do Pandas com os argumentos certos.
A seguir está exposto a chamada da função com os argumentos que eu determinei para a correta leitura do arquivo.
pd.read_csv(
"arquivo.csv",
sep=";",
decimal=",",
na_values="-9999",
encoding="latin-1",
skiprows=8,
usecols=range(19),
)
Primeiro é preciso dizer que o caractere separador das colunas é o ponto-e-vírgula (;), o separador de número decimal é a vírgula (,) e o encoding é latin-1, muito comum no Brasil.
Também é preciso dizer para pular as 8 primeiras linhas do arquivo (skiprows=8), que contém os metadados da estação), e usar apenas as 19 primeiras colunas (usecols=range(19)).
Por fim, vamos considerar o valor -9999 como sendo nulo (na_values="-9999").
Os nomes das colunas dos arquivos CSV do INMET-BDMEP são bem descritivos, mas um pouco longos. E os nomes não são consistentes entre os arquivos e ao longo do tempo. Vamos renomear as colunas para padronizar os nomes e facilitar a manipulação dos dados.
A seguinte função será usada para renomear as colunas usando expressões regulares (RegEx):
def columns_renamer(name: str) -> str:
name = name.lower()
if re.match(r"data", name):
return "data"
if re.match(r"hora", name):
return "hora"
if re.match(r"precipita[çc][ãa]o", name):
return "precipitacao"
if re.match(r"press[ãa]o atmosf[ée]rica ao n[íi]vel", name):
return "pressao_atmosferica"
if re.match(r"press[ãa]o atmosf[ée]rica m[áa]x", name):
return "pressao_atmosferica_maxima"
if re.match(r"press[ãa]o atmosf[ée]rica m[íi]n", name):
return "pressao_atmosferica_minima"
if re.match(r"radia[çc][ãa]o", name):
return "radiacao"
if re.match(r"temperatura do ar", name):
return "temperatura_ar"
if re.match(r"temperatura do ponto de orvalho", name):
return "temperatura_orvalho"
if re.match(r"temperatura m[áa]x", name):
return "temperatura_maxima"
if re.match(r"temperatura m[íi]n", name):
return "temperatura_minima"
if re.match(r"temperatura orvalho m[áa]x", name):
return "temperatura_orvalho_maxima"
if re.match(r"temperatura orvalho m[íi]n", name):
return "temperatura_orvalho_minima"
if re.match(r"umidade rel\. m[áa]x", name):
return "umidade_relativa_maxima"
if re.match(r"umidade rel\. m[íi]n", name):
return "umidade_relativa_minima"
if re.match(r"umidade relativa do ar", name):
return "umidade_relativa"
if re.match(r"vento, dire[çc][ãa]o", name):
return "vento_direcao"
if re.match(r"vento, rajada", name):
return "vento_rajada"
if re.match(r"vento, velocidade", name):
return "vento_velocidade"
Agora que temos os nomes das colunas padronizados, vamos tratar a data/hora. Os arquivos CSV do INMET-BDMEP têm duas colunas separadas para data e hora. Isso é inconveniente, pois é mais prático ter uma única coluna de data/hora. Além disso existem inconsistências nos horários, que às vezes têm minutos e às vezes não.
As três funções a seguir serão usadas para criar uma única coluna de data/hora:
def convert_dates(dates: pd.Series) -> pd.DataFrame:
dates = dates.str.replace("/", "-")
return dates
def convert_hours(hours: pd.Series) -> pd.DataFrame:
def fix_hour_string(hour: str) -> str:
if re.match(r"^\d{2}\:\d{2}$", hour):
return hour
else:
return hour[:2] + ":00"
hours = hours.apply(fix_hour_string)
return hours
def fix_data_hora(d: pd.DataFrame) -> pd.DataFrame:
d = d.assign(
data_hora=pd.to_datetime(
convert_dates(d["data"]) + " " + convert_hours(d["hora"]),
format="%Y-%m-%d %H:%M",
),
)
d = d.drop(columns=["data", "hora"])
return d
Existe um problema com os dados do INMET-BDMEP que é a presença de linhas vazias. Vamos remover essas linhas vazias para evitar problemas futuros. O código a seguir faz isso:
# Remove empty rows
empty_columns = [
"precipitacao",
"pressao_atmosferica",
"pressao_atmosferica_maxima",
"pressao_atmosferica_minima",
"radiacao",
"temperatura_ar",
"temperatura_orvalho",
"temperatura_maxima",
"temperatura_minima",
"temperatura_orvalho_maxima",
"temperatura_orvalho_minima",
"umidade_relativa_maxima",
"umidade_relativa_minima",
"umidade_relativa",
"vento_direcao",
"vento_rajada",
"vento_velocidade",
]
empty_rows = data[empty_columns].isnull().all(axis=1)
data = data.loc[~empty_rows]
Problema resolvido! (•̀ᴗ•́)و ̑̑
Para finalizar esta seção vamos encapsular o código de leitura e tratamento em funções.
Primeiro uma função para a leitura do arquivo CSV contino no arquivo comprimido.
def read_data(filepath: Path) -> pd.DataFrame:
d = pd.read_csv(
filepath,
sep=";",
decimal=",",
na_values="-9999",
encoding="latin-1",
skiprows=8,
usecols=range(19),
)
d = d.rename(columns=columns_renamer)
# Remove empty rows
empty_columns = [
"precipitacao",
"pressao_atmosferica",
"pressao_atmosferica_maxima",
"pressao_atmosferica_minima",
"radiacao",
"temperatura_ar",
"temperatura_orvalho",
"temperatura_maxima",
"temperatura_minima",
"temperatura_orvalho_maxima",
"temperatura_orvalho_minima",
"umidade_relativa_maxima",
"umidade_relativa_minima",
"umidade_relativa",
"vento_direcao",
"vento_rajada",
"vento_velocidade",
]
empty_rows = d[empty_columns].isnull().all(axis=1)
d = d.loc[~empty_rows]
d = fix_data_hora(d)
return d
Tem um problema com a função acima. Ela não lida com arquivos ZIP.
Criamos, então, a função read_zipfile para a leitura de todos os arquivos contidos no arquivo ZIP. Essa função itera sobre todos os arquivos CSV no arquivo zipado, faz a leitura usando a função read_data e os metadados usando a função read_metadata, e depois junta os dados e os metadados em um único DataFrame.
def read_zipfile(filepath: Path) -> pd.DataFrame:
data = pd.DataFrame()
with zipfile.ZipFile(filepath) as z:
files = [zf for zf in z.infolist() if not zf.is_dir()]
for zf in tqdm(files):
d = read_data(z.open(zf.filename))
meta = read_metadata(z.open(zf.filename))
d = d.assign(**meta)
data = pd.concat((data, d), ignore_index=True)
return data
No final, basta usar essa última função definida (read_zipfile) para fazer a leitura dos arquivos ZIP baixados do site do INMET. (. ❛ ᴗ ❛.)
df = reader.read_zipfile("inmet-bdmep_2023_20240102.zip")
# 100%|████████████████████████████████████████████████████████████████████████████████| 567/567 [01:46<00:00, 5.32it/s]
df
# precipitacao pressao_atmosferica pressao_atmosferica_maxima ... longitude altitude data_fundacao
# 0 0.0 887.7 887.7 ... -47.925833 1160.96 2000-05-07
# 1 0.0 888.1 888.1 ... -47.925833 1160.96 2000-05-07
# 2 0.0 887.8 888.1 ... -47.925833 1160.96 2000-05-07
# 3 0.0 887.8 887.9 ... -47.925833 1160.96 2000-05-07
# 4 0.0 887.6 887.9 ... -47.925833 1160.96 2000-05-07
# ... ... ... ... ... ... ... ...
# 342078 0.0 902.6 903.0 ... -51.215833 963.00 2019-02-15
# 342079 0.0 902.2 902.7 ... -51.215833 963.00 2019-02-15
# 342080 0.2 902.3 902.3 ... -51.215833 963.00 2019-02-15
# 342081 0.0 903.3 903.3 ... -51.215833 963.00 2019-02-15
# 342082 0.0 903.8 903.8 ... -51.215833 963.00 2019-02-15
# [342083 rows x 26 columns]
df.to_csv("inmet-bdmep_2023.csv", index=False) # Salvando o DataFrame em um arquivo CSV
Para finalizar, nada mais satisfatório do que fazer gráficos com os dados que coletamos e tratamos. ヾ(≧▽≦*)o
Nessa parte uso o R com o pacote tidyverse para fazer um gráfico combinando a temperatura horária e a média diária em São Paulo.
library(tidyverse)
dados <- read_csv("inmet-bdmep_2023.csv")
print(names(dados))
# [1] "precipitacao" "pressao_atmosferica"
# [3] "pressao_atmosferica_maxima" "pressao_atmosferica_minima"
# [5] "radiacao" "temperatura_ar"
# [7] "temperatura_orvalho" "temperatura_maxima"
# [9] "temperatura_minima" "temperatura_orvalho_maxima"
# [11] "temperatura_orvalho_minima" "umidade_relativa_maxima"
# [13] "umidade_relativa_minima" "umidade_relativa"
# [15] "vento_direcao" "vento_rajada"
# [17] "vento_velocidade" "data_hora"
# [19] "regiao" "uf"
# [21] "estacao" "codigo_wmo"
# [23] "latitude" "longitude"
# [25] "altitude" "data_fundacao"
print(unique(dados$regiao))
# [1] "CO" "N" "NE" "SE" "S"
print(unique(dados$uf))
# [1] "DF" "GO" "MS" "MT" "AC" "AM" "AP" "AL" "BA" "CE" "MA" "PB" "PE" "PI" "RN"
# [16] "SE" "PA" "RO" "RR" "TO" "ES" "MG" "RJ" "SP" "PR" "RS" "SC"
dados_sp <- dados |> filter(uf == "SP")
# Temperatura horária em São Paulo
dados_sp_h <- dados_sp |>
group_by(data_hora) |>
summarise(
temperatura_ar = mean(temperatura_ar, na.rm = TRUE),
)
# Temperatura média diária em São Paulo
dados_sp_d <- dados_sp |>
group_by(data = floor_date(data_hora, "day")) |>
summarise(
temperatura_ar = mean(temperatura_ar, na.rm = TRUE),
)
# Gráfico combinando temperatura horária e média diária em São Paulo
dados_sp_h |>
ggplot(aes(x = data_hora, y = temperatura_ar)) +
geom_line(
alpha = 0.5,
aes(
color = "Temperatura horária"
)
) +
geom_line(
data = dados_sp_d,
aes(
x = data,
y = temperatura_ar,
color = "Temperatura média diária"
),
linewidth = 1
) +
labs(
x = "Data",
y = "Temperatura (°C)",
title = "Temperatura horária e média diária em São Paulo",
color = "Variável"
) +
theme_minimal() +
theme(legend.position = "top")
ggsave("temperatura_sp.png", width = 16, height = 8, dpi = 300)
Neste texto mostrei como coletar e tratar os dados climáticos do INMET-BDMEP. Os dados coletados são muito úteis para estudos e previsões nas mais variadas áreas. Com os dados tratados, é possível fazer análises e gráficos como o que mostrei no final.
Espero que tenha gostado do texto e que tenha sido útil para você.
Ich habe ein Python-Paket mit den Funktionen erstellt, die ich in diesem Text gezeigt habe. Das Paket ist in meinem Git-Repository verfügbar. Wenn Sie möchten, können Sie das Paket herunterladen und die Funktionen in Ihrem eigenen Code verwenden.
Git-Repository: https://github.com/dankkom/inmet-bdmep-data
(～￣▽￣)～
Das obige ist der detaillierte Inhalt vonErhebung und Verarbeitung von INMET-BDMEP-Klimadaten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Transactionscope-Nutzung
Detaillierte Erläuterung der Verwendung der Oracle-Substr-Funktion
Vue verweist auf JS-Dateien
jquery jeweils
So lesen Sie Dateien und konvertieren sie in Java in Strings
Linux-Befehl zum geplanten Herunterfahren
div-Bildlaufleiste
So implementieren Sie Farbschriftarten in CSS
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
