pandas
Daten indizieren und auswählen
Suche…
Spalte nach Beschriftung auswählen
# Create a sample DF
df = pd.DataFrame(np.random.randn(5, 3), columns=list('ABC'))
# Show DF
df
A B C
0 -0.467542 0.469146 -0.861848
1 -0.823205 -0.167087 -0.759942
2 -1.508202 1.361894 -0.166701
3 0.394143 -0.287349 -0.978102
4 -0.160431 1.054736 -0.785250
# Select column using a single label, 'A'
df['A']
0 -0.467542
1 -0.823205
2 -1.508202
3 0.394143
4 -0.160431
# Select multiple columns using an array of labels, ['A', 'C']
df[['A', 'C']]
A C
0 -0.467542 -0.861848
1 -0.823205 -0.759942
2 -1.508202 -0.166701
3 0.394143 -0.978102
4 -0.160431 -0.785250
Weitere Details unter: http://pandas.pydata.org/pandas-docs/version/0.18.0/indexing.html#selection-by-label
Wählen Sie nach Position
Mit der iloc (kurz für ganzzahlige Position ) können Sie die Zeilen eines Datenrahmens basierend auf ihrem Positionsindex auswählen. Auf diese Weise können Datenframes so geschnitten werden, wie dies beim Python-Listen-Slicing der Fall ist.
df = pd.DataFrame([[11, 22], [33, 44], [55, 66]], index=list("abc"))
df
# Out:
# 0 1
# a 11 22
# b 33 44
# c 55 66
df.iloc[0] # the 0th index (row)
# Out:
# 0 11
# 1 22
# Name: a, dtype: int64
df.iloc[1] # the 1st index (row)
# Out:
# 0 33
# 1 44
# Name: b, dtype: int64
df.iloc[:2] # the first 2 rows
# 0 1
# a 11 22
# b 33 44
df[::-1] # reverse order of rows
# 0 1
# c 55 66
# b 33 44
# a 11 22
Die Zeilenposition kann mit der Spaltenposition kombiniert werden
df.iloc[:, 1] # the 1st column
# Out[15]:
# a 22
# b 44
# c 66
# Name: 1, dtype: int64
Siehe auch: Auswahl nach Position
Schneiden mit Etiketten
Bei der Verwendung von Etiketten werden sowohl der Anfang als auch der Stopp in die Ergebnisse einbezogen.
import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(5, 5)), columns = list("ABCDE"),
index = ["R" + str(i) for i in range(5)])
# Out:
# A B C D E
# R0 99 78 61 16 73
# R1 8 62 27 30 80
# R2 7 76 15 53 80
# R3 27 44 77 75 65
# R4 47 30 84 86 18
Zeilen R0 bis R2 :
df.loc['R0':'R2']
# Out:
# A B C D E
# R0 9 41 62 1 82
# R1 16 78 5 58 0
# R2 80 4 36 51 27
Beachten Sie, wie sich loc von iloc da iloc den iloc ausschließt
df.loc['R0':'R2'] # rows labelled R0, R1, R2
# Out:
# A B C D E
# R0 9 41 62 1 82
# R1 16 78 5 58 0
# R2 80 4 36 51 27
# df.iloc[0:2] # rows indexed by 0, 1
# A B C D E
# R0 99 78 61 16 73
# R1 8 62 27 30 80
Spalten C bis E :
df.loc[:, 'C':'E']
# Out:
# C D E
# R0 62 1 82
# R1 5 58 0
# R2 36 51 27
# R3 68 38 83
# R4 7 30 62
Auswahl aus gemischten Positionen und Etiketten
Datenrahmen:
import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(5, 5)), columns = list("ABCDE"),
index = ["R" + str(i) for i in range(5)])
df
Out[12]:
A B C D E
R0 99 78 61 16 73
R1 8 62 27 30 80
R2 7 76 15 53 80
R3 27 44 77 75 65
R4 47 30 84 86 18
Zeilen nach Position und Spalten nach Beschriftung auswählen:
df.ix[1:3, 'C':'E']
Out[19]:
C D E
R1 5 58 0
R2 36 51 27
Wenn der Index eine Ganzzahl ist, verwendet .ix Bezeichnungen statt Positionen
df.index = np.arange(5, 10)
df
Out[22]:
A B C D E
5 9 41 62 1 82
6 16 78 5 58 0
7 80 4 36 51 27
8 31 2 68 38 83
9 19 18 7 30 62
#same call returns an empty DataFrame because now the index is integer
df.ix[1:3, 'C':'E']
Out[24]:
Empty DataFrame
Columns: [C, D, E]
Index: []
Boolesche Indizierung
Sie können Zeilen und Spalten eines Datenrahmens mithilfe von booleschen Arrays auswählen.
import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(5, 5)), columns = list("ABCDE"),
index = ["R" + str(i) for i in range(5)])
print (df)
# A B C D E
# R0 99 78 61 16 73
# R1 8 62 27 30 80
# R2 7 76 15 53 80
# R3 27 44 77 75 65
# R4 47 30 84 86 18
mask = df['A'] > 10
print (mask)
# R0 True
# R1 False
# R2 False
# R3 True
# R4 True
# Name: A, dtype: bool
print (df[mask])
# A B C D E
# R0 99 78 61 16 73
# R3 27 44 77 75 65
# R4 47 30 84 86 18
print (df.ix[mask, 'C'])
# R0 61
# R3 77
# R4 84
# Name: C, dtype: int32
print(df.ix[mask, ['C', 'D']])
# C D
# R0 61 16
# R3 77 75
# R4 84 86
Weitere Informationen zu Pandas .
Spalten filtern ("interessant" auswählen, nicht benötigte löschen, RegEx verwenden usw.)
Beispiel-DF generieren
In [39]: df = pd.DataFrame(np.random.randint(0, 10, size=(5, 6)), columns=['a10','a20','a25','b','c','d'])
In [40]: df
Out[40]:
a10 a20 a25 b c d
0 2 3 7 5 4 7
1 3 1 5 7 2 6
2 7 4 9 0 8 7
3 5 8 8 9 6 8
4 8 1 0 4 4 9
Spalten mit dem Buchstaben 'a' anzeigen
In [41]: df.filter(like='a')
Out[41]:
a10 a20 a25
0 2 3 7
1 3 1 5
2 7 4 9
3 5 8 8
4 8 1 0
Spalten mit RegEx-Filter anzeigen (b|c|d) - b oder c oder d :
In [42]: df.filter(regex='(b|c|d)')
Out[42]:
b c d
0 5 4 7
1 7 2 6
2 0 8 7
3 9 6 8
4 4 4 9
zeige alle Spalten außer denjenigen, die mit a beginnen
In [43]: df.ix[:, ~df.columns.str.contains('^a')]
Out[43]:
b c d
0 5 4 7
1 7 2 6
2 0 8 7
3 9 6 8
4 4 4 9
Zeilen filtern / auswählen mit der Methode .query ()
import pandas as pd
zufällige DF generieren
df = pd.DataFrame(np.random.randint(0,10,size=(10, 3)), columns=list('ABC'))
In [16]: print(df)
A B C
0 4 1 4
1 0 2 0
2 7 8 8
3 2 1 9
4 7 3 8
5 4 0 7
6 1 5 5
7 6 7 8
8 6 7 3
9 6 4 5
Wählen Sie Zeilen aus, deren Werte in Spalte A > 2 und die Werte in Spalte B < 5
In [18]: df.query('A > 2 and B < 5')
Out[18]:
A B C
0 4 1 4
4 7 3 8
5 4 0 7
9 6 4 5
Verwenden der .query() -Methode mit Variablen zum Filtern
In [23]: B_filter = [1,7]
In [24]: df.query('B == @B_filter')
Out[24]:
A B C
0 4 1 4
3 2 1 9
7 6 7 8
8 6 7 3
In [25]: df.query('@B_filter in B')
Out[25]:
A B C
0 4 1 4
Pfadabhängiges Schneiden
Es kann erforderlich werden, die Elemente einer Serie oder die Zeilen eines Datenrahmens so zu durchlaufen, dass das nächste Element oder die nächste Zeile von dem zuvor ausgewählten Element oder der zuvor ausgewählten Zeile abhängt. Dies wird als Pfadabhängigkeit bezeichnet.
Betrachten Sie die folgende Zeitreihe s mit unregelmäßiger Frequenz.
#starting python community conventions
import numpy as np
import pandas as pd
# n is number of observations
n = 5000
day = pd.to_datetime(['2013-02-06'])
# irregular seconds spanning 28800 seconds (8 hours)
seconds = np.random.rand(n) * 28800 * pd.Timedelta(1, 's')
# start at 8 am
start = pd.offsets.Hour(8)
# irregular timeseries
tidx = day + start + seconds
tidx = tidx.sort_values()
s = pd.Series(np.random.randn(n), tidx, name='A').cumsum()
s.plot();
Nehmen wir eine wegabhängige Bedingung an. Beginnend mit dem ersten Mitglied der Serie möchte ich jedes nachfolgende Element so greifen, dass die absolute Differenz zwischen diesem Element und dem aktuellen Element größer oder gleich x .
Wir lösen dieses Problem mit Python-Generatoren.
Generatorfunktion
def mover(s, move_size=10):
"""Given a reference, find next value with
an absolute difference >= move_size"""
ref = None
for i, v in s.iteritems():
if ref is None or (abs(ref - v) >= move_size):
yield i, v
ref = v
Dann können wir eine neue Serie definieren moves wie so
moves = pd.Series({i:v for i, v in mover(s, move_size=10)},
name='_{}_'.format(s.name))
Plotten sie beide
moves.plot(legend=True)
s.plot(legend=True)
Das Analog für Datenrahmen wäre:
def mover_df(df, col, move_size=2):
ref = None
for i, row in df.iterrows():
if ref is None or (abs(ref - row.loc[col]) >= move_size):
yield row
ref = row.loc[col]
df = s.to_frame()
moves_df = pd.concat(mover_df(df, 'A', 10), axis=1).T
moves_df.A.plot(label='_A_', legend=True)
df.A.plot(legend=True)
Ruft die ersten / letzten n Zeilen eines Datenrahmens ab
Um die ersten oder letzten Datensätze eines Datenrahmens anzuzeigen, können Sie die Methoden head und tail
Verwenden Sie DataFrame.head([n]) um die ersten n Zeilen DataFrame.head([n])
df.head(n)
Verwenden Sie DataFrame.tail([n]) um die letzten n Zeilen DataFrame.tail([n])
df.tail(n)
Ohne das Argument n geben diese Funktionen 5 Zeilen zurück.
Beachten Sie, dass die Slice-Notation für head / tail lauten würde:
df[:10] # same as df.head(10)
df[-10:] # same as df.tail(10)
Wählen Sie unterschiedliche Zeilen über den Datenrahmen aus
Lassen
df = pd.DataFrame({'col_1':['A','B','A','B','C'], 'col_2':[3,4,3,5,6]})
df
# Output:
# col_1 col_2
# 0 A 3
# 1 B 4
# 2 A 3
# 3 B 5
# 4 C 6
Um die eindeutigen Werte in col_1 , können Sie Series.unique()
df['col_1'].unique()
# Output:
# array(['A', 'B', 'C'], dtype=object)
Series.unique () funktioniert jedoch nur für eine einzelne Spalte.
Um das select unique col_1, col_2 von SQL zu simulieren , können Sie DataFrame.drop_duplicates() :
df.drop_duplicates()
# col_1 col_2
# 0 A 3
# 1 B 4
# 3 B 5
# 4 C 6
Dadurch erhalten Sie alle eindeutigen Zeilen im Datenrahmen. Also wenn
df = pd.DataFrame({'col_1':['A','B','A','B','C'], 'col_2':[3,4,3,5,6], 'col_3':[0,0.1,0.2,0.3,0.4]})
df
# Output:
# col_1 col_2 col_3
# 0 A 3 0.0
# 1 B 4 0.1
# 2 A 3 0.2
# 3 B 5 0.3
# 4 C 6 0.4
df.drop_duplicates()
# col_1 col_2 col_3
# 0 A 3 0.0
# 1 B 4 0.1
# 2 A 3 0.2
# 3 B 5 0.3
# 4 C 6 0.4
Um die Spalten anzugeben, die beim Auswählen eindeutiger Datensätze berücksichtigt werden sollen, übergeben Sie sie als Argumente
df = pd.DataFrame({'col_1':['A','B','A','B','C'], 'col_2':[3,4,3,5,6], 'col_3':[0,0.1,0.2,0.3,0.4]})
df.drop_duplicates(['col_1','col_2'])
# Output:
# col_1 col_2 col_3
# 0 A 3 0.0
# 1 B 4 0.1
# 3 B 5 0.3
# 4 C 6 0.4
# skip last column
# df.drop_duplicates(['col_1','col_2'])[['col_1','col_2']]
# col_1 col_2
# 0 A 3
# 1 B 4
# 3 B 5
# 4 C 6
Quelle: Wie kann man mehrere Datenrahmenspalten in Pandas voneinander unterscheiden? .
Zeilen mit fehlenden Daten herausfiltern (NaN, None, NaT)
Wenn Sie einen Datenrahmen mit fehlenden Daten ( NaN , pd.NaT , None ) haben, können Sie unvollständige Zeilen herausfiltern
df = pd.DataFrame([[0,1,2,3],
[None,5,None,pd.NaT],
[8,None,10,None],
[11,12,13,pd.NaT]],columns=list('ABCD'))
df
# Output:
# A B C D
# 0 0 1 2 3
# 1 NaN 5 NaN NaT
# 2 8 NaN 10 None
# 3 11 12 13 NaT
DataFrame.dropna alle Zeilen, die mindestens ein Feld mit fehlenden Daten enthalten
df.dropna()
# Output:
# A B C D
# 0 0 1 2 3
Um nur die Zeilen zu löschen, bei denen Daten in den angegebenen Spalten fehlen, verwenden Sie die subset
df.dropna(subset=['C'])
# Output:
# A B C D
# 0 0 1 2 3
# 2 8 NaN 10 None
# 3 11 12 13 NaT
Verwenden Sie die Option inplace = True für die Ersetzung durch das gefilterte Bild.