valores - ¿Cómo obtengo lo opuesto(negación) de un booleano en Python?

operadores relacionales en python

Question

Para la siguiente muestra:

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

¿Hay alguna manera de omitir la segunda instrucción if? ¿Solo para decirle a la computadora que devuelva lo opuesto a boolean bool ?

Answer 1

El operador not (negación lógica)

Probablemente la mejor manera es usar el operador not :

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

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

Entonces, en lugar de tu código:

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

Podrías usar:

return not bool

La negación lógica como función

También hay dos funciones en el operator operator.not_ operator.__not__ y su operator.__not__ alias operator.__not__ en caso de que lo necesite como función en lugar de como operador:

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

Estos pueden ser útiles si desea usar una función que requiere una función de predicado o una devolución de llamada.

Por ejemplo, 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]

Por supuesto, lo mismo podría lograrse con una función lambda equivalente:

>>> my_not_function = lambda item: not item

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

No utilice el operador de inversión bit a bit ~ en booleanos

Uno podría estar tentado de usar el operador de inversión bit a bit ~ o la función de operator.inv equivalente operator.inv (o uno de los otros 3 alias allí). Pero como bool es una subclase de int el resultado puede ser inesperado porque no devuelve el "booleano inverso", sino que devuelve el "entero inverso":

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

Esto se debe a que True es equivalente a 1 y False a 0 y la inversión en modo bit opera en la representación bit a bit de los enteros 1 y 0 .

Entonces estos no pueden ser usados ​​para "negar" un bool .

Negación con arreglos NumPy (y subclases)

Si está tratando con arreglos NumPy (o subclases como pandas.Series o pandas.DataFrame ) que contienen booleanos, puede usar el operador bitwise inverso ( ~ ) para anular todos los booleanos en una matriz:

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

O la función NumPy equivalente:

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

No puede utilizar el operador not o el operator.not funcionan en arreglos NumPy porque requieren que estos devuelvan un único bool (no una matriz de booleanos), sin embargo, NumPy también contiene una función lógica que no funciona en función de los elementos:

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

Eso también se puede aplicar a matrices no booleanas:

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

Personalizando tus propias clases

not funciona al invocar bool en el valor y negar el resultado. En el caso más simple, el valor de verdad simplemente llamará __bool__ al objeto.

Entonces al implementar __bool__ (o __nonzero__ en Python 2) puedes personalizar el valor de verdad y por lo tanto el resultado 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)

Agregué una declaración de print para que pueda verificar que realmente llama al método:

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

Del mismo modo, podría implementar el método __invert__ para implementar el comportamiento cuando ~ se aplica:

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)

Nuevamente con una llamada de print para ver que en realidad se llama:

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

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

Sin embargo, implementar __invert__ esa manera podría ser confuso porque su comportamiento es diferente del comportamiento de Python "normal". Si alguna vez lo hace, documente claramente y asegúrese de que tenga un caso de uso bastante bueno (y común).

Answer 2

Puedes simplemente comparar la matriz booleana. Por ejemplo

X = [True, False, True]

entonces

Y = X == False

te daría

Y = [False, True, False]

Answer 3

Puedes simplemente usar:

return not bool

Answer 4

Python tiene un operador "no", ¿verdad? ¿No es solo "no"? Como en,

  return not bool

Answer 5

Si está intentando implementar un alternar , de modo que cada vez que vuelva a ejecutar un código persistente sea negado, puede lograrlo de la siguiente manera:

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

Al ejecutar este código, primero establecerá el toggle a True y cada vez que se llame a este fragmento, se negará el alternar.