python - "और"/"या" ऑपरेटर के अजीब उपयोग




operators logical-operators (6)

मैं अजगर को सीखने की कोशिश कर रहा हूं और कुछ ऐसे कोड आए हैं जो अच्छे और छोटे हैं लेकिन पूरी तरह से समझ में नहीं आते हैं

संदर्भ था:

def fn(*args):
    return len(args) and max(args)-min(args)

मुझे वह मिल रहा है जो वह कर रहा है, लेकिन अजगर ऐसा क्यों करता है - यानी ट्रू / फाल्स के बजाय वैल्यू लौटाता है?

10 and 7-2

रिटर्न 5. इसी तरह, बदलने और करने के लिए या कार्यक्षमता में परिवर्तन का परिणाम देगा। इसलिए

10 or 7 - 2

10 लौटेगा।

क्या यह कानूनी / विश्वसनीय शैली है, या इस पर कोई गौण हैं?


क्या यह कानूनी / विश्वसनीय शैली है, या इस पर कोई गौण हैं?

मैं इस सवाल को जोड़ना चाहूंगा कि यह न केवल वैध और विश्वसनीय है, बल्कि अल्ट्रा व्यावहारिक भी है। ये रहा एक सरल उदाहरण:

>>>example_list = []
>>>print example_list or 'empty list'
empty list

इसलिए आप वास्तव में अपने लाभ पर इसका उपयोग कर सकते हैं। यह कैसे मैं इसे देख रहा हूं:

Or संचालक

पायथन or ऑपरेटर पहला ट्रुथ-वाई मान, या अंतिम मान लौटाता है, और रुक जाता है

And ऑपरेटर

पायथन and ऑपरेटर पहला गलत-वाई मान, या अंतिम मान लौटाता है, और बंद हो जाता है

परदे के पीछे

अजगर में, 0. को छोड़कर सभी संख्याओं को True माना जाता है।

0 and 10 

के समान है:

False and True

जो स्पष्ट रूप से False । इसलिए यह तर्कसंगत है कि यह 0 देता है


क्या यह कानूनी / विश्वसनीय शैली है, या इस पर कोई गौण हैं?

यह वैध है, यह एक शॉर्ट सर्किट मूल्यांकन है जहां अंतिम मान लौटाया जाता है।

आप एक अच्छा उदाहरण प्रदान करते हैं। यदि कोई तर्कों को पारित नहीं किया जाता है, तो फ़ंक्शन 0 वापस आ जाएगा, और कोड को बिना किसी तर्कों के विशेष मामले की जांच करने की आवश्यकता नहीं है।

इसका उपयोग करने का एक और तरीका है, एक खाली सूची की तरह, कोई भी परस्पर तर्क करने के लिए कोई भी तर्क डिफ़ॉल्ट नहीं है:

def fn(alist=None):
    alist = alist or []
    ....

यदि कुछ गैर-सत्य मूल्य को खाली सूची में बदलने के लिए पारित किया जाता है, if एक बयान से बचने के लिए आसान तरीका और उत्परिवर्ती डिफ़ॉल्ट तर्क नुकसान


टी एल; डॉ

हम दो तार्किक ऑपरेटरों and / or के दो व्यवहार को सारांशित करके शुरू करते हैं। ये मुहावरे नीचे हमारी चर्चा का आधार बनेंगे।

and

पहला फल्सी मान लौटाएं यदि कोई हैं, तो अभिव्यक्ति में अंतिम मान लौटाएं।

or

पहला सत्य मान लौटाएँ यदि कोई हो, और अंतिम भाव अभिव्यक्ति में लौटाएँ।

इस तालिका में, विशेष रूप से डॉक्स में व्यवहार को संक्षेप में प्रस्तुत किया गया है :

केवल ऑपरेटर अपने ऑपरेटर की परवाह किए बिना बूलियन मान लौटाता है, ऑपरेटर not

"सत्यता", और "सत्य" मूल्यांकन

बयान

len(args) and max(args) - min(args)

यह कहने के लिए कि "यदि args खाली नहीं है, तो max(args) - min(args) का परिणाम लौटाएं, अन्यथा 0 वापस करें।" सामान्य तौर पर, यह एक if-else अभिव्यक्ति का अधिक संक्षिप्त प्रतिनिधित्व है। उदाहरण के लिए,

exp1 and exp2

को (मोटे तौर पर) अनुवाद करना चाहिए:

r1 = exp1
if not r1:
    r1 = exp2

या, समकक्ष,

r1 = exp1 if exp1 else exp2

जहां exp1 और exp2 मनमाने ढंग से पाइथन ऑब्जेक्ट्स या कुछ ऑब्जेक्ट लौटाने वाले एक्सप्रेशन हैं। तार्किक and or ऑपरेटरों के उपयोग को समझने की कुंजी यह समझ रही है कि वे बूलियन मूल्यों को संचालित करने या वापस करने के लिए प्रतिबंधित नहीं हैं। सत्यता मूल्य वाली किसी भी वस्तु का परीक्षण यहाँ किया जा सकता है। इसमें int , str , list , dict , tuple , set , NoneType और उपयोगकर्ता परिभाषित ऑब्जेक्ट शामिल हैं। लघु परिपालन नियम अभी भी लागू होते हैं।

