Python lernen mit ChemTHEATER 05-1

Teil 5 Darstellung der ChemTHEATER-Daten auf einer Karte (Teil 1)

Kap.0 Gesamtdurchfluss

In Teil 5 wird die gemessene Konzentration chemischer Substanzen unter Verwendung der ChemTHEATER-Daten auf einer Karte aufgezeichnet. Es ist sozusagen ein einfaches GIS.
Im ersten Teil wollen wir eine Animation erstellen, indem wir die Datenverarbeitung mit dem Plotten auf der Karte und im zweiten Teil die Ausgabebilddaten verbinden.

Laden der Chap.1-Bibliothek

Wenn Sie Cartopy nicht installiert haben, installieren Sie es im Voraus.

conda install -c conda-forge cartopy

Laden Sie dann die folgende Bibliothek.

%matplotlib inline
import os
import numpy as np
import pandas as pd
import itertools
import matplotlib.pyplot as plt
from cartopy import crs as ccrs

Zunächst importieren wir zunächst die für die Verarbeitung erforderlichen Bibliotheken.
Die erste Zeile ist wie üblich ein Befehl zum Anzeigen der Ausgabe von matplotlib.
In Teil 5 werden die folgenden Bibliotheken verwendet. (Siehe zweite und nachfolgende Zeilen)
Beide sind bereits in Anaconda3 (Windows 64-Bit-Version) installiert.
Dieses Mal werden wir die Karte mit einer Kartonkopie in der Grafik von matplotlib anzeigen.

Lesen von Kap.2 Daten

Nachdem die Bibliothek fertig ist, laden Sie die Daten. Da wir dieses Mal Daten von Meeressäugern verwenden werden, suchen Sie in der Probensuche von ChemTHEATER nach dem Probentyp als "Biotisch - Säugetiere - Meeressäuger". Klicken Sie in den Suchergebnissen auf "Proben exportieren" und "Messdaten exportieren", um die Probenlisten- bzw. Messwertlistendateien herunterzuladen. Speichern Sie die Datei in einem beliebigen Verzeichnis und lesen Sie sie wie folgt aus Ihrem Notizbuch.

data_file = "measureddata_20191002074038.tsv"    #Ändern Sie die in die Variable eingegebene Zeichenfolge in den tsv-Dateinamen Ihrer Messdaten
data = pd.read_csv(data_file, delimiter="\t")
data = data.drop(["ProjectID", "ScientificName", "RegisterDate", "UpdateDate"], axis=1)    #Entfernen Sie doppelte Spalten, wenn Sie später mit Samples verbinden
data

7103 rows × 9 columns

sample_file = "samples_20191002074035.tsv"    #Ändern Sie die in die Variable eingegebene Zeichenfolge in den tsv-Dateinamen Ihrer Beispiele
sample = pd.read_csv(sample_file, delimiter="\t")
sample

202 rows × 66 columns

Kapitel 3 Datenaufbereitung

Bereiten Sie sich darauf vor, den in Kapitel 2 gelesenen DataFrame auf der Karte zeichnen zu können. Kombinieren Sie zunächst Messdaten und Proben und löschen Sie die Spalte N / A.

df = pd.merge(data, sample, on="SampleID")

df = df.dropna(how='all', axis=1)
df

7103 rows × 39 columns

Extrahieren Sie als Nächstes die erforderlichen Daten. Dieses Mal werden wir Daten zu vier Arten chemischer Substanzen (ΣPCBs, ΣDDTs, ΣCHLs, ΣHCHs) mit der Einheit [ng / g Lipid] verarbeiten.

data_lipid = df[df["Unit"] == "ng/g lipid"]
data_lipid = data_lipid[(data_lipid["ChemicalName"] == "ΣPCBs") | (data_lipid["ChemicalName"] == "ΣDDTs") |
                        (data_lipid["ChemicalName"] == "ΣCHLs") | (data_lipid["ChemicalName"] == "ΣHCHs")]

Damit ist die Extraktion der erforderlichen Daten abgeschlossen. Zur Bestätigung erhalten Sie eine Liste der in diesem Datensatz enthaltenen Arten und chemischen Namen.

