Comment obtenir l'opposé (négation) d'un booléen en Python ?

Question

Pour l'échantillon suivant :

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

Existe-t-il un moyen de sauter la deuxième déclaration if ? Juste pour dire à l'ordinateur de retourner l'opposé du booléen. bool ?

Answer 1

Vous pouvez simplement utiliser :

return not bool

Answer 2

El not opérateur (négation logique)

Le meilleur moyen est probablement d'utiliser l'opérateur not :

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

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

Donc à la place de votre code :

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

Vous pourriez utiliser :

return not bool

La négation logique comme fonction

Il existe également deux fonctions dans le operator module operator.not_ et son alias operator.__not__ au cas où vous en auriez besoin comme fonction plutôt que comme opérateur :

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

Ils peuvent être utiles si vous souhaitez utiliser une fonction qui nécessite une fonction prédicat ou une fonction de rappel.

Par exemple map o 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]

Bien sûr, on pourrait également obtenir la même chose avec un équivalent lambda fonction :

>>> my_not_function = lambda item: not item

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

N'utilisez pas l'opérateur d'inversion bit à bit ~ sur les booléens

On pourrait être tenté d'utiliser l'opérateur d'inversion bit à bit ~ ou la fonction d'opérateur équivalente operator.inv (ou l'un des 3 autres alias qui s'y trouvent). Mais parce que bool est une sous-classe de int le résultat pourrait être inattendu car il ne renvoie pas le "booléen inverse", il renvoie le "nombre entier inverse" :

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

C'est parce que True est équivalent à 1 y False a 0 et l'inversion bit à bit opère sur la représentation bit à bit de l'élément nombres entiers 1 y 0 .

Elles ne peuvent donc pas être utilisées pour "nier" une bool .

Négation avec les tableaux NumPy (et les sous-classes)

Si vous utilisez des tableaux NumPy (ou des sous-classes telles que pandas.Series o pandas.DataFrame ) contenant des booléens, vous pouvez en fait utiliser l'opérateur inverse bitwise ( ~ ) pour annuler tous booléens dans un tableau :

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

Ou la fonction NumPy équivalente :

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

Vous ne pouvez pas utiliser le not ou l'opérateur operator.not sur les tableaux NumPy parce que ces derniers nécessitent de retourner un unique bool (pas un tableau de booléens), mais NumPy contient également une fonction logique not qui fonctionne par élément :

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

Cela peut également être appliqué aux tableaux non booléens :

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

Personnaliser vos propres classes

not fonctionne en appelant bool sur la valeur et de nier le résultat. Dans le cas le plus simple, le valeur de vérité appellera simplement __bool__ sur l'objet.

Ainsi, en mettant en œuvre __bool__ (ou __nonzero__ en Python 2) vous pouvez personnaliser la valeur de vérité et donc le résultat de 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)

J'ai ajouté un print afin de vérifier qu'il appelle bien la méthode :

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

De même, vous pourriez mettre en œuvre la méthode __invert__ pour mettre en œuvre le comportement lorsque ~ est appliquée :

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)

Toujours avec un print pour vérifier qu'il est effectivement appelé :

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

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

Toutefois, la mise en œuvre __invert__ comme cela pourrait prêter à confusion car son comportement est différent du comportement "normal" de Python. Si vous faites cela, documentez-le clairement et assurez-vous que le cas d'utilisation est assez bon (et commun).

Answer 3

Python a un opérateur "not", non ? Ce n'est pas simplement "not" ? Comme dans,

  return not bool

Answer 4

La réponse acceptée ici est la plus correcte pour le scénario donné.

Cela m'a amené à me poser des questions sur l'inversion d'une valeur booléenne en général. Il s'avère que la solution acceptée ici fonctionne en une seule ligne, et qu'il existe une autre solution en une seule ligne qui fonctionne également. En supposant que vous ayez une variable "n" que vous savez être un booléen, les façons les plus simples de l'inverser sont les suivantes :

n = n is False

qui était ma solution originale, puis la réponse acceptée de cette question :

n = not n

Ce dernier est plus clair, mais je me suis posé la question de la performance et je l'ai fait passer. timeit - et il s'avère qu'à n = not n est également le moyen le plus rapide d'inverser la valeur booléenne.

Answer 5

Python a not pour inverser la valeur booléenne.

Exemples :

Si vous voulez inverser la valeur dans le fichier déclaration de retour utilisez le code ci-dessous.

return not bool

Si vous voulez inverser la valeur dans le fichier si la condition utilisez le code suivant

if not bool:
    return True
else:
    return False

Si vous voulez inverser la valeur lorsque vous passez la valeur à l'option niveau de méthode utilisez le code suivant

check(not bool)

Si vous voulez inverser la valeur lorsque l'attribution de la valeur utilisez le code ci-dessous.

key = not bool