Para la siguiente muestra:

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

¿Hay alguna forma de saltear la segunda instrucción if? ¿Solo para decirle a la computadora que devuelva el opuesto del booleano bool?

81
amyassin 11 ago. 2011 a las 22:15

6 respuestas

La mejor respuesta

Solo puedes usar:

return not bool
140
Mike Graham 11 ago. 2011 a las 18:56

La respuesta aceptada aquí es la más correcta para el escenario dado.

Sin embargo, me hizo preguntarme sobre la simple inversión de un valor booleano en general. Resulta que la solución aceptada aquí funciona como un trazador de líneas, y hay otro trazador de líneas que también funciona. Suponiendo que tiene una variable "n" que sabe que es booleana, las formas más fáciles de invertirla son:

n = n is False

Cuál fue mi solución original, y luego la respuesta aceptada de esta pregunta:

n = not n

Esto último es más claro, pero me pregunté sobre el rendimiento y lo analicé a través de timeit, y resulta que en n = not n también es la forma MÁS RÁPIDA de invertir el valor booleano.

1
user1411616 29 ene. 2020 a las 23:02

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

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

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

2
user1767754 30 may. 2018 a las 17:56

Simplemente puede comparar la matriz booleana. Por ejemplo

X = [True, False, True]

Entonces

Y = X == False

Te daría

Y = [False, True, False]
3
Sebastian 1 oct. 2017 a las 12:18

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

  return not bool
9
Patrick87 11 ago. 2011 a las 18:17

El not operador (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 su código:

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

Usted podría utilizar:

return not bool

La negación lógica como función

También hay dos funciones en el operator módulo operator.not_ y es 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 utilizar 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 también 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 verse tentado a usar el operador de inversión bit a bit ~ o la función de operador equivalente operator.inv (o uno de los otros 3 alias allí). Pero debido a que bool es una subclase de int, el resultado podría ser inesperado porque no devuelve el "booleano inverso", 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 bit a bit opera en la representación bit a bit de los enteros 1 y 0.

Por lo tanto, no se pueden usar para "negar" un bool.

Negación con matrices NumPy (y subclases)

Si se trata de matrices NumPy (o subclases como pandas.Series o pandas.DataFrame) que contienen booleanos, puede usar el operador inverso bit a bit (~) para negar todos 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 usar el operador not o la función operator.not en las matrices NumPy porque requieren que devuelvan un solo bool (no una matriz de booleanos), sin embargo, NumPy también contiene una función lógica no que funciona en cuanto a 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 llamando a bool en el valor y niega el resultado. En el caso más simple, el valor de verdad simplemente llamará a {{X2 }} en el objeto.

Entonces, al implementar __bool__ (o __nonzero__ en Python 2) puede personalizar el valor de verdad y así 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 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 print para ver que realmente 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__ así podría ser confuso porque su comportamiento es diferente del comportamiento "normal" de Python. Si alguna vez lo hace, documente claramente y asegúrese de que tenga un caso de uso bastante bueno (y común).

33
MSeifert 1 jul. 2018 a las 12:38