पांडा डेटा फ़्रेम से पंक्तियों का चयन करने के कई तरीके हैं:
- बूलियन अनुक्रमण (
df[df['col'] == value))
- स्थितिगत अनुक्रमण (
df.iloc[...])
- लेबल अनुक्रमण (
df.xs(...))
df.query(...) एपीआई
नीचे मैं आपको कुछ तकनीकों का उपयोग करने के लिए सलाह के साथ प्रत्येक के उदाहरण दिखाता हूं। मान लें कि हमारी कसौटी कॉलम 'A'== है'foo'
(प्रदर्शन पर ध्यान दें: प्रत्येक आधार प्रकार के लिए, हम पांडा एपीआई का उपयोग करके चीजों को सरल रख सकते हैं या हम एपीआई के बाहर उद्यम कर सकते हैं, आमतौर पर numpyऔर चीजों को गति देते हैं।)
सेटअप
पहली चीज़ जो हमें चाहिए वह है ऐसी स्थिति की पहचान करना जो पंक्तियों के चयन के लिए हमारी कसौटी के रूप में कार्य करेगी। हम ओपी के मामले से शुरू करेंगे 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()एपीआई
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
अंतर्निहित 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)
सरणी के 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)