Ich habe versucht zusammenzufassen, wie man Pandas von Python benutzt
Einführung
Dieses Mal werde ich zusammenfassen, wie man Pandas benutzt.
Viele Leute haben zusammengefasst, wie man Pandas benutzt, also ist es vielleicht nicht neu, aber ich würde es begrüßen, wenn Sie mit mir auskommen könnten.
Im vorherigen Artikel wurde die Verwendung von Numpy zusammengefasst. Überprüfen Sie diese, wenn Sie möchten.
Ich habe Pythons Numpy zusammengefasst
Seriengenerierung
Sie können eine Serie erstellen, indem Sie die folgenden Schritte ausführen. Serie ist ein Array mit einem angehängten Index.
import numpy as np
import pandas as pd
series = pd.Series(data=[1, 2, 3, 4, 5], index=['A', 'B', 'C', 'D', 'E'])
print(series)
A 1 B 2 C 3 D 4 E 5 dtype: int64
Es kann auch in Kombination mit numpy generiert werden.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series)
A 0 B 1 C 2 D 3 E 4 dtype: int64
Daten aus Serien extrahieren
Serien können indiziert werden, um Daten abzurufen. Es liegt in der Nähe eines Wörterbuchtyps.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series['A'])
0
Sie können auch Slices verwenden.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series['A':'D'])
A 0 B 1 C 2 D 3 dtype: int64
Im Sinne eines normalen Slice sollten die Daten bis C, die vor D liegen, extrahiert werden. Im Fall von Series werden sie jedoch in den vom Index angegebenen Bereich extrahiert.
Mit loc
Beim Abrufen von Daten durch Angabe eines Index auf diese Weise wird jedoch üblicherweise die loc-Methode verwendet.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series.loc['A':'D'])
A 0 B 1 C 2 D 3 dtype: int64
Sie können zwei Indizes angeben, ohne Slices zu verwenden.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series.loc[['A', 'D']])
A 0 D 3 dtype: int64
Mit iloc
Anstatt den Serienindex zu verwenden, können Sie auch den Index der von Anfang an zugewiesenen Nummer angeben und abrufen.
series = pd.Series(data=np.arange(5), index=['A', 'B', 'C', 'D', 'E'])
print(series.iloc[[0]])
A 0 dtype: int64
DataFrame-Generierung
Sie können einen DataFrame wie folgt generieren.
df = pd.DataFrame(data=[[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=['A', 'B', 'C'], columns=['A1', 'A2', 'A3'])
print(df)
A1 A2 A3 A 1 2 3 B 4 5 6 C 7 8 9
Auf diese Weise besteht der DataFrame aus zweidimensionalen Daten, wobei "Index" und "Spalten" angegeben sind.
Beim maschinellen Lernen repräsentiert der Index den Datentyp und die Spalten das Merkmal der Daten.
Datei lesen
Dies ist eine sehr häufige Aufgabe, da Pandas Dateien grundsätzlich lesen und verwenden.
Laden Sie hier die CSV-Datei, die Sie entsprechend erstellt haben. Die folgenden Daten.
Lass es uns lesen.
df = pd.read_csv('train.csv')
print(df)
Das Folgende ist das Ausführungsergebnis.
Es war schwer zu sehen, selbst wenn ich es kopierte, also drückte ich es.
Ich wollte takash und kenta indizieren, aber sie sind standardmäßig nicht indiziert.
Auf diese Weise muss beim Lesen von Daten mit einem Index "index_col" angegeben werden. In diesem Beispiel werden die Daten ganz links als Index behandelt. Setzen Sie also "index_col = 0".
df = pd.read_csv('train.csv', index_col=0)
print(df)
Standardmäßig wird die allererste Zeile als Kopfzeile behandelt. Wenn Sie nicht die allererste Zeile als Überschrift angeben möchten, geben Sie "header = None" an.
df = pd.read_csv('train.csv', header=None)
print(df)
Bestätigung des Dateninhalts
Überprüfen Sie die Form
Lassen Sie uns die Form der Daten überprüfen. Wie Numpy usw. speichert die Formvariable die Bemaßungsdaten.
df = pd.read_csv('train.csv', index_col=0)
print(df.shape)
(3, 3)
Statistiken überprüfen`
Sie können die Statistik der Daten mithilfe der Beschreibungsmethode überprüfen.
df = pd.read_csv('train.csv', index_col=0)
print(df.describe())
Auf diese Weise können Sie die Anzahl der Daten, den Mittelwert, die Standardabweichung, das Minimum, das Maximum und den Quadranten für jede Spalte ermitteln.
Überprüfen Sie die Anzahl und Art der Daten
Sie können dies mit dem folgenden Code überprüfen.
df = pd.read_csv('train.csv', index_col=0)
print(df.info())
<class 'pandas.core.frame.DataFrame'> Index: 3 entries, takash to yoko Data columns (total 3 columns): math 3 non-null int64 Engrish 3 non-null int64 society 3 non-null int64 dtypes: int64(3) memory usage: 96.0+ bytes None
Sie können die Daten so überprüfen. Es ist kein Kommentar erforderlich.
Daten ohne Duplizierung prüfen
Wenn Sie die Nunique-Methode verwenden, können Sie die Daten für jede von Ihnen geschriebene Spalte ohne Duplizierung überprüfen.
df = pd.read_csv('train.csv', index_col=0)
print(df.nunique())
＞math 3 Engrish 3 society 3 dtype: int64
Dieses Mal gab es keine Duplizierung, daher war das Ergebnis wie oben.
Bestätigung des Zeilennamens und des Spaltennamens
Die Indexvariable speichert den Index und die Spaltenvariable speichert die Spaltennamen. Lass uns nachsehen.
df = pd.read_csv('train.csv', index_col=0)
print(df.index)
print(df.columns)
Index(['takash', 'kenta', 'yoko'], dtype='object') Index(['math', 'Engrish', 'society'], dtype='object')
Überprüfen Sie die Summe der fehlenden Werte
Sie können die Position der fehlenden Werte in jeder Spalte mit dem folgenden Code sehen.
df = pd.read_csv('train.csv', index_col=0)
print(df.isnull())
math Engrish society takash False False False kenta False False False yoko False False False
Da jeder Wert kein fehlender Wert ist, wird False zurückgegeben.
Lassen Sie uns nun die Summe der fehlenden Werte mit dem folgenden Code erhalten.
df = pd.read_csv('train.csv', index_col=0)
print(df.isnull().sum())
math 0 Engrish 0 society 0 dtype: int64
Auswahl und Extraktion von DataFrame-Daten
Extrahieren wir nun die Daten aus dem DataFrame. Vorerst habe ich den folgenden DataFrame generiert.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df)
np.random.seed (0) ermöglicht es Ihnen, die von np.random.rand generierten Zufallszahlen zu korrigieren. Da ich den Code jedoch jedes Mal ausführe, ändern sich die Zufallszahlen jedes Mal.
np.random.rand ist der Code, der Zufallszahlen von 0 bis 1 generiert.
Lassen Sie uns Columuns mit dem folgenden Code auswählen und extrahieren.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df['A1'])
A 0.165899 B 0.144862 C 0.974517 D 0.144633 E 0.806085 Name: A1, dtype: float64
Auf diese Weise konnte ich die Spalten extrahieren.
Mit der loc-Methode können Sie einen Index für die Extraktion angeben.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df.loc['A'])
A1 0.687867 A2 0.243104 A3 0.568371 A4 0.125892 A5 0.749777 Name: A, dtype: float64
Ich habe geschrieben, dass es durch Angabe des Index extrahiert wird, aber die Spezifikationsmethode mit der loc-Methode in DataFrame ist der Spezifikation des zweidimensionalen Arrays von numpy ziemlich ähnlich.
Sie können loc [row: column] angeben.
Mal sehen, wie man es unten benutzt.
print(df.loc[:, 'A1'])
A 0.108650 B 0.819086 C 0.250341 D 0.950634 E 0.852035 Name: A1, dtype: float64
Da : im Zeilenteil angegeben ist, bedeutet dies, dass alle Zeilen angegeben sind, und da A1 in der Spalte angegeben ist, werden die Spalten von A1 extrahiert.
print(df.loc['C', ['A2', 'A4']])
A2 0.129296 A4 0.367573 Name: C, dtype: float64
Auf diese Weise können Sie die Daten in den Zeilen A2 und A4 extrahieren.
Nach Bedingung auswählen
Lassen Sie uns Bedingungen aus dem DataFrame auswählen und extrahieren. Lassen Sie uns das Verhalten von df> 0.5 mit dem folgenden Code überprüfen.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df)
print(df > 0.5)
Auf diese Weise wird True gespeichert, wenn der Wert im DataFrame die Bedingung erfüllt, und False wird gespeichert, wenn die Bedingung nicht erfüllt ist.
Auf diese Weise können Sie Werte ausschließen, die die unten gezeigten Bedingungen nicht erfüllen.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df > 0.5)
print(df[df > 0.5])
Außerdem können Sie nur die Zeilen extrahieren, die den bestimmten Spalten entsprechen, indem Sie die folgenden Schritte ausführen.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df)
print(df[df['A3'] > 0.5])
Sie können Bedingungen auch mit & hinzufügen, wie unten gezeigt.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
print(df)
print(df[(df['A3'] > 0.2) & (df['A3'] < 0.6)])
Hinzufügen / Entfernen von Daten in DataFrame
Sie können Spalten hinzufügen, indem Sie die folgenden Schritte ausführen.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
df['new'] = np.arange(5)
print(df)
Sie können eine Spalte löschen, indem Sie den Spaltennamen angeben.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
df = df.drop(columns=['A1', 'A3'])
print(df)
Sie können eine Zeile löschen, indem Sie den Zeilennamen angeben.
df = pd.DataFrame(data=np.random.rand(5, 5),
index=['A', 'B', 'C', 'D', 'E'],
columns=('A1', 'A2', 'A3', 'A4', 'A5'))
np.random.seed(0)
df = df.drop(index=['A', 'D'])
print(df)
Umgang mit fehlenden Werten
Bereiten wir die Daten wie folgt vor.
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, 17, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
print(df)
Mit der dropna-Methode können Sie die Zeile löschen, die den fehlenden Wert enthält.
df = df.dropna()
print(df)
Columns: [A1, A2, A3, A4, A5] Index: []
Dieses Mal haben alle Zeilen fehlende Werte, sodass sie alle verschwunden sind. Auf diese Weise können Daten nur schwer erhalten bleiben, wenn Sie strenge Einschränkungen anwenden.
Entfernen Sie fehlende Werte in einer bestimmten Spalte
Sie können die fehlenden Werte für eine bestimmte Spalte folgendermaßen entfernen:
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, 17, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
df = df[df['A3'].isnull() == False]
print(df)
Wenn Sie "isnull" verwenden, wird True zurückgegeben, wenn die Daten nan sind, und False wird zurückgegeben, wenn die Daten nicht nan sind. Daher können Sie nur Zeilen löschen, die fehlende Werte in A3 enthalten, wie oben gezeigt.
Löschen Sie, indem Sie eine Zahl angeben, bei der es sich nicht um einen fehlenden Wert handelt
Argument von dropna Durch Angabe des Arguments von thresh können andere Zeilen als die Zeilen gelöscht werden, deren Werte nicht mehr als die im Argument angegebene Zahl enthalten.
Zum Beispiel löscht "thresh = 4" Zeilen, die nicht mehr als 4 nicht fehlende Werte haben.
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, np.nan, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
df = df.dropna(thresh=4)
Wenn Sie "Achse = 1" setzen, können Sie dasselbe für die Spalte tun.
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, np.nan, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
df = df.dropna(thresh=4, axis=1)
print(df)
Ersetzen Sie den fehlenden Wert durch einen anderen Wert
Für eine bestimmte Spalte können Sie dem fehlenden Wert für diese Spalte den Durchschnitt der Spalte zuweisen:
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, np.nan, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
df['A3'] = df['A3'].fillna(df['A3'].mean())
print(df)
Sie können den fehlenden Wert für alle Spalten durch den Durchschnittswert ersetzen, indem Sie die folgenden Schritte ausführen.
df = pd.DataFrame([[1, 2, 3, np.nan, 5],
[np.nan, 7, 8, 9, 10],
[11, np.nan, 13, 14, 15],
[16, np.nan, np.nan, 19, 20],
[21, 22, 23, 24, np.nan]],
index=['A', 'B', 'C', 'D', 'E'],
columns=['A1', 'A2', 'A3', 'A4', 'A5'])
df = df.fillna(df.mean())
print(df)
Fehlende Werte für kategoriale Daten
Erstellen wir den folgenden DataFrame.
df = pd.DataFrame({'A1': ['A', 'A', 'B', 'B', 'B', 'C', np.nan],
'A2': [1, 2, 3, 4, 5, 6, 7],
'A3': [8, 9, 10, 11, 12, 13, 14]})
print(df)
Lassen Sie uns die Kategorie und die Anzahl der Daten mit dem folgenden Code überprüfen.
print(df['A1'].value_counts())
B 3 A 2 C 1
Mit dem folgenden Code können Sie nur bestimmte Datenkategorien abrufen.
print(df[df['A1'] == 'B'])
A1 A2 A3 2 B 3 10 3 B 4 11 4 B 5 12
Sie können die fehlenden Werte für kategoriale Daten mit dem folgenden Code eingeben. Da der häufigste Wert von "mode () [0]" zurückgegeben wird, wird der häufigste Wert dem fehlenden Wert zugewiesen.
df = pd.DataFrame({'A1': ['A', 'A', 'B', 'B', 'B', 'C', np.nan],
'A2': [1, 2, 3, 4, 5, 6, 7],
'A3': [8, 9, 10, 11, 12, 13, 14]})
df['A1'] = df['A1'].fillna(df['A1'].mode()[0])
print(df)
Berechnen wir den Prozentsatz der kategorialen Daten mit dem folgenden Code.
df = pd.DataFrame({'A1': ['A', 'A', 'B', 'B', 'B', 'C', np.nan],
'A2': [1, 2, 3, 4, 5, 6, 7],
'A3': [8, 9, 10, 11, 12, 13, 14]})
print(round(df['A1'].value_counts() / len(df), 3))
B 0.429 A 0.286 C 0.143
Mit dem folgenden Code können Sie kategoriale Daten gruppieren und Statistiken berechnen.
df = pd.DataFrame({'A1': ['A', 'A', 'B', 'B', 'B', 'C', np.nan],
'A2': [1, 2, 3, 4, 5, 6, 7],
'A3': [8, 9, 10, 11, 12, 13, 14]})
print(df.groupby('A1').sum())
print(df.groupby('A1').mean())
DataFrame Join
Der Standardwert ist "Achse = 0", daher werden sie vertikal kombiniert.
df1 = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A1', 'A2', 'A3'])
df2 = pd.DataFrame(data=np.random.rand(3, 3),
index=['D', 'E', 'F'],
columns=['A1', 'A2', 'A3'])
df3 = pd.concat([df1, df2])
print(df3)
Wenn Sie "Achse = 1" wie unten gezeigt angeben, können Sie sie horizontal kombinieren.
Sie müssen beim vertikalen Verbinden mit "Spalten" und beim horizontalen Verbinden mit "Index" übereinstimmen.
df1 = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A1', 'A2', 'A3'])
df2 = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A4', 'A5', 'A6'])
df3 = pd.concat([df1, df2], axis=1)
print(df3)
Anwenden von Funktionen auf DataFrame
Sie können eine Funktion auf bestimmte Daten anwenden, indem Sie "Übernehmen" verwenden.
df = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A1', 'A2', 'A3'])
print(df)
df['A1'] = df['A1'].apply(lambda x: x ** 2)
print(df)
Wenn Sie eine Funktion mit mehreren Argumenten auf einen DataFrame anwenden, ist es praktisch, eine Funktion mit einem DataFrame als Argument zu definieren.
df = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A1', 'A2', 'A3'])
print(df)
def matmul(df):
return df['A1'] * df['A2']
df['A4'] = df.apply(matmul, axis=1)
print(df)
Wenn Sie mehrere Rückgabewerte haben, können Sie diese wie folgt empfangen.
df = pd.DataFrame(data=np.random.rand(3, 3),
index=['A', 'B', 'C'],
columns=['A1', 'A2', 'A3'])
def square_and_twice(x):
return pd.Series([x**2, x*2])
df[['square', 'twice']] = df['A3'].apply(square_and_twice)
print(df)
Am Ende
Dies ist das Ende dieses Artikels.
Vielen Dank für Ihre Beziehung.
Recommended Posts