Visualización de datos (5) Hacer un diagrama de dispersión de terremotos global: formato JSON
Descargue un conjunto de datos de todos los terremotos que ocurrieron en todo el mundo en un mes y haga un diagrama de dispersión que muestre la ubicación y la magnitud de estos terremotos. Estos datos se almacenan en formato JSON, así que use el módulo json para procesarlos. Plotly proporciona herramientas para dibujar mapas basados en datos de ubicación, lo cual es adecuado para principiantes. Lo usará para visualizar e indicar la distribución global de los terremotos.
1. Datos del terremoto
Copie el archivo eq_data_1_day_m1.json en la carpeta donde se almacena el programa de este capítulo. Los terremotos se miden en la escala de Richter, y este archivo registra (al momento de escribir esta sección) todos los terremotos de magnitud 1 o mayor que han ocurrido en todo el mundo en las últimas 24 horas.
2. Ver datos JSON
Si abre el archivo eq_data_1_day_m1.json, encontrará que su contenido es denso y difícil de leer:
{
"type":"FeatureCollection","metadata":{
"generated":1550361461000,...
{
"type":"Feature","properties":{
"mag":1.2,"place":"11km NNE of Nor...
{
"type":"Feature","properties":{
"mag":4.3,"place":"69km NNW of Ayn...
{
"type":"Feature","properties":{
"mag":3.6,"place":"126km SSE of Co...
{
"type":"Feature","properties":{
"mag":2.1,"place":"21km NNW of Teh...
{
"type":"Feature","properties":{
"mag":4,"place":"57km SSW of Kakto...
--snip--
Estos datos son aptos para ser leídos por máquinas, no por humanos. Sin embargo, como puede ver, este archivo contiene algunos diccionarios y alguna información que nos interesa, como la magnitud y la ubicación.
El módulo json proporciona varias herramientas para explorar y manipular datos JSON, algunas de las cuales ayudan a reformatear este archivo, lo que nos permite ver los datos sin procesar con mayor claridad y luego decidir cómo procesarlos mediante programación.
Carguemos estos datos primero y mostrémoslos de una manera legible por humanos. Este archivo de datos es bastante largo, así que en lugar de imprimirlo, escriba los datos en otro archivo, luego ábralo y navegue fácilmente a través de los datos: eq_explore_data.py
import json
# 探索数据的结构。
filename = 'data/eq_data_1_day_m1.json'
with open(filename) as f:
❶ all_eq_data = json.load(f)
❷ readable_file = 'data/readable_eq_data.json'
with open(readable_file, 'w') as f:
❸ json.dump(all_eq_data, f, indent=4)
Primero importe el módulo json para que los datos en el archivo se carguen y almacenen correctamente en all_eq_data (ver ❶). La función json.load() convierte los datos a un formato que Python puede manejar, aquí hay un diccionario enorme. En ❷, cree un archivo en el que escribir estos datos en un formato legible por humanos. La función json.dump() acepta un objeto de datos JSON y un objeto de archivo, y escribe los datos en este archivo (ver ❸). El parámetro sangría=4 le dice a dump() que formatee los datos usando una cantidad de sangría que coincida con la estructura de datos.
Si ahora busca en los datos del directorio y abre el archivo readable_eq_data.json en él, encontrará que el comienzo se ve así: readable_eq_data.json
{
"type": "FeatureCollection",
❶ "metadata": {
"generated": 1550361461000,
"url": "https://earthquake.usgs.gov/earthquakes/.../1.0_day.geojson",
"title": "USGS Magnitude 1.0+ Earthquakes, Past Day",
"status": 200,
"api": "1.7.0",
"count": 158
},
❷ "features": [
--snip--
El comienzo de este archivo es un fragmento con la clave "metadatos" (ver ❶), que indica cuándo se generó el archivo de datos y dónde se puede encontrar en Internet. También contiene títulos legibles por humanos y cuántos terremotos se registraron en el archivo: En las últimas 24 horas, hubo 158 terremotos.
La estructura de este archivo geoJSON es adecuada para almacenar datos basados en la ubicación. Los datos se almacenan en una lista asociada con las "características" clave (ver ❷). Este archivo contiene datos de terremotos, por lo que cada elemento de la lista corresponde a un terremoto. Esta estructura puede ser un poco confusa, pero es útil, ya que permite a los geólogos almacenar cualquier cantidad de información sobre cada terremoto en un diccionario y colocar esos diccionarios en una lista grande.
Echemos un vistazo al diccionario que representa un terremoto específico: readable_eq_data.json
--snip--
{
"type": "Feature",
❶ "properties": {
"mag": 0.96,
--snip--
❷ "title": "M 1.0 - 8km NE of Aguanga, CA"
},
❸ "geometry": {
"type": "Point",
"coordinates": [
❹ -116.7941667,
❺ 33.4863333,
3.22
]
},
"id": "ci37532978"
},
Las "propiedades" clave están asociadas con una gran cantidad de información relacionada con un terremoto en particular (ver ❶). Nos preocupa principalmente la magnitud del terremoto asociado con la clave "mag" y el título del terremoto, ya que este último brinda una buena descripción general de la magnitud y la ubicación del terremoto (ver ❷).
La "geometría" clave indica dónde ocurrió el terremoto (ver ❸), y necesitamos marcar el terremoto en el diagrama de dispersión en base a esta información. En la lista asociada a la clave "coordenadas" puede encontrar la longitud (ver ❹) y latitud (ver ❺) donde ocurrió el terremoto.
Este archivo tiene más niveles de anidamiento que el código que hemos escrito. Si esto lo confunde, no se preocupe, Python se encargará de la mayor parte del trabajo complicado por usted. Solo trataremos con uno o dos niveles de anidamiento a la vez. Comenzaremos extrayendo un diccionario para cada terremoto ocurrido en las últimas 24 horas.
Tenga en cuenta que cuando hablamos de ubicación, generalmente hablamos primero de latitud y luego de longitud. La razón de este hábito puede ser que los humanos descubrieron primero la latitud, y mucho antes que el concepto de longitud. Sin embargo, muchos marcos geológicos listan las longitudes primero y las latitudes al final porque esto es consistente con las convenciones matemáticas [ilustrado]. El formato geoJSON sigue la convención de (longitud, latitud), pero es importante tener en cuenta las convenciones que sigue al usar otros marcos.
3. Crea una lista de terremotos
Primero, cree una lista con información diversa sobre todos los terremotos: eq_explore_data.py
import json
# 探索数据的结构。
filename = 'data/eq_data_1_day_m1.json'
with open(filename) as f:
all_eq_data = json.load(f)
all_eq_dicts = all_eq_data['features']
print(len(all_eq_dicts))
Extraemos los datos asociados con las 'características' clave y los almacenamos en all_eq_dicts. Sabemos que este archivo registra 158 terremotos. El siguiente resultado muestra que extrajimos todos los terremotos registrados en este archivo:
158
Tenga en cuenta que el código que escribimos es muy corto. El archivo readable_eq_data.json bien formado contiene más de 6000 líneas, pero con solo unas pocas líneas de código, todos los datos se pueden leer y almacenar en una lista de Python. Lo siguiente extraerá las magnitudes de todos los terremotos.
4. Extraer magnitud
Ahora que tenemos una lista de todos los datos de terremotos, podemos iterar a través de la lista para extraer los datos que necesitamos. Extraigamos la magnitud de cada terremoto: eq_explore_data.py
--snip--
all_eq_dicts = all_eq_data['features']
❶ mags = []
for eq_dict in all_eq_dicts:
❷ mag = eq_dict['properties']['mag']
mags.append(mag)
print(mags[:10])
Creamos una lista vacía para almacenar las magnitudes de los terremotos e iteramos sobre la lista all_eq_dicts (ver ❶). La magnitud de cada terremoto se almacena bajo la clave 'mag' en la sección 'propiedades' del diccionario correspondiente (ver ❷). A su vez, asignamos la magnitud del terremoto a la variable mag y agregamos esta variable al final de la lista mags.
Para asegurarse de que los datos extraídos sean correctos, imprima las magnitudes de los primeros 10 terremotos:
[0.96, 1.2, 4.3, 3.6, 2.1, 4, 1.06, 2.3, 4.9, 1.8]
A continuación, extraeremos la información de ubicación de cada terremoto y luego podremos dibujar el diagrama de dispersión del terremoto.
5. Extraer datos de ubicación
Los datos de posición se almacenan bajo la tecla "geometría". En el diccionario asociado a la clave "geometría", existe una clave "coordenadas", que está asociada a una lista, y los dos primeros valores de la lista son longitud y latitud. A continuación se muestra cómo extraer datos de ubicación: eq_explore_data.py
--snip--
all_eq_dicts = all_eq_data['features']
mags, titles, lons, lats = [], [], [], []
for eq_dict in all_eq_dicts:
mag = eq_dict['properties']['mag']
❶ title = eq_dict['properties']['title']
❷ lon = eq_dict['geometry']['coordinates'][0]
lat = eq_dict['geometry']['coordinates'][1]
mags.append(mag)
titles.append(title)
lons.append(lon)
lats.append(lat)
print(mags[:10])
print(titles[:2])
print(lons[:5])
print(lats[:5])
Creamos una lista titles para almacenar el título de la ubicación, para extraer el valor correspondiente a la clave 'title' en el diccionario 'properties' (ver ❶), y una lista para almacenar la longitud y la latitud. El código eq_dict['geometry'] accede al diccionario asociado con la tecla "geometry" (ver ❷). La segunda clave ('coordenadas') obtiene la lista asociada con las "coordenadas", mientras que el índice 0 obtiene el primer valor de esa lista, la longitud de donde ocurrió el terremoto.
Al imprimir las primeras 5 longitudes y latitudes, la salida muestra que los datos extraídos son correctos:
[0.96, 1.2, 4.3, 3.6, 2.1, 4, 1.06, 2.3, 4.9, 1.8]
['M 1.0 - 8km NE of Aguanga, CA', 'M 1.2 - 11km NNE of North Nenana, Alaska']
[-116.7941667, -148.9865, -74.2343, -161.6801, -118.5316667]
[33.4863333, 64.6673, -12.1025, 54.2232, 35.3098333]
6. Dibujar diagrama de dispersión de magnitud
Con los datos extraídos anteriormente, se puede dibujar la visualización. Comenzaremos implementando un diagrama de dispersión de magnitud simple y, después de asegurarnos de mostrar la información correcta, centraremos nuestra atención en el estilo y la apariencia. El código para dibujar el diagrama de dispersión inicial es el siguiente: eq_world_map.py
❶ import plotly.express as px
fig = px.scatter(
x=lons,
y=lats,
labels={
"x": "经度", "y": "纬度"},
range_x=[-200, 200],
range_y=[-90, 90],
width=800,
height=800,
title="全球地震散点图",
❷ )
❸ fig.write_html("global_earthquakes.html")
❹ fig.show()
Primero, importe plotly.express, indicado por el alias px. Plotly Express es una interfaz de alto nivel de Plotly, que es fácil de usar y tiene una sintaxis similar a Matplotlib (ver ❶). Luego, llame a la función px.scatter para configurar los parámetros para crear una instancia de fig y establezca el eje [ilustración] en longitud [el rango es [-200, 200] (expanda el espacio para mostrar completamente los puntos de dispersión del terremoto alrededor de 180° longitud este-oeste)], [Ilustración] El eje es la latitud [el rango es [-90,90]], establezca el ancho y la altura de la visualización del diagrama de dispersión en 800 píxeles y establezca el título en "Gráfico de dispersión de terremotos global " (ver ❷).
En solo 14 líneas de código, se configura un diagrama de dispersión simple, que devuelve un objeto fig. El método fig.write_html puede guardar la visualización como un archivo html. Busque el archivo global_earthquakes.html en la carpeta y ábralo con un navegador (vea ❸). Además, si usa Jupyter Notebook, puede usar directamente el método fig.show para mostrar el diagrama de dispersión directamente en la celda del cuaderno (ver ❹).
El efecto local se muestra en la siguiente figura:
Este diagrama de dispersión se puede modificar mucho para que sea más significativo y comprensible. Hagamos algunos de estos cambios.
7. Otra forma de especificar los datos del gráfico
Antes de configurar este gráfico, echemos un vistazo a una forma ligeramente diferente de especificar datos para un gráfico de Plotly. Actualmente, los datos de latitud y longitud se configuran manualmente:
--snip--
x=lons,
y=lats,
labels={
"x": "经度", "y": "纬度"},
--snip--
Esta es una de las formas más fáciles de definir datos para gráficos en Plotly Express, pero no es óptima para la manipulación de datos. Aquí hay otra forma equivalente de definir datos para el gráfico, utilizando la herramienta de análisis de datos pandas. Primero cree un DataFrame para encapsular los datos requeridos:
import pandas as pd
data = pd.DataFrame(
data=zip(lons, lats, titles, mags), columns=["经度", "纬度", "位置", "震级"]
)
data.head()
Luego, el método de configuración de parámetros se puede cambiar a:
--snip--
data,
x="经度",
y="纬度",
--snip--
En este enfoque, toda la información sobre los datos se coloca en un diccionario en forma de pares clave-valor. Si estos códigos se utilizan en eq_plot.py, los gráficos resultantes son los mismos. Este formato permite un análisis de datos fluido y una personalización más sencilla que el formato anterior.