pandas
Indeksowanie i wybieranie danych
Szukaj…
Wybierz kolumnę według etykiety
# 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
Dodatkowe informacje na stronie: http://pandas.pydata.org/pandas-docs/version/0.18.0/indexing.html#selection-by-label
Wybierz według pozycji
Metoda iloc (skrót od położenia liczby całkowitej ) pozwala wybrać wiersze ramki danych na podstawie ich indeksu pozycji. W ten sposób można wycinać ramki danych tak jak w przypadku wycinania list Pythona.
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
Lokalizację wiersza można połączyć z lokalizacją kolumny
df.iloc[:, 1] # the 1st column
# Out[15]:
# a 22
# b 44
# c 66
# Name: 1, dtype: int64
Zobacz także: Wybór według pozycji
Krojenie za pomocą etykiet
Podczas korzystania z etykiet, zarówno początek, jak i stop są uwzględniane w wynikach.
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
Rzędy R0 do 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
Zauważ, że loc różni się od iloc ponieważ iloc wyklucza indeks końcowy
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
Kolumny od C do 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
Mieszany wybór oparty na pozycji i etykiecie
Ramka danych:
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
Wybierz wiersze według pozycji, a kolumny według etykiety:
df.ix[1:3, 'C':'E']
Out[19]:
C D E
R1 5 58 0
R2 36 51 27
Jeśli indeks jest liczbą całkowitą, .ix użyje etykiet zamiast pozycji:
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: []
Indeksowanie boolowskie
Można wybierać wiersze i kolumny ramki danych za pomocą tablic boolowskich.
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
Więcej w dokumentacji pand .
Filtrowanie kolumn (wybieranie „interesujących”, upuszczanie niepotrzebnych, używanie RegEx itp.)
wygeneruj próbkę DF
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
pokaż kolumny zawierające literę „a”
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
pokaż kolumny przy użyciu filtra RegEx (b|c|d) - b lub c lub 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
pokaż wszystkie kolumny oprócz tych rozpoczynających się a (innymi słowy usuń / upuść wszystkie kolumny spełniające podane RegEx)
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
Filtrowanie / wybieranie wierszy za pomocą metody `.query ()`
import pandas as pd
generuj losowy DF
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
wybierz wiersze, w których wartości w kolumnie A > 2 i wartości w kolumnie 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
za pomocą metody .query() ze zmiennymi do filtrowania
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
Krojenie zależne od ścieżki
Konieczne może być przejście przez elementy serii lub wierszy ramki danych w taki sposób, aby następny element lub następny wiersz był zależny od wcześniej wybranego elementu lub wiersza. Nazywa się to zależnością ścieżki.
Rozważmy następujący szereg czasowy s z nieregularną częstotliwością.
#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();
Załóżmy warunek zależny od ścieżki. Zaczynając od pierwszego członka serii, chcę chwycić każdy kolejny element tak, aby absolutna różnica między tym elementem a bieżącym elementem była większa lub równa x .
Rozwiążemy ten problem za pomocą generatorów python.
Funkcja generatora
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
Następnie możemy zdefiniować nowe moves serii w ten sposób
moves = pd.Series({i:v for i, v in mover(s, move_size=10)},
name='_{}_'.format(s.name))
Spisywanie ich obu
moves.plot(legend=True)
s.plot(legend=True)
Analogiem dla ramek danych byłoby:
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)
Uzyskaj pierwszy / ostatni n wierszy ramki danych
Aby wyświetlić pierwsze lub ostatnie rekordy ramki danych, możesz użyć metod „ head i tail
Aby zwrócić pierwsze n wierszy, użyj DataFrame.head([n])
df.head(n)
Aby zwrócić ostatnie n wierszy, użyj DataFrame.tail([n])
df.tail(n)
Bez argumentu n funkcje te zwracają 5 wierszy.
Zauważ, że notacja plastra dla head / tail będzie:
df[:10] # same as df.head(10)
df[-10:] # same as df.tail(10)
Wybierz różne wiersze w ramce danych
Pozwolić
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
Aby uzyskać różne wartości w col_1 , możesz użyć Series.unique()
df['col_1'].unique()
# Output:
# array(['A', 'B', 'C'], dtype=object)
Ale Series.unique () działa tylko dla jednej kolumny.
Aby symulować wybrany unikalny col_1, col_2 SQL, możesz użyć DataFrame.drop_duplicates() :
df.drop_duplicates()
# col_1 col_2
# 0 A 3
# 1 B 4
# 3 B 5
# 4 C 6
Otrzymasz wszystkie unikalne wiersze w ramce danych. Więc jeśli
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
Aby określić kolumny, które należy wziąć pod uwagę przy wyborze unikalnych rekordów, przekaż je jako argumenty
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
Źródło: Jak „wybrać odrębne” w wielu kolumnach ramek danych w pandach? .
Filtruj wiersze z brakującymi danymi (NaN, Brak, NaT)
Jeśli masz ramkę danych z brakującymi danymi ( NaN , pd.NaT , None ), możesz odfiltrować niekompletne wiersze
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 wszystkie wiersze zawierające co najmniej jedno pole z brakującymi danymi
df.dropna()
# Output:
# A B C D
# 0 0 1 2 3
Aby po prostu upuścić wiersze, w których brakuje danych w określonych kolumnach, użyj 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
Użyj opcji inplace = True aby zastąpić w miejscu filtrowaną ramką.