lipid_species = data_lipid["ScientificName"].unique()
lipid_chemicals = data_lipid["ChemicalName"].unique()

lipid_species, lipid_chemicals

(array(['Peponocephala electra', 'Neophocaena phocaenoides',
        'Sousa chinensis', 'Stenella coeruleoalba'], dtype=object),
 array(['ΣPCBs', 'ΣDDTs', 'ΣCHLs', 'ΣHCHs'], dtype=object))

Auch hier wird DataFrame / data_lipid im CSV-Format ausgegeben, damit im zweiten Teil dieselben Daten verwendet werden können. Die CSV-Ausgabe verwendet die to_csv-Methode von Pandas.

data_lipid.to_csv("data.csv")

Kap.4 Plot auf Karte

Abschnitt 4-1 Basisdiagramm

Als nächstes werden wir auf der Karte zeichnen, was der Hauptteil dieser Zeit ist. Lassen Sie uns zunächst sorgfältig prüfen, wie eine Karte erstellt wird.
Da der Graph dieses Mal auf der Karte ausgegeben wird, wird die Karte zuerst ausgegeben. In Python können Sie mit cartopy eine Karte auf matplotlib ausgeben.

ax = plt.axes(projection=ccrs.PlateCarree())
ax.coastlines()
plt.show()

Überprüfen Sie als Nächstes den Greifer, der der Karte überlagert ist. Dieses Mal werden die Punkte im zweidimensionalen Raum von Breite und Länge als Messpunkte aufgezeichnet, sodass die Daten als Streukarte gezeichnet werden.
Sortieren Sie vor dem Zeichnen die Daten für jede in data_lipid enthaltene Art.

df_0 = data_lipid[(data_lipid["ChemicalName"] == "ΣPCBs") & (data_lipid["ScientificName"] == lipid_species[0])]    #Kazuhagondous ΣPCBs
df_1 = data_lipid[(data_lipid["ChemicalName"] == "ΣPCBs") & (data_lipid["ScientificName"] == lipid_species[1])]    #Sunameris ΣPCBs
df_2 = data_lipid[(data_lipid["ChemicalName"] == "ΣPCBs") & (data_lipid["ScientificName"] == lipid_species[2])]    #Sinaus Iro Dolphin ΣPCBs
df_3 = data_lipid[(data_lipid["ChemicalName"] == "ΣPCBs") & (data_lipid["ScientificName"] == lipid_species[3])]    #Suji Dolphin ΣPCBs

Wenn die Daten weiter unterteilt sind, versuchen Sie, sie in einem Streudiagramm aufzuwecken. Die Diagrammzeichnung von matplotlib kann darüber gelegt werden, sodass Sie Bilder einzeln hinzufügen können.

fig = plt.figure()
ax = plt.axes()

#CollectionLongitudeFrom,Extrahieren Sie Längen- und Breitengradinformationen aus CollectionLatitudeFrom
ax.scatter(x = np.array(df_0["CollectionLongitudeFrom"]), y = np.array(df_0["CollectionLatitudeFrom"]), c = "red", alpha=0.5)
ax.scatter(x = np.array(df_1["CollectionLongitudeFrom"]), y = np.array(df_1["CollectionLatitudeFrom"]), c = "blue", alpha=0.5)
ax.scatter(x = np.array(df_2["CollectionLongitudeFrom"]), y = np.array(df_2["CollectionLatitudeFrom"]), c = "yellow", alpha=0.5)
ax.scatter(x = np.array(df_3["CollectionLongitudeFrom"]), y = np.array(df_3["CollectionLatitudeFrom"]), c = "green", alpha=0.5)
plt.show()

Abschnitt 4-2 Streudiagramm + zylindrische Projektion mit normalem Abstand

Nachdem wir die Basisfigur gezeichnet haben, zeichnen wir sie, indem wir sie überlagern.

