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();

wprowadź opis zdjęcia tutaj

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)

wprowadź opis zdjęcia tutaj


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)

wprowadź opis zdjęcia tutaj

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ą.



Modified text is an extract of the original Stack Overflow Documentation
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow