Jest kilka sposobów na wybranie wierszy z ramki danych Pandy:]}

1. indeksowanie logiczne(df[df['col'] == value] )
2. pozycjonowanie pozycjonowanie (df.iloc[...])
3. indeksowanie etykiet(df.xs(...))
4. df.query(...) API

Poniżej przedstawiam przykłady każdego z nich, z poradami, kiedy należy stosować określone techniki. Załóżmy, że naszym kryterium jest kolumna 'A' == 'foo'

(uwaga na wydajność: dla każdego typu bazowego, możemy zachować rzeczy proste przez używając API Pandas lub możemy wyjść poza API, Zwykle do NumPy i przyspieszyć działanie.)

Setup

Pierwszą rzeczą, jakiej będziemy potrzebować, jest określenie warunku, który będzie działał jako nasze kryterium wyboru wierszy. Zaczniemy od przypadku OP column_name == some_value i dodamy kilka innych typowych przypadków użycia.

Pożyczka od @unutbu:

import pandas as pd, numpy as np

df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split(),
                   'C': np.arange(8), 'D': np.arange(8) * 2})

1. Indeksowanie logiczne

... Indeksowanie logiczne wymaga znalezienia prawdziwej wartości każda kolumna 'A' jest równa 'foo', a następnie użyj tych wartości prawdy, aby określić, które wiersze zachować. Zazwyczaj nazwalibyśmy tę serię, tablicą wartości prawdy, mask. Zrobimy to również tutaj.

mask = df['A'] == 'foo'

df[mask]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Jest to jeden z najprostszych sposobów wykonania tego zadania i jeśli wydajność lub intuicyjność nie jest problemem, powinna to być wybrana przez Ciebie metoda. Jeśli jednak wydajność jest problemem, możesz chcesz rozważyć alternatywny sposób tworzenia mask.

2. Pozycjonowanie

Pozycyjne indeksowanie (df.iloc[...]) ma swoje zastosowania, ale to nie jest jeden z nich. Aby określić, gdzie pokroić, najpierw musimy wykonać tę samą analizę logiczną, którą wykonaliśmy powyżej. To pozostawia nam wykonanie jednego dodatkowego kroku, aby wykonać to samo zadanie.

mask = df['A'] == 'foo'
pos = np.flatnonzero(mask)
df.iloc[pos]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

3. Indeksowanie etykiet

Etykieta indeksowanie może być bardzo przydatne, ale w w tym przypadku ponownie wykonujemy więcej pracy bez żadnych korzyści [67]}

df.set_index('A', append=True, drop=False).xs('foo', level=1)

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

4. df.query() API

pd.DataFrame.query jest bardzo eleganckim / intuicyjnym sposobem wykonania tego zadania, ale często jest wolniejszy. jednakże, jeśli zwróci się uwagę na czasy poniżej, dla dużych danych zapytanie jest bardzo wydajne. Bardziej niż standardowe podejście i o podobnej skali, jak moja najlepsza sugestia.

df.query('A == "foo"')

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Moje preferencje to użycie Boolean mask

Rzeczywista ulepszeń można dokonać modyfikując sposób, w jaki tworzymy nasze Boolean mask.

mask alternatywa 1 użyj podstawowej tablicy NumPy i zrezygnuj z narzutu tworzenia innej pd.Series

mask = df['A'].values == 'foo'

Pod koniec pokażę więcej kompletnych testów czasowych, ale wystarczy spojrzeć na zyski wydajności, które otrzymujemy za pomocą przykładowej ramki danych. Po pierwsze, patrzymy na różnicę w tworzeniu mask

%timeit mask = df['A'].values == 'foo'
%timeit mask = df['A'] == 'foo'

5.84 µs ± 195 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
166 µs ± 4.45 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Ocena mask z tablicą NumPy jest ~ 30 razy szybsza. Jest to częściowo spowodowane tym, że ocena NumPy często jest szybsza. Jest to również częściowo spowodowane brakiem narzutu koniecznego do zbudowania indeksu i odpowiadającego mu obiektu pd.Series.

Następnie przyjrzymy się czasowi krojenia jednym mask kontra drugim.

mask = df['A'].values == 'foo'
%timeit df[mask]
mask = df['A'] == 'foo'
%timeit df[mask]

219 µs ± 12.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
239 µs ± 7.03 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

mask alternatywa 2 Mogliśmy też zrekonstruować ramkę danych. Jest duży uwaga podczas rekonstrukcji ramki danych-musisz zadbać o dtypes podczas tego procesu!

Zamiast df[mask] zrobimy to

pd.DataFrame(df.values[mask], df.index[mask], df.columns).astype(df.dtypes)