fig = plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.coastlines()
ax.scatter(x = np.array(df_0["CollectionLongitudeFrom"]), y = np.array(df_0["CollectionLatitudeFrom"]), c = "red", alpha=0.5)
ax.scatter(x = np.array(df_1["CollectionLongitudeFrom"]), y = np.array(df_1["CollectionLatitudeFrom"]), c = "blue", alpha=0.5)
ax.scatter(x = np.array(df_2["CollectionLongitudeFrom"]), y = np.array(df_2["CollectionLatitudeFrom"]), c = "yellow", alpha=0.5)
ax.scatter(x = np.array(df_3["CollectionLongitudeFrom"]), y = np.array(df_3["CollectionLatitudeFrom"]), c = "green", alpha=0.5)
plt.show()

Abschnitt 4-3 Verbesserung von Abschnitt 4-2

Ich konnte vorerst mit Abschnitt 4-2 ausgeben. Im aktuellen Status wird der Bereich der Karte jedoch automatisch festgelegt. Dies wird nur automatisch verarbeitet, sodass der gesamte Bereich, in dem die Daten vorhanden sind, automatisch verarbeitet wird, sodass sich der Bereich abhängig von den zu verarbeitenden Daten ändert. Hier ist die Karte in einem geeigneten Bereich fixiert.

Mit den Methoden set_xlim und set_ylim von matplotlib kann der Bereich der X-Achsenrichtung und der Y-Achsenrichtung des zu zeichnenden Graphen bestimmt werden.

fig = plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.coastlines()
ax.scatter(x = np.array(df_0["CollectionLongitudeFrom"]), y = np.array(df_0["CollectionLatitudeFrom"]), c = "red", alpha=0.5)
ax.scatter(x = np.array(df_1["CollectionLongitudeFrom"]), y = np.array(df_1["CollectionLatitudeFrom"]), c = "blue", alpha=0.5)
ax.scatter(x = np.array(df_2["CollectionLongitudeFrom"]), y = np.array(df_2["CollectionLatitudeFrom"]), c = "yellow", alpha=0.5)
ax.scatter(x = np.array(df_3["CollectionLongitudeFrom"]), y = np.array(df_3["CollectionLatitudeFrom"]), c = "green", alpha=0.5)
ax.set_xlim(90,180)    #Bereich in X-Achsenrichtung (Längsrichtung) zum Zeichnen
ax.set_ylim(15, 60)    #Bereich in Richtung der Y-Achse (Breitengrad) zum Zeichnen
ax.set_title("ΣPCBs")
plt.show()

Kap.5 Ausgabe in einem Blatt

Wie Sie in

Kapitel 3 sehen können, enthält dieser DataFrame Daten von 4 Arten chemischer Substanzen. Geben Sie sie also in Form von 4 davon in einem Blatt aus. </ p>

Wie in Kapitel 4 sortieren wir zunächst die Daten für jede chemische Substanz. Da es jedoch insgesamt 16 Kombinationen gibt (jeweils 4 Arten von biologischen und chemischen Substanzen), werden wir sie hier auflisten. Insgesamt erfolgt dies beim Zeichnen nacheinander. Zu diesem Zeitpunkt ist es erforderlich, jede Kombination zu generieren (z. B. ΣPCBs von Snameri). Verwenden Sie daher die Funktion von Pythons Iterator ^{1 , um direkt zu produzieren. Wir werden nach 2 fragen. Mit anderen Worten wird das direkte Produkt aus der Liste der chemischen Substanzen (lipid_chemicals) und der Liste der Artennamen (lipid_species) erhalten, und alle 16 Kombinationsmuster werden abgeleitet.}

df_list = []
for k1, k2 in itertools.product(lipid_chemicals, lipid_species):
    df_list.append(data_lipid[(data_lipid["ChemicalName"] == k1) & (data_lipid["ScientificName"] == k2)])    #Extrahieren Sie Daten für jede Kombination

