팬더 데이터 프레임에서 행을 선택하는 방법에는 여러 가지가 있습니다.

1. 부울 인덱싱 ( df[df['col'] == value])
2. 위치 인덱싱 ( df.iloc[...])
3. 라벨 색인 생성 ( df.xs(...))
4. df.query(...) API

아래에서는 특정 기술을 사용할 때 조언과 함께 각각의 예를 보여줍니다. 우리의 기준이 열 'A'== 이라고 가정하십시오.'foo'

(성능에 대한 참고 사항 : 각 기본 유형에 대해 pandas API를 사용하여 작업을 단순하게 유지하거나 API 외부에서 일반적으로 numpy로 이동하여 작업 속도를 높일 수 있습니다.)

설정
첫 번째로 필요한 것은 행을 선택하기위한 기준으로 작용할 조건을 식별하는 것입니다. OP의 경우부터 시작하고 column_name == some_value다른 일반적인 사용 사례를 포함시킵니다.

@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})

부울 인덱싱

… 부울 인덱싱은 각 행의 'A'열의 실제 값 이와 같은 'foo'값을 찾은 다음 해당 값을 사용하여 유지할 행을 식별해야합니다. 일반적으로이 계열의 이름은 진리 값의 배열입니다 mask. 우리는 여기서도 그렇게 할 것입니다.

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

이것은이 작업을 수행 할 수있는 가장 간단한 방법 중 하나이며 성능 또는 직관적 성이 문제가되지 않는 경우이 방법을 선택해야합니다. 그러나 성능이 중요한 경우을 만드는 대체 방법을 고려할 수 있습니다 mask.

2. 위치 인덱싱

위치 인덱싱 ( df.iloc[...])에는 사용 사례가 있지만이 중 하나가 아닙니다. 슬라이스 할 위치를 식별하려면 먼저 위에서와 동일한 부울 분석을 수행해야합니다. 이를 통해 동일한 작업을 수행하기위한 추가 단계를 수행 할 수 있습니다.

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. 라벨 색인

라벨 인덱싱은 매우 유용 할 수 있지만이 경우 더 많은 작업을 수행하고 있습니다.

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이 작업을 수행하는 매우 우아하고 직관적 인 방법이지만 종종 느립니다. 그러나 아래의 타이밍에주의를 기울이면 대용량 데이터의 경우 쿼리가 매우 효율적입니다. 표준 접근법보다 더 많고 내 제안과 비슷한 규모입니다.

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

내가 선호하는 것은 Boolean mask

실제 개선 방법은을 만드는 방법을 수정하여 수행 할 수 있습니다 Boolean mask.

mask대안 1 기본 배열을 사용하고 다른 배열을 만드는 오버 헤드를 피하십시오
numpypd.Series

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

마지막에 더 완전한 시간 테스트를 보여 드리지만 샘플 데이터 프레임을 사용하여 얻을 수있는 성능 이점을 살펴보십시오. 먼저, 우리는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)

어레이를 mask사용한 평가 numpy는 ~ 30 배 더 빠릅니다. 이것은 부분적으로 인해 numpy평가는 종종 빠르다. 또한 인덱스 및 해당 pd.Series개체를 작성하는 데 필요한 오버 헤드가 부족하기 때문입니다 .

다음으로 우리는 하나 mask와 다른 것으로 슬라이싱하는 타이밍을 살펴볼 것 입니다.

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대안 2
데이터 프레임도 재구성 할 수있었습니다. 데이터 프레임을 재구성 할 때주의해야 할 사항이 있습니다. dtypes그렇게 할 때는 주의해야합니다 !

df[mask]우리 대신에

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

예를 들어, 데이터 프레임이 혼합 유형 인 df.values경우 결과 배열 을 얻을 때 dtype object새 데이터 프레임의 모든 열은입니다 dtype object. 따라서 astype(df.dtypes)잠재적 인 성능 향상이 필요합니다 .

%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)

그러나 데이터 프레임이 혼합 유형이 아닌 경우이를 수행하는 데 매우 유용한 방법입니다.

주어진

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)

대

%%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대안 3
@unutbu는 또한 일련의 값에있는 pd.Series.isin각 요소를 설명 하는 데 사용하는 방법을 보여줍니다 df['A']. 우리의 값 집합이 하나의 값 집합 인 경우 동일한 것으로 평가됩니다 'foo'. 그러나 필요한 경우 더 큰 값 세트를 포함하도록 일반화합니다. 더 일반적인 솔루션이지만 여전히 매우 빠릅니다. 유일한 손실은 개념에 익숙하지 않은 사람들에게 직관적입니다.

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

그러나 이전과 마찬가지로 numpy거의 아무것도 희생하지 않으면 서 성능을 향상시키는 데 활용할 수 있습니다 . 우리는 사용할 것이다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

타이밍
나는 다른 게시물에서 언급 된 다른 개념들도 참고로 포함 할 것이다.
아래 코드

이 테이블의 각 열은 각 함수를 테스트하는 다른 길이의 데이터 프레임을 나타냅니다. 각 열은 기준 인덱스가 지정된 가장 빠른 함수와 함께 소요 된 상대 시간을 보여줍니다 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

가장 빠른 시간이 mask_with_values와 (과) 공유되는 것 같습니다.mask_with_in1d

res.T.plot(loglog=True)

기능

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]

테스팅

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)

특수 타이밍 전체 데이터 프레임에 대해
하나의 객체 dtype가 아닌 특수한 경우를 살펴보십시오 .
아래 코드

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

재건은 몇 백 행을 넘을 가치가 없다는 것이 밝혀졌습니다.

spec.T.plot(loglog=True)

기능

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
)

테스팅

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)

답변

select * from table where column_name = some_value

table[table.column_name == some_value]

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

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

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

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

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

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

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

# Example dataframe
df = pd.DataFrame({'Sender email':['ex@example.com', "reply@shop.com", "buy@shop.com"]})

     Sender email
0  ex@example.com
1  reply@shop.com
2    buy@shop.com

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

     Sender email
1  reply@shop.com
2    buy@shop.com

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

     Sender email
1  reply@shop.com
2    buy@shop.com

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

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

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