Jeśli ramka danych jest typu mixed, czym jest nasz przykład, to kiedy otrzymamy df.values tablica wynikowa jest dtype object i w konsekwencji wszystkie kolumny nowej ramki danych będą dtype object. W ten sposób wymagając astype(df.dtypes) i zabijając wszelkie potencjalne zyski wydajności.

%timeit df[m]
%timeit pd.DataFrame(df.values[mask], df.index[mask], df.columns).astype(df.dtypes)

216 µs ± 10.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
1.43 ms ± 39.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Jeśli jednak ramka danych nie jest typu mieszanego, jest to bardzo przydatny sposób.

Podane

np.random.seed([3,1415])
d1 = pd.DataFrame(np.random.randint(10, size=(10, 5)), columns=list('ABCDE'))

d1

   A  B  C  D  E
0  0  2  7  3  8
1  7  0  6  8  6
2  0  2  0  4  9
3  7  3  2  4  3
4  3  6  7  7  4
5  5  3  7  5  9
6  8  7  6  4  7
7  6  2  6  6  5
8  2  8  7  5  8
9  4  7  6  1  5

%%timeit
mask = d1['A'].values == 7
d1[mask]

179 µs ± 8.73 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Kontra

%%timeit
mask = d1['A'].values == 7
pd.DataFrame(d1.values[mask], d1.index[mask], d1.columns)

87 µs ± 5.12 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

mask alternatywa 3

@ unutbu pokazuje nam również, jak używać pd.Series.isin do rozliczania każdego elementu df['A'] będącego w zbiorze wartości. To samo się dzieje, jeśli nasz zbiór wartości jest zbiorem jednej wartości, a mianowicie 'foo'. Ale uogólnia się również, aby w razie potrzeby zawierać większe zestawy wartości. Okazuje się, że to wciąż dość szybko chociaż jest to rozwiązanie bardziej ogólne. Jedyną prawdziwą stratą jest intuicyjność dla tych, którzy nie znają pojęcia.

mask = df['A'].isin(['foo'])
df[mask]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Jednakże, tak jak wcześniej, możemy wykorzystać NumPy do poprawy wydajności, poświęcając praktycznie nic. Użyjemy np.in1d

mask = np.in1d(df['A'].values, ['foo'])
df[mask]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Czas

Dołączę inne pojęcia wymienione w innych postach, jak również w celach informacyjnych.

Kod Poniżej

Każda kolumna w tej tabeli przedstawia ramka danych różnej długości, na której testujemy każdą funkcję. Każda kolumna pokazuje czas względny, a najszybsza funkcja ma indeks bazowy 1.0.

res.div(res.min())

                         10        30        100       300       1000      3000      10000     30000
mask_standard         2.156872  1.850663  2.034149  2.166312  2.164541  3.090372  2.981326  3.131151
mask_standard_loc     1.879035  1.782366  1.988823  2.338112  2.361391  3.036131  2.998112  2.990103
mask_with_values      1.010166  1.000000  1.005113  1.026363  1.028698  1.293741  1.007824  1.016919
mask_with_values_loc  1.196843  1.300228  1.000000  1.000000  1.038989  1.219233  1.037020  1.000000
query                 4.997304  4.765554  5.934096  4.500559  2.997924  2.397013  1.680447  1.398190
xs_label              4.124597  4.272363  5.596152  4.295331  4.676591  5.710680  6.032809  8.950255
mask_with_isin        1.674055  1.679935  1.847972  1.724183  1.345111  1.405231  1.253554  1.264760
mask_with_in1d        1.000000  1.083807  1.220493  1.101929  1.000000  1.000000  1.000000  1.144175

Zauważysz, że najszybsze czasy wydają się być dzielone między mask_with_values i mask_with_in1d.

res.T.plot(loglog=True)

Funkcje

def mask_standard(df):
    mask = df['A'] == 'foo'
    return df[mask]

def mask_standard_loc(df):
    mask = df['A'] == 'foo'
    return df.loc[mask]

def mask_with_values(df):
    mask = df['A'].values == 'foo'
    return df[mask]

def mask_with_values_loc(df):
    mask = df['A'].values == 'foo'
    return df.loc[mask]

def query(df):
    return df.query('A == "foo"')

def xs_label(df):
    return df.set_index('A', append=True, drop=False).xs('foo', level=-1)

def mask_with_isin(df):
    mask = df['A'].isin(['foo'])
    return df[mask]

def mask_with_in1d(df):
    mask = np.in1d(df['A'].values, ['foo'])
    return df[mask]

Testowanie

res = pd.DataFrame(
    index=[
        'mask_standard', 'mask_standard_loc', 'mask_with_values', 'mask_with_values_loc',
        'query', 'xs_label', 'mask_with_isin', 'mask_with_in1d'
    ],
    columns=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
    dtype=float
)