ax = [0]*4
fig = plt.figure(figsize=(16, 9))
for i in range(4): 
    ax[i] = fig.add_subplot(2, 2, i+1, projection=ccrs.PlateCarree())    #Bereich zum Zeichnen des Diagramms hinzugefügt
    ax[i].coastlines()
    ax[i].scatter(x = np.array(df_list[4*i+0]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+0]["CollectionLatitudeFrom"]),
                  c = "red", alpha=0.5)    #Kazuhagondou
    ax[i].scatter(x = np.array(df_list[4*i+1]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+1]["CollectionLatitudeFrom"]), 
                  c = "blue", alpha=0.5)    #Snameri
    ax[i].scatter(x = np.array(df_list[4*i+2]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+2]["CollectionLatitudeFrom"]), 
                  c = "yellow", alpha=0.5)    #Sinaus Iro Dolphin
    ax[i].scatter(x = np.array(df_list[4*i+3]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+3]["CollectionLatitudeFrom"]), 
                  c = "green", alpha=0.5)    #Suji-Delphin
    ax[i].set_xlim(90,180)
    ax[i].set_ylim(15, 60)
    ax[i].set_title(lipid_chemicals[i])
plt.show()

Dies spiegelt nur die Messpunkte wider. Zeichnen Sie daher auch die gemessenen Werte auf der Karte. Lassen Sie es uns im Radius jedes Sprühpunkts reflektieren. Sie müssen lediglich die Daten in der Spalte MeasuredValue dem Parameter s der Streumethode zuweisen, mit der das Streudiagramm gezeichnet wird.

fig = plt.figure(figsize=(16, 9))
for i in range(4): 
    ax[i] = fig.add_subplot(2, 2, i+1, projection=ccrs.PlateCarree())
    ax[i].coastlines()
    ax[i].scatter(x = np.array(df_list[4*i+0]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+0]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+0]["MeasuredValue"]), c = "red", alpha=0.5)
    ax[i].scatter(x = np.array(df_list[4*i+1]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+1]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+1]["MeasuredValue"]), c = "blue", alpha=0.5)
    ax[i].scatter(x = np.array(df_list[4*i+2]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+2]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+2]["MeasuredValue"]), c = "yellow", alpha=0.5)
    ax[i].scatter(x = np.array(df_list[4*i+3]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+3]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+3]["MeasuredValue"]), c = "green", alpha=0.5)
    ax[i].set_xlim(90,180)
    ax[i].set_ylim(15, 60)
    plt.title(lipid_chemicals[i])
plt.show()

Wenn der Wert von MeasuredValue durch den Radius des Streupunkts ersetzt wird, wird der Kreis des Diagramms von ΣDDTs groß und alle überlappen sich. Passen Sie ihn daher so an, dass der Radius klein ist. Hier wird die Größe einheitlich auf 1/10 eingestellt.

fig = plt.figure(figsize=(16, 9))
rate = [10,10,10,10]    #Variable Anzeigeskala
for i in range(4): 
    ax[i] = fig.add_subplot(2, 2, i+1, projection=ccrs.PlateCarree())
    ax[i].coastlines()
    ax[i].scatter(x = np.array(df_list[4*i+0]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+0]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+0]["MeasuredValue"])/rate[i], c = "red", alpha=0.3)
    ax[i].scatter(x = np.array(df_list[4*i+1]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+1]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+1]["MeasuredValue"])/rate[i], c = "blue", alpha=0.3)
    ax[i].scatter(x = np.array(df_list[4*i+2]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+2]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+2]["MeasuredValue"])/rate[i], c = "yellow", alpha=0.3)
    ax[i].scatter(x = np.array(df_list[4*i+3]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+3]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+3]["MeasuredValue"])/rate[i], c = "green", alpha=0.3)
    ax[i].set_xlim(90,180)
    ax[i].set_ylim(15, 60)
    plt.title(lipid_chemicals[i])
plt.show()

Jetzt können Sie die Messergebnisse auf der Karte darstellen. Da jedoch alle Daten überlappend angezeigt werden, ist es sehr schwierig zu sehen, und in dieser Abbildung sind Änderungen im Zeitverlauf nicht zu sehen. Im zweiten Teil werden wir animieren, diese Probleme zu lösen.

Fußnote

^{1 Ein Iterator ist ein Mechanismus, der wiederholt auf das nächste Element mit einem Typ zugreift, der Daten wie eine Liste sammelt.}

^{2 Das direkte Produkt besteht darin, eine neue Menge zu erstellen, indem aus jeder Menge ein Element extrahiert und eine Menge erstellt wird, wie in der folgenden Abbildung gezeigt. Auch mit dem kartesischen Produkt.}