python - numero - eliminar objeto de lista

¿Cómo puedo agregar el valor booleano False pero no True en un conjunto en Python?

Question

Esta pregunta ya tiene una respuesta aquí:

• Python establece clase, float y int evaluación 1 respuesta
• ¿Por qué bool es una subclase de int? 3 respuestas

Acabo de empezar a investigar el tipo de datos establecido en Python. Por alguna razón, cada vez que agrego el valor booleano de True a un conjunto, no aparece. Sin embargo, si agrego False a un conjunto, se convertirá en un elemento del conjunto. Me sorprendió cuando busqué en Google esta pregunta que no surgió nada.

example1 = {1, 2, 7, False}
example2 = {7, 2, 4, 1, True}

print(example1)
print(example2)

El resultado es:

{False, 1, 2, 7}
{1, 2, 4, 7}

Answer 1

False y True son iguales a 0 y 1, respectivamente. Son entidades distintas, pero los dos valores iguales no pueden estar ambos en un conjunto. Este es un comportamiento claramente no deseado, sin embargo, no está claro que se pueda arreglar y aún así permitir que la multiplicación por un valor booleano funcione como está documentado.

IPython 6.2.1 -- An enhanced Interactive Python.

1 is True
Out[1]: False

{1,True}
Out[2]: {1}

{0,False}
Out[3]: {0}

{False, 0}
Out[4]: {False}

{True, 1}
Out[5]: {True}

Tenga en cuenta que dependiendo del orden de ponerlos en el conjunto, 1 no estará en el conjunto si True ya está en él, y True no estará en el conjunto si 1 ya está en él.

Answer 2

La razón por la que está perdiendo valores booleanos de un set si ya contienen 0 o 1 es porque el siguiente comportamiento ...

>>> hash(1) == hash(True)
True
>>> hash(0) == hash(False)
True
>>> 1 == True
>>> True
>>> 0 == False
>>> True

... está garantizado en Python 3.x.

Lo que significa que no puede tener ambos en un conjunto:

>>> set([True, 1])
{True}
>>> set([False, 0])
{False}

El hecho de que los hashes sean iguales es tan importante como que los objetos sean iguales, porque los objetos que son "iguales" pueden producir hashes diferentes y viceversa:

class Foo:
    def __init__(self, x): self.x = x
    def __hash__(self): return 1
    def __eq__(self, other): return self.x == other.x

class Bar:
    def __init__(self, x): self.x = x
    def __hash__(self): return 2
    def __eq__(self, other): return self.x == other.x

>>> x = Foo(3)    
>>> y = Bar(3)
>>> x == y
True
>>> hash(x) == hash(y)
False
>>> set([x, y])
{<__main__.Bar at 0x56ed278>, <__main__.Foo at 0x5707390>}

También puede tener un set que contenga elementos con los mismos valores hash, si esos elementos no son iguales:

>>> hash(''a'')
-904409032991049157
>>> hash(-904409032991049157)
-904409032991049157
>>> hash(''a'') == hash(-904409032991049157)
True
>>> set([''a'', -904409032991049157])
{-904409032991049157, ''a''}

Este comportamiento no está garantizado en Python 2.x, por la sencilla razón de que True y False no son palabras clave reservadas (este cambio se introdujo en 3.x ). Puede reasignarlos (aunque es mejor no hacerlo), por lo que no hay ninguna razón por la cual el mismo comportamiento deba mantenerse en Python 2.x:

>>> True = 5
>>> hash(True) == hash(1)
False
>>> set([1, True])
set([1, 5])

¡Pero no dejes que el hecho de que True sido reemplazado por 5 te desanime! Podemos abusar de la representación de una clase para que parezca que True realmente está en el conjunto:

class Foo(object):
    def __repr__(self):
        return(''True'')

>>> True = Foo()
>>> set([1, True])
set([1, True])

Obviamente, los últimos fragmentos de código de pareja son una mala práctica y solo son para demostración. Lo principal es que los objetos iguales con el mismo hash no pueden estar contenidos en el mismo set , y en Python 3.x, 1 y True , y 0 y False , siempre tendrán el mismo hash, y siempre serán iguales.

Answer 3

Porque en Python 1 == True (y hash(1) == hash(True) ) y ya tienes 1 en tu conjunto.

Imagina este ejemplo:

example1 = {0, False, None}
example2 = {1, True}

print(example1)
print(example2)

Se producirá:

{0, None}
{1}

El primer conjunto tiene 0 y None porque 0 == False pero 0 != None . Con el segundo conjunto 1 == True True no se agrega al conjunto.