TLDR; पंडों में तार्किक संचालक हैं &, |और ~, और कोष्ठक (...)महत्वपूर्ण है!
अजगर है and, orऔर notतार्किक ऑपरेटरों scalars साथ काम करने के लिए डिजाइन किए हैं। इसलिए पंडों को एक बेहतर काम करना था और वेक्टरवाइज हासिल करने के लिए बिटवाइज ऑपरेटर्स को ओवरराइड करना था इस कार्यप्रणाली के (तत्व-वार) संस्करण ।
तो अजगर में निम्नलिखित ( exp1और exp2भाव हैं जो एक बूलियन परिणाम का मूल्यांकन करते हैं) ...
exp1 and exp2 # Logical AND
exp1 or exp2 # Logical OR
not exp1 # Logical NOT
... का अनुवाद होगा ...
exp1 & exp2 # Element-wise logical AND
exp1 | exp2 # Element-wise logical OR
~exp1 # Element-wise logical NOT
पांडा के लिए।
यदि आप तार्किक ऑपरेशन करने की प्रक्रिया में हैं ValueError, तो आपको समूहन के लिए कोष्ठक का उपयोग करने की आवश्यकता है:
(exp1) op (exp2)
उदाहरण के लिए,
(df['col1'] == x) & (df['col2'] == y)
और इसी तरह।
बूलियन इंडेक्सिंग : एक सामान्य ऑपरेशन डेटा को फ़िल्टर करने के लिए तार्किक स्थितियों के माध्यम से बूलियन मास्क की गणना करना है। पंडों ने तीन ऑपरेटरों कोप्रदान किया:&तार्किक के|लिए,तार्किक के लिए, और~ तार्किक नहीं के लिए।
निम्नलिखित सेटअप पर विचार करें:
np.random.seed(0)
df = pd.DataFrame(np.random.choice(10, (5, 3)), columns=list('ABC'))
df
A B C
0 5 0 3
1 3 7 9
2 3 5 2
3 4 7 6
4 8 8 1
तार्किक और
के लिए dfऊपर, तुम कहाँ एक <5 और B> 5. यह कंप्यूटिंग प्रत्येक शर्त के लिए मास्क अलग है, और उन्हें Anding द्वारा किया जाता है सभी पंक्तियों को वापस करना चाहते हैं का कहना है।
ओवरलोडेड बिटकॉइन &ऑपरेटर
जारी रखने से पहले, डॉक्स के इस विशेष अंश पर ध्यान दें
एक और आम ऑपरेशन बूलियन वैक्टर का उपयोग डेटा को फ़िल्टर करने के लिए है। ऑपरेटरों हैं: |के लिए or, &के लिए and, और ~के लिए not। इन कोष्ठकों का उपयोग के आधार पर वर्गीकृत किया जाना चाहिए , डिफ़ॉल्ट अजगर द्वारा के बाद से इस तरह के रूप एक अभिव्यक्ति का मूल्यांकन करेंगे df.A > 2 & df.B < 3के रूप में df.A > (2 &
df.B) < 3है, जबकि वांछित मूल्यांकन आदेश है (df.A > 2) & (df.B <
3)।
इसलिए, इसे ध्यान में रखते हुए, तत्व बुद्धिमान तार्किक और बिटवाइज़ ऑपरेटर के साथ कार्यान्वित किया जा सकता है &:
df['A'] < 5
0 False
1 True
2 True
3 True
4 False
Name: A, dtype: bool
df['B'] > 5
0 False
1 True
2 False
3 True
4 True
Name: B, dtype: bool
(df['A'] < 5) & (df['B'] > 5)
0 False
1 True
2 False
3 True
4 False
dtype: bool
और बाद में छानने का कदम बस है,
df[(df['A'] < 5) & (df['B'] > 5)]
A B C
1 3 7 9
3 4 7 6
कोष्ठक संचालकों के डिफ़ॉल्ट पूर्वता क्रम को ओवरराइड करने के लिए कोष्ठक का उपयोग किया जाता है, जो सशर्त संचालकों पर उच्च पूर्वता रखते हैं <और >। अजगर डॉक्स में ऑपरेटर पूर्वता का अनुभाग देखें ।
यदि आप कोष्ठक का उपयोग नहीं करते हैं, तो अभिव्यक्ति का गलत तरीके से मूल्यांकन किया जाता है। उदाहरण के लिए, यदि आप गलती से ऐसा कुछ करने का प्रयास करते हैं
df['A'] < 5 & df['B'] > 5
इसे पार्स किया गया है
df['A'] < (5 & df['B']) > 5
जो बन जाता है,
df['A'] < something_you_dont_want > 5
जो हो जाता है ( जंजीर ऑपरेटर तुलना पर अजगर डॉक्स देखें ),
(df['A'] < something_you_dont_want) and (something_you_dont_want > 5)
जो बन जाता है,
# Both operands are Series...
something_else_you_dont_want1 and something_else_you_dont_want2
जो फेंकता है
ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
तो, वह गलती मत करो! 1
कोष्ठक से बचना समूह
निर्धारण वास्तव में काफी सरल है। अधिकांश ऑपरेटरों के पास डाटाफ्रेम के लिए एक समान बाध्य विधि है। यदि सशर्त संचालकों के बजाय कार्यों का उपयोग करके व्यक्तिगत मुखौटे बनाए जाते हैं, तो आपको मूल्यांकन आदेश निर्दिष्ट करने के लिए परेंस द्वारा समूह की आवश्यकता नहीं होगी:
df['A'].lt(5)
0 True
1 True
2 True
3 True
4 False
Name: A, dtype: bool
df['B'].gt(5)
0 False
1 True
2 False
3 True
4 True
Name: B, dtype: bool
df['A'].lt(5) & df['B'].gt(5)
0 False
1 True
2 False
3 True
4 False
dtype: bool
लचीली तुलना पर अनुभाग देखें । । संक्षेप में, हमारे पास है
╒════╤════════════╤════════════╕
│ │ Operator │ Function │
╞════╪════════════╪════════════╡
│ 0 │ > │ gt │
├────┼────────────┼────────────┤
│ 1 │ >= │ ge │
├────┼────────────┼────────────┤
│ 2 │ < │ lt │
├────┼────────────┼────────────┤
│ 3 │ <= │ le │
├────┼────────────┼────────────┤
│ 4 │ == │ eq │
├────┼────────────┼────────────┤
│ 5 │ != │ ne │
╘════╧════════════╧════════════╛
कोष्ठक से बचने का एक अन्य विकल्प उपयोग DataFrame.query(या eval) है:
df.query('A < 5 and B > 5')
A B C
1 3 7 9
3 4 7 6
मैं है बड़े पैमाने पर दस्तावेज queryऔर evalमें pd.eval का उपयोग कर गतिशील अभिव्यक्ति मूल्यांकन पांडा में () ।
operator.and_
आपको इस कार्य को कार्यात्मक तरीके से करने की अनुमति देता है। आंतरिक रूप से कॉल Series.__and__जो बिटवाइज़ ऑपरेटर से मेल खाती है।
import operator
operator.and_(df['A'] < 5, df['B'] > 5)
# Same as,
# (df['A'] < 5).__and__(df['B'] > 5)
0 False
1 True
2 False
3 True
4 False
dtype: bool
df[operator.and_(df['A'] < 5, df['B'] > 5)]
A B C
1 3 7 9
3 4 7 6
आपको आमतौर पर इसकी आवश्यकता नहीं होगी, लेकिन यह जानना उपयोगी है।
सामान्यीकरण: np.logical_and(और logical_and.reduce)
एक अन्य विकल्प का उपयोग किया जा रहा है np.logical_and, जिसके लिए कोष्ठक के समूहीकरण की आवश्यकता नहीं है:
np.logical_and(df['A'] < 5, df['B'] > 5)
0 False
1 True
2 False
3 True
4 False
Name: A, dtype: bool
df[np.logical_and(df['A'] < 5, df['B'] > 5)]
A B C
1 3 7 9
3 4 7 6
np.logical_andएक ufunc (यूनिवर्सल फ़ंक्शंस) है , और अधिकांश ufuncs में एक reduceविधि है। इसका मतलब यह है कि logical_andअगर आपके पास कई मास्क हैं तो इसे सामान्य करना आसान है । उदाहरण के लिए, करने के लिए और मास्क m1और m2और m3साथ &, तुम क्या करने के लिए होता है
m1 & m2 & m3
हालाँकि, एक आसान विकल्प है
np.logical_and.reduce([m1, m2, m3])
यह शक्तिशाली है, क्योंकि यह आपको अधिक जटिल तर्क के साथ इसके ऊपर निर्माण करने देता है (उदाहरण के लिए, गतिशील रूप से सूची समझ में मास्क उत्पन्न करना और उन सभी को जोड़ना):
import operator
cols = ['A', 'B']
ops = [np.less, np.greater]
values = [5, 5]
m = np.logical_and.reduce([op(df[c], v) for op, c, v in zip(ops, cols, values)])
m
# array([False, True, False, True, False])
df[m]
A B C
1 3 7 9
3 4 7 6
1 - मुझे पता है कि मैं इस बिंदु पर नुकसान पहुंचा रहा हूं, लेकिन कृपया मेरे साथ सहन करें। यह है एक बहुत , बहुत आम शुरुआत की गलती है, और बहुत अच्छी तरह से समझाया जाना चाहिए।
तार्किक या
के लिए dfऊपर, आप सभी पंक्तियों जहां एक == 3 या बी == 7 वापस आना चाहते हैं।
ओवरलोड बिट |
df['A'] == 3
0 False
1 True
2 True
3 False
4 False
Name: A, dtype: bool
df['B'] == 7
0 False
1 True
2 False
3 True
4 False
Name: B, dtype: bool
(df['A'] == 3) | (df['B'] == 7)
0 False
1 True
2 True
3 True
4 False
dtype: bool
df[(df['A'] == 3) | (df['B'] == 7)]
A B C
1 3 7 9
2 3 5 2
3 4 7 6
यदि आपने अभी तक नहीं किया है, तो कृपया तार्किक और पर अनुभाग भी पढ़ें ऊपर दिए , सभी कैविएट यहां लागू होते हैं।
वैकल्पिक रूप से, इस ऑपरेशन के साथ निर्दिष्ट किया जा सकता है
df[df['A'].eq(3) | df['B'].eq(7)]
A B C
1 3 7 9
2 3 5 2
3 4 7 6
operator.or_
Series.__or__हुड के तहत
कॉल ।
operator.or_(df['A'] == 3, df['B'] == 7)
# Same as,
# (df['A'] == 3).__or__(df['B'] == 7)
0 False
1 True
2 True
3 True
4 False
dtype: bool
df[operator.or_(df['A'] == 3, df['B'] == 7)]
A B C
1 3 7 9
2 3 5 2
3 4 7 6
np.logical_or
दो शर्तों के लिए, का उपयोग करें logical_or :
np.logical_or(df['A'] == 3, df['B'] == 7)
0 False
1 True
2 True
3 True
4 False
Name: A, dtype: bool
df[np.logical_or(df['A'] == 3, df['B'] == 7)]
A B C
1 3 7 9
2 3 5 2
3 4 7 6
कई मास्क के लिए, उपयोग करें logical_or.reduce:
np.logical_or.reduce([df['A'] == 3, df['B'] == 7])
# array([False, True, True, True, False])
df[np.logical_or.reduce([df['A'] == 3, df['B'] == 7])]
A B C
1 3 7 9
2 3 5 2
3 4 7 6
तार्किक नहीं
एक मुखौटा दिया, जैसे कि
mask = pd.Series([True, True, False])
यदि आपको प्रत्येक बूलियन मान को उल्टा करने की आवश्यकता है (ताकि अंतिम परिणाम हो [False, False, True] ), तो आप नीचे दिए गए किसी भी तरीके का उपयोग कर सकते हैं।
बिटवाइज़ ~
~mask
0 False
1 False
2 True
dtype: bool
फिर से, भावों को छोटा किया जाना चाहिए।
~(df['A'] == 3)
0 True
1 False
2 False
3 True
4 True
Name: A, dtype: bool
यह आंतरिक रूप से कहता है
mask.__invert__()
0 False
1 False
2 True
dtype: bool
लेकिन इसे सीधे उपयोग न करें।
operator.inv
आंतरिक रूप __invert__से श्रृंखला पर कॉल करता है।
operator.inv(mask)
0 False
1 False
2 True
dtype: bool
np.logical_not
यह संख्यात्मक संस्करण है।
np.logical_not(mask)
0 False
1 False
2 True
dtype: bool
ध्यान दें, np.logical_andके लिए प्रतिस्थापित किया जा सकता np.bitwise_and, logical_orके साथ bitwise_or, और logical_notसाथ invert।