लेकिन सच्चाई क्या है?
यह संदर्भित करता है कि सशर्त अभिव्यक्तियों में उपयोग किए जाने पर वस्तुओं का मूल्यांकन कैसे किया जाता है। @ पैट्रिक हाउ ने इस पोस्ट में सच्चाई को संक्षेप में प्रस्तुत किया है।

निम्नलिखित को छोड़कर सभी मूल्यों को "सत्य" माना जाता है, जो "मिथ्या" हैं:

  • None
  • False
  • 0
  • 0.0
  • 0j
  • Decimal(0)
  • Fraction(0, 1)
  • [] - एक खाली list
  • {} - एक खाली dict
  • () - एक खाली tuple
  • '' - एक खाली str
  • b'' - एक खाली bytes
  • set() - एक खाली set
  • एक खाली range , range तरह range(0)
  • जिसके लिए वस्तुएं
    • obj.__bool__() रिटर्न False
    • obj.__len__() रिटर्न 0

एक "सत्य" मान if या while बयानों द्वारा किए गए चेक को संतुष्ट करेगा। हम "सत्य" और "मिथ्या" का उपयोग करने के लिए bool मूल्यों को अलग करते हैं True और False

कैसे and कैसे काम करता है

हम ओपी के सवाल पर एक चर्चा के रूप में निर्माण करते हैं कि इन उदाहरणों में ये ऑपरेटर कैसे हैं।

परिभाषा के साथ एक फ़ंक्शन दिया

def foo(*args):
    ...

मैं शून्य या अधिक तर्कों की सूची में न्यूनतम और अधिकतम मूल्य के बीच के अंतर को कैसे वापस करूं?

न्यूनतम और अधिकतम खोजना आसान है (इनबिल्ट फ़ंक्शन का उपयोग करें!)। यहां एकमात्र स्नैग उचित रूप से कोने के मामले को संभाल रहा है जहां तर्क सूची खाली हो सकती है (उदाहरण के लिए, कॉलिंग foo() )। हम एक ही लाइन में ऑपरेटर and ऑपरेटर दोनों का धन्यवाद कर सकते हैं:

def foo(*args):
     return len(args) and max(args) - min(args)

foo(1, 2, 3, 4, 5)
# 4

foo()
# 0

चूँकि प्रयोग किया जाता है, दूसरी अभिव्यक्ति का भी मूल्यांकन किया जाना चाहिए यदि पहला True । ध्यान दें, यदि पहली अभिव्यक्ति का मूल्यांकन सत्य है, तो वापसी मूल्य हमेशा दूसरी अभिव्यक्ति का परिणाम होता है। यदि पहली अभिव्यक्ति का मूल्यांकन फल्सी होने के लिए किया जाता है, तो लौटाया गया परिणाम पहली अभिव्यक्ति का परिणाम है।

उपरोक्त फ़ंक्शन में, यदि foo एक या अधिक तर्क प्राप्त करता है, तो len(args) 0 (एक सकारात्मक संख्या) से अधिक है, इसलिए लौटाया गया परिणाम max(args) - min(args) । OTOH, यदि कोई तर्क पारित नहीं होता है, तो len(args) 0 जो कि मिथ्या है, और 0 वापस आ गया है।

ध्यान दें कि इस फ़ंक्शन को लिखने का एक वैकल्पिक तरीका होगा:

def foo(*args):
    if not len(args):
        return 0

    return max(args) - min(args)

या, अधिक संक्षेप में,

def foo(*args):
    return 0 if not args else max(args) - min(args)

यदि निश्चित रूप से, इनमें से कोई भी कार्य किसी भी प्रकार की जाँच नहीं करता है, तो जब तक आप प्रदान किए गए इनपुट पर पूरी तरह से भरोसा नहीं करते हैं, तब तक इन निर्माणों की सादगी पर भरोसा न करें

कैसे or काम करता है

मैं एक विपरीत उदाहरण के साथ or इसी तरह के काम की व्याख्या करता हूं।

परिभाषा के साथ एक फ़ंक्शन दिया

def foo(*args):
    ...

9000 से अधिक संख्याओं को वापस करने के लिए आप कैसे पूरा करेंगे?

हम यहां कोने के मामले का उपयोग करते हैं or संभालते हैं। हम foo को इस प्रकार परिभाषित करते हैं:

def foo(*args):
     return [x for x in args if x > 9000] or 'No number over 9000!'

foo(9004, 1, 2, 500)
# [9004]

foo(1, 2, 3, 4)
# 'No number over 9000!'