for j in res.columns:
    d = pd.concat([df] * j, ignore_index=True)
    for i in res.index:a
        stmt = '{}(d)'.format(i)
        setp = 'from __main__ import d, {}'.format(i)
        res.at[i, j] = timeit(stmt, setp, number=50)

Specjalny Czas

Patrząc na szczególny przypadek, gdy mamy pojedynczy Nie-obiekt dtype dla całej ramki danych.

Kod Poniżej

spec.div(spec.min())

                     10        30        100       300       1000      3000      10000     30000
mask_with_values  1.009030  1.000000  1.194276  1.000000  1.236892  1.095343  1.000000  1.000000
mask_with_in1d    1.104638  1.094524  1.156930  1.072094  1.000000  1.000000  1.040043  1.027100
reconstruct       1.000000  1.142838  1.000000  1.355440  1.650270  2.222181  2.294913  3.406735

Okazuje się, że rekonstrukcja nie jest tego warta poza kilkuset rzędami.

spec.T.plot(loglog=True)

Funkcje

np.random.seed([3,1415])
d1 = pd.DataFrame(np.random.randint(10, size=(10, 5)), columns=list('ABCDE'))

def mask_with_values(df):
    mask = df['A'].values == 'foo'
    return df[mask]

def mask_with_in1d(df):
    mask = np.in1d(df['A'].values, ['foo'])
    return df[mask]

def reconstruct(df):
    v = df.values
    mask = np.in1d(df['A'].values, ['foo'])
    return pd.DataFrame(v[mask], df.index[mask], df.columns)

spec = pd.DataFrame(
    index=['mask_with_values', 'mask_with_in1d', 'reconstruct'],
    columns=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
    dtype=float
)

Testowanie

for j in spec.columns:
    d = pd.concat([df] * j, ignore_index=True)
    for i in spec.index:
        stmt = '{}(d)'.format(i)
        setp = 'from __main__ import d, {}'.format(i)
        spec.at[i, j] = timeit(stmt, setp, number=50)

Tl;dr

Pandy odpowiednik

select * from table where column_name = some_value

Jest

table[table.column_name == some_value]

Wiele warunków:

table[(table.column_name == some_value) | (table.column_name2 == some_value2)]

Lub

table.query('column_name == some_value | column_name2 == some_value2')

Przykład kodu

import pandas as pd

# Create data set
d = {'foo':[100, 111, 222],
     'bar':[333, 444, 555]}
df = pd.DataFrame(d)

# Full dataframe:
df

# Shows:
#    bar   foo
# 0  333   100
# 1  444   111
# 2  555   222

# Output only the row(s) in df where foo is 222:
df[df.foo == 222]

# Shows:
#    bar  foo
# 2  555  222

W powyższym kodzie jest to linia df[df.foo == 222], która podaje wiersze na podstawie wartości kolumny, 222 w tym przypadku.

Możliwe są również różne warunki:

df[(df.foo == 222) | (df.bar == 444)]
#    bar  foo
# 1  444  111
# 2  555  222

Ale w tym momencie zalecałbym użycie funkcji query, ponieważ jest mniej słowna i daje ten sam wynik:

df.query('foo == 222 | bar == 444')

Uważam składnię poprzednich odpowiedzi za zbędną i trudną do zapamiętania. Pandy wprowadziły metodę query() w v0.13 i zdecydowanie ją preferuję. Na twoje pytanie możesz zrobić df.query('col == val')

Reprodukowane z http://pandas.pydata.org/pandas-docs/version/0.17.0/indexing.html#indexing-query

In [167]: n = 10

In [168]: df = pd.DataFrame(np.random.rand(n, 3), columns=list('abc'))

In [169]: df
Out[169]: 
          a         b         c
0  0.687704  0.582314  0.281645
1  0.250846  0.610021  0.420121
2  0.624328  0.401816  0.932146
3  0.011763  0.022921  0.244186
4  0.590198  0.325680  0.890392
5  0.598892  0.296424  0.007312
6  0.634625  0.803069  0.123872
7  0.924168  0.325076  0.303746
8  0.116822  0.364564  0.454607
9  0.986142  0.751953  0.561512

# pure python
In [170]: df[(df.a < df.b) & (df.b < df.c)]
Out[170]: 
          a         b         c
3  0.011763  0.022921  0.244186
8  0.116822  0.364564  0.454607

# query
In [171]: df.query('(a < b) & (b < c)')
Out[171]: 
          a         b         c
3  0.011763  0.022921  0.244186
8  0.116822  0.364564  0.454607

Możesz również uzyskać dostęp do zmiennych w środowisku, przygotowując @.

exclude = ('red', 'orange')
df.query('color not in @exclude')

Większa elastyczność przy użyciu .query z pand > = 0.25.0:

Sierpień 2019 zaktualizowana odpowiedź

