[PYTHON] Ich habe die grundlegende Operation von Pandas im Jupyter Lab geschrieben (Teil 2).

14 ..

Über NaN von DataFrame

import numpy as np
import pandas as pd

df = pd.read_csv('train.csv')
df.head()

Alle Datensätze, die NaN enthalten, wurden gelöscht. (Index bleibt gleich. Grundsätzlich wird der Index nur neu zugewiesen, wenn .reset_index ()

df.dropna().head()

Sie können eine Spalte mit NaN löschen, indem Sie Achse = 1 als Argument verwenden (Standard ist Linie mit Achse = 0).

nicht sehr oft verwenden. Beim Erstellen eines Modells wird es in der Strategie verwendet, die Variablen (erklärende Variablen) zu reduzieren, die die Daten erklären, ohne die Anzahl der Daten zu verringern. Es ist jedoch unwahrscheinlich, dass "die erklärenden Variablen reduziert werden, weil es sogar ein NaN gibt". .. Welche erklärenden Variablen für die Modellbildung wichtig sind, ist eine sehr wichtige und sorgfältige Frage.

df.dropna(axis=1) .head()

Durch Übergeben einer Liste von Spaltennamen an das Teilmengenargument werden nur die Zeilen gelöscht, die NaN in dieser Spalte enthalten.

Sie müssen nur die NaN-Zeile in einer bestimmten Spalte ablegen. Denken Sie daran, es ist sehr praktisch.

Natürlich überschreibt .dropna () den ursprünglichen df nicht. Wenn Sie das ursprüngliche df aktualisieren möchten, weisen Sie es dem vertrauten inplace = True oder df = df.dropna () zu.

df.dropna(subset=['Age']).head() ###index=888 wird fallen gelassen.

.fillna(value)

Weisen Sie NaN einen bestimmten Wert zu.

df.fillna('THIS IS IT').head()

Ersetzen Sie NaN in einer bestimmten Spalte durch den Spaltenmittelwert

df['Age'].mean()

29.69911764705882

df['Age'].fillna(df['Age'].mean()).head()

0    22.0
1    38.0
2    26.0
3    35.0
4    35.0
Name: Age, dtype: float64

df['Age'] = df['Age'].fillna(df['Age'].mean())

df.head()

pd.isna(df).head()

Ersetzen Sie das NaN-Beurteilungsergebnis von Cabin durch die Spalte Cabin_nan

df['Cabin_nan'] = pd.isna(df['Cabin']) df

15 ..

groupby mit .groupby () function ()

df = pd.read_csv('train.csv')
df.head()

Gruppieren Sie nach in Klasse

Da df.groupby ('Pclass') allein nicht weiß, was nach dem Gruppieren und Gruppieren zu tun ist, rufen Sie Funktionen wie .mean () und .count () auf.

df.groupby('Pclass').mean()

df = df[df['Pclass']==1]
df.head()

Nehmen Sie Statistiken für jede Spalte mit 'Klasse' == 1

df[df['Pclass']==1].describe()

Nur Mittelwert extrahieren

Es ist schwierig, sie einzeln herauszunehmen, daher ist es eine gute Idee, .groupby () zu verwenden, um sie alle zusammen zu sehen.

df[df['Pclass']==1].describe().loc['mean']

PassengerId    461.597222
Survived         0.629630
Pclass           1.000000
Age             38.233441
SibSp            0.416667
Parch            0.356481
Fare            84.154687
Name: mean, dtype: float64

Nehmen Sie nach groupby den im Index angegebenen Wert für by, das erste Argument von groupby,. Im obigen Beispiel ist dies der Wert von Pclass (1, 2, 3). Das Ergebnis von grouby ist natürlich auch ein DataFrame, sodass Sie mit .loc [] eine bestimmte Gruppe von Serien abrufen können.

df.groupby('Pclass').mean().loc[1]

PassengerId    461.597222
Survived         0.629630
Age             38.233441
SibSp            0.416667
Parch            0.356481
Fare            84.154687
Name: 1, dtype: float64

df.groupby('Pclass').count().loc[1] #count()Und Summe()Usw. sind ebenfalls möglich

PassengerId    216
Survived       216
Name           216
Sex            216
Age            186
SibSp          216
Parch          216
Ticket         216
Fare           216
Cabin          176
Embarked       214
Name: 1, dtype: int64

df.groupby('Pclass').describe()

df.groupby('Pclass').describe()['Age'] #Ich habe nur Age rausgenommen

Wenn in Jupyter die Spalten und Zeilen des DataFrame nicht angezeigt werden können, werden sie weggelassen.

Wenn Sie alle Spalten (oder alle Zeilen) anzeigen möchten, ohne sie wegzulassen, können Sie verhindern, dass sie weggelassen werden, indem Sie Folgendes ausführen.

#Anzeige ohne Auslassen von Spalten
pd.set_option('display.max_columns', None)
#Anzeige ohne Auslassen von Linien
pd.set_option('display.max_rows', None)

Drehen Sie das Ergebnis der Gruppe mit einer for-Anweisung um

for i, group_df in df.groupby('Pclass'):
    print("{}: group_df's type is {} and has {}".format(i, type(group_df), len(group_df)))

1: group_df's type is <class 'pandas.core.frame.DataFrame'> and has 216
2: group_df's type is <class 'pandas.core.frame.DataFrame'> and has 184
3: group_df's type is <class 'pandas.core.frame.DataFrame'> and has 491

Nummerieren Sie den höchsten Tarif für jeden Datensatz in jeder Pclass-Gruppe

df = pd.read_csv('train.csv')
results = []
for i, group_df in df.groupby('Pclass'):
    sorted_group_df = group_df.sort_values('Fare')
    sorted_group_df['RankInClass'] = np.arange(len(sorted_group_df))
    results.append(sorted_group_df)

results_df = pd.concat(results)
results_df.head()

Tisch verbinden

Es gibt zwei Haupttypen von Tabellenverknüpfungen.

Verbinden Sie sich, indem Sie eine bestimmte Spalte oder einen bestimmten Index als Schlüssel verwenden

Kombinieren Sie DataFrames einfach horizontal (oder vertikal) (oder vertikal).

import pandas as pd

df1 = pd.DataFrame({'Key':['k0','k','k2'],
                   'A':['a0','a1','a2'],
                   'B':['b0','b1','b2']})
df2 = pd.DataFrame({'Key':['k0','k1','k2'],
                   'C':['c0','c2','c3'],
                   'D':['d0','d1','d2']})

df1

df2

Beide haben eine Spalte namens "Key" und ihre Werte sind gleich.

Die anderen Spalten haben unterschiedliche Werte. Diese Spalte mit dem Namen "Schlüssel" wird als Schlüssel verwendet, um zwei DataFrames horizontal zu verbinden. Verwenden Sie zum Zusammenführen .merge ().

df1.merge(df2)

Kombinieren Sie DataFrames einfach horizontal (oder vertikal) (oder vertikal).

Verwenden Sie pd.concat () concat = concatenate

#Vertikal (oft verwendet)
pd.concat([df1,df2], axis=0) #Der Standardwert ist Achse=0

/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:2: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.

To accept the future behavior, pass 'sort=False'.

To retain the current behavior and silence the warning, pass 'sort=True'.

#Seite
pd.concat([df1,df2], axis=1)

16 ..

Verwendung von .merge ()

wie: Wie kombiniert man → {'links', 'rechts', 'außen', 'inner'}, Standard ist 'inner'

Geben Sie die Spalte an, die aktiviert werden soll: key (Spalte, die in beiden DataFrames vorhanden ist). Wenn nicht angegeben, werden sie in einer gemeinsamen Spalte zusammengefasst.

left_on: Spalte, die der Schlüssel des linken DataFrame sein soll

right_on: Spalte als Schlüssel für den richtigen DataFrame

left_index: Geben Sie True an, wenn Sie den linken Schlüssel auf Index setzen

right_index: Geben Sie True an, wenn Sie den Schlüssel für das Indexieren festlegen

how

df1

df2

df1.merge(df2, how='left')

df1.merge(df2, how='outer')

df1.merge(df2, how='inner')

on

Das Argument on gibt an, welche Spalte beim Beitritt als Schlüssel verwendet werden soll. Sie können nur Spalten angeben, die sich sowohl in der linken als auch in der rechten Tabelle befinden.

Wenn es eine gemeinsame Spalte gibt, ist diese Spalte der Schlüssel und wird kombiniert, ohne etwas anzugeben. Geben wir jedoch die Grundlagen an. Es ist leicht zu verstehen und sicher. Es wird oft gesagt, dass "sie in einer unerwarteten Spalte verbunden wurden". Wenn mehrere gemeinsame Spalten vorhanden sind, wissen Sie nicht, welche Spalte verbunden werden soll, und selbst wenn nur eine gemeinsame Spalte vorhanden ist, ist es besser, diese anzugeben. (Da die Beispiele bisher vor der Erklärung von on lagen, habe ich sie absichtlich geschrieben, ohne das Argument on anzugeben.)

Um den Index auf Key zu setzen, setzen Sie right_index und left_index, die später beschrieben werden, auf True. Wenn die Spaltennamen jeder Tabelle (DataFrame) unterschiedlich sind, geben Sie left_on und right_on an, die später beschrieben werden.

df1 = pd.DataFrame({'Key':['k0','k1','k2'],
                    'ID':['aa','bb','cc'],
                   'A':['a0','a1','a2'],
                   'B':['b0','b1','b2']})
df2 = pd.DataFrame({'Key':['k0','k1','k3'],
                    'ID':['aa','bb','cc'],
                   'C':['c0','c1','c3'],
                   'D':['d0','d1','d3']})

df1.merge(df2, on='Key')

df1.merge(df2, on='ID')

Suffix ändern

df1.merge(df2, on='ID', suffixes=('_left', '_right'))

left_on, right_on

Geben Sie dieses Argument an, wenn der Spaltenname, den Sie als Schlüssel verwenden möchten, zwischen links und rechts unterschiedlich ist.

df1 = pd.DataFrame({'Key1':['k0','k1','k2'],
                   'A':['a0','a1','a2'],
                   'B':['b0','b1','b2']})
df2 = pd.DataFrame({'Key2':['k0','k1','k3'],
                   'C':['c0','c1','c3'],
                   'D':['d0','d1','d3']})

df1.merge(df2, left_on='Key1', right_on='Key2')

left_index, right_index

Wenn Sie Index als Schlüssel anstelle von Spalte angeben möchten, geben Sie True für left_index und right_index an.

df1.merge(df2, left_index=True, right_index=True)

join

Wenn Sie die Join-Funktion verwenden, wird sie nach Index verknüpft, Sie müssen sich jedoch nicht daran erinnern, da Sie mit Merge fast dasselbe tun können.

df1 = pd.DataFrame({'Key1':['k0','k1','k2'],
                   'A':['a0','a1','a2'],
                   'B':['b0','b1','b2']})
df2 = pd.DataFrame({'Key2':['k0','k1','k3'],
                   'C':['c0','c1','c3'],
                   'D':['d0','d1','d3']})

df1.join(df2)

df1.merge(df2, left_index=True, right_index=True)

df1 = pd.DataFrame({'Key1':['k0','k1','k2'],
                   'A':['a0','a1','a2'],
                   'B':['b0','b1','b2']})
df2 = pd.DataFrame({'Key2':['k0','k1','k3'],
                   'C':['c0','c1','c3'],
                   'D':['d0','d1','d3']})
df3 = pd.DataFrame({'Key3':['k0','k1','k4'],
                   'E':['c0','c1','c3'],
                   'F':['d0','d1','d3']})
df1.join([df2, df3])

17 ..

.unique() .nunique()

import pandas as pd
df = pd.read_csv('train.csv')
df.head()

df['Pclass'].unique()

array([3, 1, 2])

df['Pclass'].nunique()

3

.value_counts()

df['Pclass'].value_counts()

3    491
1    216
2    184
Name: Pclass, dtype: int64

(Super wichtig) .apply ()

Mit der Funktion apply () können Sie alle Datensätze in einem DataFrame verarbeiten und die Ergebnisse in einer separaten Spalte speichern. Es ist ein Bild, das die Verarbeitung auf jede Zeile anwendet

def get_age_group(age):
    return str(age)[0] + '0s'

get_age_group(45)

'40s'

df = pd.DataFrame({'name':['John','Mike','Emily'],
                  'age':['23','36','42']})
df

df['age'].apply(get_age_group)

0    20s
1    30s
2    40s
Name: age, dtype: object

Verwendung von .apply () mit Lambda-Funktion

#Weisen Sie der Variablen f in der Lambda-Funktion zu
f = lambda x: str(x)[0] + '0s'
#Setzen Sie 43 als Probe
f(43)

'40s'

df['age_group'] = df['age'].apply(lambda x: str(x)[0] + '0s')

df

Verwendung von .apply () für den gesamten Datensatz

df = pd.DataFrame({'name':['John','Mike','Emily'],
                  'age':['23','36','42']})
df['description'] = df.apply(lambda row:'{} is {} years old'.format(row['name'], row['age']), axis=1)

df

18 ..

Speichern Sie DataFrame im CSV-Format mit .to_csv ()

df = pd.read_csv('train.csv')
df.head()

df['Adult'] = df['Age'].apply(lambda x: x>20)
df.tail()

df.to_csv('train_w_adult.csv')

df = pd.read_csv('train_w_adult.csv')
df.head(3)

Mit Blick auf das Ergebnis von df.head (3) werden die Indexinformationen, als sie das letzte Mal gespeichert wurden, in der mysteriösen Spalte "Unbenannt: 0" gespeichert.

Wenn Sie in .to_csv () index = False angeben, müssen Sie den Index nicht speichern. Geben Sie grundsätzlich immer index = False an und speichern Sie es im CSV-Format.

Beachten Sie, dass dieselbe Datei, die bereits im Speicherziel vorhanden ist, überschrieben wird.

df = pd.read_csv('train.csv')
df['Adult'] = df['Age'].apply(lambda x: x>20)
df.to_csv('train_w_adult.csv', index=False)

df = pd.read_csv('train_w_adult.csv')
df.head(3)

df = pd.DataFrame({'A':[['a', 'b'], 2, 3], 'B':[['c', 'd'], 5, 6]})
df

#Stellen Sie sicher, dass die gespeicherten Werte eine Liste sind.
type(df['A'].iloc[0])

list

#Speichern Sie mit csv
df.to_csv('temp.csv', index=False)
#Laden Sie die gespeicherte CSV
df = pd.read_csv('temp.csv')
df

type(df['A'].iloc[0])

str

Iterieren Sie DataFrame mit .iterrows ()

Es wird verwendet, wenn ein DataFrame mit einer for-Anweisung iteriert wird. Es ist schwer zu merken, aber da "Zeilen" "Iteration" ist, erinnern wir uns an iter + row + s. Da es mit for gedreht werden kann, nehmen wir an, dass es mehrere s gibt.

"Iteration" bedeutet, den Vorgang zu wiederholen. Es ist eine Schleife. Wenn es sich beispielsweise um eine Liste handelt, kann sie mit i in list iteriert werden: (siehe Teil 4).

In DataFrame können Sie nicht direkt für i in df sagen: wie eine Liste. Schreiben Sie wie folgt mit einer Funktion namens .iterrows ().

df = pd.read_csv('train.csv')
for idx, row in df.iterrows():
    if row['Age'] > 40 and row['Pclass'] == 3 and row['Sex'] == 'male' and row['Survived'] == 1:
        print('{} is very lucky guy...!'.format(row['Name']))

Dahl, Mr. Karl Edwart is very lucky guy...!
Sundman, Mr. Johan Julian is very lucky guy...!

In .apply () wird es häufig verwendet, wenn das Ergebnis der Verarbeitung jedes Datensatzes in einer anderen Spalte gespeichert wird, und in dieser .iterows () wird es häufig verwendet, wenn Sie nur verarbeiten möchten, anstatt einen Wert zurückzugeben.

Beispielsweise wird der Dateipfad in DataFrame gespeichert und .iterrows () wird zum Verschieben oder Lesen der Datei verwendet.

Sortieren Sie nach einer bestimmten Spalte mit .sort_values ()

#Nach Alter sortieren
df.sort_values('Age')
df.head()

Erstellen Sie eine Pivot-Tabelle mit .pivot_table ()

data = {'Data':['Jan-1','Jan-1','Jan-1','Jan-2','Jan-2','Jan-2'],
       'User':['Emily', 'John','Nick','Kevin','Emily','John'],
       'Method':['Card','Card','Cash','Card','Cash','Cash'],
       'Price':[100,250,200,460,200,130]}
df = pd.DataFrame(data)
df

Geben Sie unter Werte die Spalte ein, die Sie aggregieren möchten. Diesmal ist es Preis.

Zunächst wird in jede Zelle der durch Werte angegebene Wert (in diesem Fall Preis) eingegeben. Dies ist die Spalte, die Sie aggregieren möchten.

Übergeben Sie andererseits einfach die Spalten, für die Sie Index und Spalten in einer Liste angeben möchten.

df.pivot_table(values='Price', index=['Data', 'User'], columns=['Method'])

df.pivot_table(values='Price', index=['Data', 'Method'], columns=['User'])

Klären Sie zuerst "welche Spalte Sie aggregieren möchten" und fügen Sie diese Spalte in Werte ein. Fügen Sie dann einfach die gewünschten Informationen in Index und Spalten ein.

Querschnittsoperation mit .xs ()

.xs () ist eine Abkürzung für Querschnitt. Ich benutze auch nicht so viel, aber es ist praktisch, wenn ich mit DataFrames arbeite, die mehrere Indizes haben, wie z. B. Pivots. Es ist eine gute Idee, sich zusammen mit dem Drehpunkt daran zu erinnern.

Was Sie mit dieser .xs () tun müssen, ist, sie in der obigen Pivot-Tabelle zu verwenden, wenn Sie beispielsweise nur die Zeile "Karte" extrahieren möchten. (Genauer Querschnitt)

#pivot.xs('Card', level = 'Method')