foo 9000 से अधिक संख्या को बनाए रखने के लिए सूची में एक निस्पंदन करता है। यदि ऐसी कोई संख्या मौजूद है, तो सूची की समझ का नतीजा एक गैर-रिक्त सूची है जो सत्य है, इसलिए इसे वापस कर दिया जाता है (यहां कार्रवाई में छोटी चक्कर लगाना)। यदि ऐसी कोई संख्या मौजूद नहीं है, तो सूची COMP का परिणाम [] जो गलत है। तो अब दूसरी अभिव्यक्ति का मूल्यांकन किया जाता है (एक गैर-रिक्त स्ट्रिंग) और वापस कर दिया जाता है।

सशर्त का उपयोग करके, हम इस फ़ंक्शन को फिर से लिख सकते हैं,

def foo(*args):
    r = [x for x in args if x > 9000]
    if not r:
        return 'No number over 9000!' 

    return r

पहले की तरह, यह संरचना त्रुटि से निपटने के मामले में अधिक लचीली है।


सरल तरीके से समझने के लिए,

और: if first_val is False return first_val else second_value

उदाहरण के लिए:

1 and 2 # here it will return 2 because 1 is not False

परंतु,

0 and 2 # will return 0 because first value is 0 i.e False

और => यदि कोई झूठा है, तो वह झूठा होगा। यदि दोनों सत्य हैं तो केवल सत्य बनेंगे

या: if first_val is False return second_val else first_value

कारण यह है कि यदि पहला गलत है, तो जांच लें कि 2 सही है या नहीं।

उदाहरण के लिए:

1 or 2 # here it will return 1 because 1 is not False

परंतु,

0 or 2 # will return 2 because first value is 0 i.e False

या => यदि कोई असत्य है, तो वह सत्य होगा। इसलिए यदि पहला मूल्य गलत है तो कोई बात नहीं कि 2 मान क्या होगा। इसलिए यह दूसरा मूल्य देता है जो कभी भी हो सकता है।

यदि कोई सत्य है तो वह सत्य हो जाएगा। अगर दोनों झूठे हैं तो यह गलत हो जाएगा।


पायथन डॉक्स से उद्धरण

ध्यान दें कि न तो and न ही or उस मूल्य को प्रतिबंधित करें और टाइप करें कि वे False और True , लेकिन अंतिम मूल्यांकन किए गए तर्क को वापस लौटाएं। यह कभी-कभी उपयोगी होता है, उदाहरण के लिए, यदि s एक स्ट्रिंग है जिसे डिफ़ॉल्ट मान द्वारा प्रतिस्थापित किया जाना चाहिए यदि यह खाली है, तो अभिव्यक्ति s or 'foo' वांछित मान प्राप्त करता है।

तो, यह है कि पायथन को बूलियन अभिव्यक्तियों का मूल्यांकन करने के लिए कैसे बनाया गया था और उपरोक्त प्रलेखन हमें एक अंतर्दृष्टि देता है कि उन्होंने ऐसा क्यों किया।

एक बूलियन मूल्य प्राप्त करने के लिए बस इसे टाइप करें।

return bool(len(args) and max(args)-min(args))

क्यूं कर?

लघु सर्किटिंग।

उदाहरण के लिए:

2 and 3 # Returns 3 because 2 is Truthy so it has to check 3 too
0 and 3 # Returns 0 because 0 is Falsey and there's no need to check 3 at all

वही इसके लिए भी जाता है, or यह है कि यह अभिव्यक्ति को लौटा देगा जो सत्य है जैसे ही यह पता चलता है, क्योंकि बाकी अभिव्यक्ति का मूल्यांकन अनावश्यक है।

हार्ड True या False वापस करने के बजाय, पायथन ने ट्रू या फाल्सी लौटाया , जो वैसे भी True या False का मूल्यांकन करने वाले हैं। आप अभिव्यक्ति का उपयोग कर सकते हैं, और यह अभी भी काम करेगा।

सत्य और असत्य क्या है, यह जानने के लिए पैट्रिक हॉ का जवाब देखें


और, या बूलियन तर्क प्रदर्शन करते हैं, लेकिन जब वे तुलना कर रहे होते हैं तो वे वास्तविक मूल्यों में से एक को वापस करते हैं। उपयोग करते समय और , मान का मूल्यांकन बूलियन संदर्भ में बाएं से दाएं किया जाता है। 0, '', [], (), {}, और बूलियन संदर्भ में कोई भी गलत नहीं है; बाकी सब सच है।

यदि बूलियन संदर्भ में सभी मान सत्य हैं, और अंतिम मान लौटाता है।

>>> 2 and 5
5
>>> 2 and 5 and 10
10

यदि कोई मूल्य बूलियन संदर्भ में गलत है और पहला गलत मान लौटाता है।

>>> '' and 5
''
>>> 2 and 0 and 5
0

तो कोड

return len(args) and max(args)-min(args)

max(args)-min(args) का मान लौटाता है जब args होता है तो यह len(args) जो 0 होता है।







logical-operators