팬더 데이터 프레임에서 행을 선택하는 방법에는 여러 가지가 있습니다.
- 부울 인덱싱 (
df[df['col'] == value])
- 위치 인덱싱 (
df.iloc[...])
- 라벨 색인 생성 (
df.xs(...))
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)