DataFramePandas의 일부 열에 있는 값을 기반으로 행을 선택하려면 어떻게 해야 합니까?
SQL에서는 다음을 사용합니다.
SELECT *
FROM table
WHERE column_name = some_value
반응형
열 값이 스칼라 인 행을 선택하려면 다음 some_value을 사용 ==하십시오.
df.loc[df['column_name'] == some_value]
열 값이 iterable에 있는 행을 선택하려면 다음 some_values을 사용 isin하십시오.
df.loc[df['column_name'].isin(some_values)]
여러 조건을 다음과 결합 &:
df.loc[(df['column_name'] >= A) & (df['column_name'] <= B)]
괄호에 유의하십시오. Python의 연산자 우선 순위 규칙 으로 인해 및 &보다 더 밀접하게 바인딩 됩니다. 따라서 마지막 예의 괄호가 필요합니다. 괄호 없이<=>=
df['column_name'] >= A & df['column_name'] <= B
다음과 같이 구문 분석됩니다.
df['column_name'] >= (A & df['column_name']) <= B
Series 의 Truth 값이 되는 결과 는 모호한 오류 입니다.
열 값 이 같지 않은 some_value 행을 선택하려면 다음 을 사용 !=하십시오.
df.loc[df['column_name'] != some_value]
isin부울 계열을 반환하므로 값이 in 에 없는some_values 행을 선택하려면 다음 을 사용하여 부울 계열을 무효화합니다 ~.
df.loc[~df['column_name'].isin(some_values)]
예를 들어,
import pandas as pd
import 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})
print(df)
# A B C D
# 0 foo one 0 0
# 1 bar one 1 2
# 2 foo two 2 4
# 3 bar three 3 6
# 4 foo two 4 8
# 5 bar two 5 10
# 6 foo one 6 12
# 7 foo three 7 14
print(df.loc[df['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
포함하려는 값이 여러 개인 경우 목록(또는 더 일반적으로 모든 반복 가능)에 넣고 다음을 사용합니다 isin.
print(df.loc[df['B'].isin(['one','three'])])
수익률
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
그러나 이 작업을 여러 번 수행하려면 먼저 인덱스를 만든 다음 다음을 사용하는 것이 더 효율적입니다 df.loc.
df = df.set_index(['B'])
print(df.loc['one'])
수익률
A C D
B
one foo 0 0
one bar 1 2
one foo 6 12
또는 인덱스의 여러 값을 포함하려면 다음을 사용 df.index.isin하십시오.
df.loc[df.index.isin(['one','two'])]
수익률
A C D
B
one foo 0 0
one bar 1 2
two foo 2 4
two foo 4 8
two bar 5 10
one foo 6 12
Pandas 데이터 프레임에서 행을 선택하는 방법에는 여러 가지가 있습니다.
- 부울 인덱싱(
df[df['col'] == value] ) - 위치 인덱싱(
df.iloc[...]) - 레이블 인덱싱(
df.xs(...)) df.query(...)API
아래에서는 특정 기술을 언제 사용해야 하는지에 대한 조언과 함께 각각의 예를 보여 드리겠습니다. 기준이 column '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})
1. 부울 인덱싱
... 부울 인덱싱을 위해서는 각 행의 '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
.NET Framework를 만드는 방법을 수정하여 실제 개선할 수 있습니다 Boolean mask.
mask대안 1
기본 NumPy 배열을 사용하고 다른 배열을 생성하는 오버헤드를 피하십시오.pd.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)
maskNumPy 배열로 평가하면 ~ 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]열 값을 기반으로 행을 제공하는 행입니다 .222
여러 조건도 가능합니다.
df[(df.foo == 222) | (df.bar == 444)]
# bar foo
# 1 444 111
# 2 555 222
그러나 그 시점에서 쿼리 함수를 사용하는 것이 좋습니다. 덜 장황하고 동일한 결과를 생성하기 때문입니다.
df.query('foo == 222 | bar == 444')
반응형
'파이썬' 카테고리의 다른 글
| [python] **(이중 별표/별표) 및 *(별표/별표)는 매개변수에 대해 무엇을 합니까? (0) | 2022.08.22 |
|---|---|
| [python] 시간 지연은 어떻게 합니까? [복제하다] (0) | 2022.08.22 |
| [python] 할당 후 예기치 않게 변경되지 않도록 목록을 복제하려면 어떻게 해야 합니까? (0) | 2022.08.22 |
| [python] Python의 목록 메서드 추가와 확장의 차이점은 무엇입니까? (0) | 2022.08.22 |
| [python] 참조로 변수를 전달하려면 어떻게 해야 합니까? (0) | 2022.08.21 |