मैं पायथन में एक बूलियन के विपरीत (नकार) कैसे प्राप्त करूं?

Question 1

निम्नलिखित नमूने के लिए:

def fuctionName(int, bool):
    if int in range(...):
        if bool == True:
            return False
        else:
            return True

क्या दूसरा इफ-स्टेटमेंट छोड़ने का कोई तरीका है? बस कंप्यूटर को बूलियन के विपरीत लौटने के लिए कहना है bool?

Question 2

आप बस उपयोग कर सकते हैं:

return not bool

Question 3

`not`ऑपरेटर (तार्किक निषेध)

शायद सबसे अच्छा तरीका ऑपरेटर का उपयोग कर रहा है not:

>>> value = True
>>> not value
False

>>> value = False
>>> not value
True

इसलिए अपने कोड के बजाय:

if bool == True:
    return False
else:
    return True

आप उपयोग कर सकते हैं:

return not bool

फ़ंक्शन के रूप में तार्किक निषेध

operatorमॉड्यूल में भी दो कार्य हैं operator.not_और यह उर्फ operator.__not__के मामले में है जब आपको ऑपरेटर के बजाय फ़ंक्शन की आवश्यकता होती है:

>>> import operator
>>> operator.not_(False)
True
>>> operator.not_(True)
False

ये उपयोगी हो सकते हैं यदि आप एक फ़ंक्शन का उपयोग करना चाहते हैं जिसके लिए एक पेडीकैट-फ़ंक्शन या कॉलबैक की आवश्यकता होती है।

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

>>> lst = [True, False, True, False]
>>> list(map(operator.not_, lst))
[False, True, False, True]

>>> lst = [True, False, True, False]
>>> list(filter(operator.not_, lst))
[False, False]

बेशक एक समान lambdaकार्य के साथ भी प्राप्त किया जा सकता है :

>>> my_not_function = lambda item: not item

>>> list(map(my_not_function, lst))
[False, True, False, True]

`~`बूलियन्स पर बिटवाइज़ इनवर्टर ऑपरेटर का उपयोग न करें

बिटवाइज इनवर्टर ऑपरेटर ~या समकक्ष ऑपरेटर फ़ंक्शन operator.inv(या अन्य 3 उपनामों में से एक) का उपयोग करने के लिए किसी को लुभाया जा सकता है । लेकिन क्योंकि परिणाम boolका एक उपवर्ग intअप्रत्याशित हो सकता है क्योंकि यह "उलटा बूलियन" वापस नहीं करता है, यह "उलटा पूर्णांक" लौटाता है:

>>> ~True
-2
>>> ~False
-1

के ऐसा इसलिए है क्योंकि Trueके बराबर है 1और Falseकरने के लिए 0और बिटवाइज़ उलट की बिटवाइज़ प्रतिनिधित्व पर चल रही है पूर्णांकों 1 और 0।

इसलिए इनका उपयोग "नकारात्मक" करने के लिए नहीं किया जा सकता है bool।

NumPy सरणियों (और उपवर्ग) के साथ ऋणात्मकता

आप (या की तरह उपवर्गों NumPy सरणी के साथ काम कर रहे हैं pandas.Seriesया pandas.DataFrame) युक्त बूलियन्स आप वास्तव में बिटवाइज़ उलटा ऑपरेटर (उपयोग कर सकते हैं ~नकारना करने के लिए) सभी एक सरणी में बूलियन्स:

>>> import numpy as np
>>> arr = np.array([True, False, True, False])
>>> ~arr
array([False,  True, False,  True])

या समकक्ष NumPy फ़ंक्शन:

>>> np.bitwise_not(arr)
array([False,  True, False,  True])

आप NumPy सरणियों पर notऑपरेटर या operator.notफ़ंक्शन का उपयोग नहीं कर सकते क्योंकि इन के लिए आवश्यक है कि ये एकल bool(बूलियनों की एक सरणी नहीं) लौटें , हालांकि NumPy में एक तार्किक नहीं फ़ंक्शन भी शामिल है जो तत्व-वार काम करता है:

>>> np.logical_not(arr)
array([False,  True, False,  True])

यह गैर-बूलियन सरणियों पर भी लागू किया जा सकता है:

>>> arr = np.array([0, 1, 2, 0])
>>> np.logical_not(arr)
array([ True, False, False,  True])