Od Pandas > = 0.25.0 możemy użyć metody query do filtrowania ramek danych metodami Pandas, a nawet nazw kolumn ze spacjami. Zwykle spacje w nazwach kolumn dałyby błąd, ale teraz możemy to rozwiązać za pomocą backtick ( ` ) - zobacz GitHub :

# Example dataframe
df = pd.DataFrame({'Sender email':['[email protected]', "[email protected]", "[email protected]"]})

     Sender email
0  [email protected]
1  [email protected]
2    [email protected]

Używając .query z metodą str.endswith:

df.query('`Sender email`.str.endswith("@shop.com")')

Wyjście

     Sender email
1  [email protected]
2    [email protected]

Możemy również użyć zmiennych lokalnych poprzez prefiks z @ w naszym zapytaniu:

domain = 'shop.com'
df.query('`Sender email`.str.endswith(@domain)')

Wyjście

     Sender email
1  [email protected]
2    [email protected]

Szybsze wyniki można osiągnąć za pomocą numpy.gdzie .

Na przykład, z unubtu ' s setup -

In [76]: df.iloc[np.where(df.A.values=='foo')]
Out[76]: 
     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Porównanie czasu:

In [68]: %timeit df.iloc[np.where(df.A.values=='foo')]  # fastest
1000 loops, best of 3: 380 µs per loop

In [69]: %timeit df.loc[df['A'] == 'foo']
1000 loops, best of 3: 745 µs per loop

In [71]: %timeit df.loc[df['A'].isin(['foo'])]
1000 loops, best of 3: 562 µs per loop

In [72]: %timeit df[df.A=='foo']
1000 loops, best of 3: 796 µs per loop

In [74]: %timeit df.query('(A=="foo")')  # slowest
1000 loops, best of 3: 1.71 ms per loop

Oto prosty przykład

from pandas import DataFrame

# Create data set
d = {'Revenue':[100,111,222], 
     'Cost':[333,444,555]}
df = DataFrame(d)


# mask = Return True when the value in column "Revenue" is equal to 111
mask = df['Revenue'] == 111

print mask

# Result:
# 0    False
# 1     True
# 2    False
# Name: Revenue, dtype: bool


# Select * FROM df WHERE Revenue = 111
df[mask]

# Result:
#    Cost    Revenue
# 1  444     111

Do wybierania tylko konkretnych kolumn z wielu kolumn dla danej wartości w Pandzie:

select col_name1, col_name2 from table where column_name = some_value.

Opcje:

df.loc[df['column_name'] == some_value][[col_name1, col_name2]]

Lub

df.query['column_name' == 'some_value'][[col_name1, col_name2]]

Aby dołączyć do tego słynnego pytania( choć trochę za późno): możesz również zrobić df.groupby('column_name').get_group('column_desired_value').reset_index(), aby utworzyć nową ramkę z podaną kolumną o określonej wartości. Np.

import pandas as pd
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split()})
print("Original dataframe:")
print(df)

b_is_two_dataframe = pd.DataFrame(df.groupby('B').get_group('two').reset_index()).drop('index', axis = 1) 
#NOTE: the final drop is to remove the extra index column returned by groupby object
print('Sub dataframe where B is two:')
print(b_is_two_dataframe)

Uruchom to daje:

Original dataframe:
     A      B
0  foo    one
1  bar    one
2  foo    two
3  bar  three
4  foo    two
5  bar    two
6  foo    one
7  foo  three
Sub dataframe where B is two:
     A    B
0  foo  two
1  foo  two
2  bar  two

Możesz również użyć ."zastosowanie": {]}

df.apply(lambda row: row[df['B'].isin(['one','three'])])

W rzeczywistości działa pod względem wiersza (tzn. stosuje funkcję do każdego wiersza).

Wyjście To

   A      B  C   D
0  foo    one  0   0
1  bar    one  1   2
3  bar  three  3   6
6  foo    one  6  12
7  foo  three  7  14

Wyniki są takie same jak przy użyciu, jak wspomniano przez @ unutbu

df[[df['B'].isin(['one','three'])]]

W nowszych wersjach pand, inspirowanych dokumentacją (przeglądanie danych):

df[df["colume_name"] == some_value] #Scalar, True/False..

df[df["colume_name"] == "some_value"] #String

Połącz wiele warunków, umieszczając klauzulę w nawiasach, () i łącząc je z & i | (i/lub). Tak:

df[(df["colume_name"] == "some_value1") & (pd[pd["colume_name"] == "some_value2"])]

Inne filtry

pandas.notna(df["colume_name"]) == True # Not NaN
df['colume_name'].str.contains("text") # Search for "text"
df['colume_name'].str.lower().str.contains("text") # Search for "text", after converting  to lowercase