अपनी कक्षाओं को अनुकूलित करना

notboolमूल्य पर कॉल करके काम करता है और परिणाम को नकारता है। सबसे सरल मामले में सत्य मूल्य सिर्फ __bool__ऑब्जेक्ट पर कॉल करेगा ।

तो लागू करके __bool__(या __nonzero__पायथन 2 में) आप सत्य मूल्य को अनुकूलित कर सकते हैं और इस तरह से परिणाम not:

class Test(object):
    def __init__(self, value):
        self._value = value

    def __bool__(self):
        print('__bool__ called on {!r}'.format(self))
        return bool(self._value)

    __nonzero__ = __bool__  # Python 2 compatibility

    def __repr__(self):
        return '{self.__class__.__name__}({self._value!r})'.format(self=self)

मैंने एक printबयान जोड़ा है ताकि आप पुष्टि कर सकें कि यह वास्तव में विधि कहती है:

>>> a = Test(10)
>>> not a
__bool__ called on Test(10)
False

इसी तरह आप __invert__लागू होने पर व्यवहार को लागू करने के लिए विधि को लागू कर सकते हैं ~:

class Test(object):
    def __init__(self, value):
        self._value = value

    def __invert__(self):
        print('__invert__ called on {!r}'.format(self))
        return not self._value

    def __repr__(self):
        return '{self.__class__.__name__}({self._value!r})'.format(self=self)

एक printकॉल के साथ फिर से देखने के लिए कि यह वास्तव में कहा जाता है:

>>> a = Test(True)
>>> ~a
__invert__ called on Test(True)
False

>>> a = Test(False)
>>> ~a
__invert__ called on Test(False)
True

हालाँकि इसे लागू __invert__करना भ्रामक हो सकता है क्योंकि यह व्यवहार "सामान्य" पायथन व्यवहार से अलग है। यदि आप कभी ऐसा करते हैं तो स्पष्ट रूप से दस्तावेज दें और सुनिश्चित करें कि इसका उपयोग बहुत अच्छा (और आम) उपयोग-मामला है।

Question 4

पायथन में एक "नहीं" ऑपरेटर है, है ना? क्या यह सिर्फ "नहीं" नहीं है? जैसे की,

  return not bool

Question 5

आप बस बूलियन सरणी की तुलना कर सकते हैं। उदाहरण के लिए

X = [True, False, True]

फिर

Y = X == False

आपको देगा

Y = [False, True, False]

Question 6

यदि आप एक टॉगल को लागू करने का प्रयास कर रहे हैं , ताकि किसी भी समय आप एक निरंतर कोड को उसके उपेक्षित होने पर फिर से चलाएं, तो आप इसे प्राप्त कर सकते हैं:

try:
    toggle = not toggle
except NameError:
    toggle = True

इस कोड को चलाने से सबसे पहले सेट होगा toggle करने के लिए Trueऔर किसी भी समय इस स्निपेट कहा जाता IST, टॉगल नकार दिया जाएगा।

Question 7

यहाँ दिया गया स्वीकृत उत्तर दिए गए परिदृश्य के लिए सबसे सही है।

इसने मुझे आश्चर्यचकित कर दिया, हालांकि सामान्य रूप से एक बूलियन मूल्य में प्रवेश करने के बारे में। यह स्वीकार किए जाते हैं कि यहां समाधान एक लाइनर के रूप में काम करता है, और एक और एक लाइनर है जो काम करता है। यह मानते हुए कि आपके पास एक चर "n" है जिसे आप जानते हैं कि एक बूलियन है, इसे उलटने के सबसे आसान तरीके हैं:

n = n is False

जो मेरा मूल समाधान था, और फिर इस प्रश्न से स्वीकृत उत्तर:

n = not n

उत्तरार्द्ध आईएस अधिक स्पष्ट है, लेकिन मैंने प्रदर्शन के बारे में सोचा और इसके माध्यम से हॉक किया timeit- और यह पता चलता है n = not nकि बूलियन मूल्य को उल्टा करने का सबसे तेज़ तरीका भी है।

Question 8

उसी परिणाम को प्राप्त करने का एक और तरीका, जो मुझे एक पांडा डेटाफ्रेम के लिए उपयोगी लगा।

जैसा कि नीचे mousetail द्वारा सुझाया गया है:

bool(1 - False)

bool(1 - True)