Python Language
Comparaciones

Sintaxis

• ! = - No es igual a

• == - es igual a

• > - mayor que

• < - menos que

• >= - mayor que o igual a

• <= - menor o igual que

• is - prueba si los objetos son exactamente el mismo objeto

• no es = prueba si los objetos no son exactamente el mismo objeto

Parámetros

Mayor o menor que

x > y
x < y

Estos operadores comparan dos tipos de valores, son menos que y mayores que los operadores. Para los números, esto simplemente compara los valores numéricos para ver cuál es más grande:

12 > 4
# True
12 < 4
# False
1 < 4
# True

Para las cuerdas, se compararán lexicográficamente, lo cual es similar al orden alfabético pero no es exactamente el mismo.

"alpha" < "beta"
# True
"gamma" > "beta"
# True
"gamma" < "OMEGA"
# False

En estas comparaciones, las letras minúsculas se consideran "mayores que" en mayúsculas, por lo que "gamma" < "OMEGA" es falso. Si todos estuvieran en mayúsculas, devolvería el resultado de orden alfabético esperado:

"GAMMA" < "OMEGA"
# True

Cada tipo define su cálculo con los operadores < y > diferente, por lo que debe investigar qué significan los operadores con un tipo dado antes de usarlo.

No igual a

x != y  

Esto devuelve True si x e y no son iguales y, de lo contrario, devuelve False .

12 != 1
# True
12 != '12'
# True
'12' != '12'
# False

Igual a

x == y 

Esta expresión se evalúa si x y y son del mismo valor y devuelve el resultado como un valor booleano. En general, tanto el tipo como el valor deben coincidir, por lo que el int 12 no es lo mismo que la cadena '12' .

12 == 12
# True
12 == 1
# False
'12' == '12'
# True
'spam' == 'spam'
# True
'spam' == 'spam '
# False
'12' == 12
# False

Tenga en cuenta que cada tipo debe definir una función que se utilizará para evaluar si dos valores son iguales. Para los tipos incorporados, estas funciones se comportan como cabría esperar y solo evalúan las cosas basándose en el mismo valor. Sin embargo, los tipos personalizados pueden definir las pruebas de igualdad como lo deseen, incluyendo devolver siempre True o siempre False .

Comparaciones de cadena

Puede comparar varios elementos con múltiples operadores de comparación con comparación de cadena. Por ejemplo

x > y > z

Es sólo una forma corta de:

x > y and y > z

Esto se evaluará como True solo si ambas comparaciones son True .

La forma general es

a OP b OP c OP d ...

Donde OP representa una de las múltiples operaciones de comparación que puede usar, y las letras representan expresiones válidas arbitrarias.

Tenga en cuenta que 0 != 1 != 0 evalúa como True , aunque 0 != 0 sea False . A diferencia de la notación matemática común en la que x != y != z significa que x , y , z tienen valores diferentes. Las operaciones de encadenamiento == tienen el significado natural en la mayoría de los casos, ya que la igualdad es generalmente transitiva.

Estilo

No hay un límite teórico sobre la cantidad de elementos y operaciones de comparación que utiliza, siempre que tenga la sintaxis adecuada:

1 > -1 < 2 > 0.5 < 100 != 24

Lo anterior devuelve True si cada comparación devuelve True . Sin embargo, el uso de encadenamiento enrevesado no es un buen estilo. Un buen encadenamiento será "direccional", no más complicado que

1 > x > -4 > y != 8

Efectos secundarios

Tan pronto como una comparación devuelve False , la expresión se evalúa inmediatamente en False , omitiendo todas las comparaciones restantes.

Tenga en cuenta que la expresión exp en a > exp > b se evaluará solo una vez, mientras que en el caso de

a > exp and exp > b

exp se calculará dos veces si a > exp es verdadero.

Comparación por `is` vs` == `

Un error común es confundir a los operadores de comparación de igualdad is y == .

a == b compara el valor de a y b .

a is b comparará las identidades de a y b .

Para ilustrar:

a = 'Python is fun!'
b = 'Python is fun!'
a == b # returns True
a is b # returns False

a = [1, 2, 3, 4, 5]
b = a      # b references a
a == b     # True
a is b     # True
b = a[:]   # b now references a copy of a
a == b     # True
a is b     # False [!!]

Básicamente, is puede considerar como una abreviatura para id(a) == id(b) .

Más allá de esto, hay peculiaridades del entorno del tiempo de ejecución que complican aún más las cosas. Las cadenas cortas y los enteros pequeños devolverán True cuando se compara con is , debido a que la máquina Python intenta usar menos memoria para objetos idénticos.

a = 'short'
b = 'short'
c = 5
d = 5
a is b # True
c is d # True

Pero las cadenas más largas y los enteros más grandes se almacenarán por separado.

a = 'not so short'
b = 'not so short'
c = 1000
d = 1000
a is b # False
c is d # False

Usted debe usar is para probar para None :

if myvar is not None:
    # not None
    pass
if myvar is None:
    # None
    pass

Un uso de is es probar un "centinela" (es decir, un objeto único).

sentinel = object()
def myfunc(var=sentinel):
    if var is sentinel:
        # value wasn’t provided
        pass
    else:
        # value was provided
        pass

Comparando objetos

Para comparar la igualdad de clases personalizadas, puede anular == y != __ne__ métodos __eq__ y __ne__ . También puede anular __lt__ ( < ), __le__ ( <= ), __gt__ ( > ) y __ge__ ( > ). Tenga en cuenta que solo necesita anular dos métodos de comparación, y Python puede manejar el resto ( == es lo mismo que not < y not > , etc.)

class Foo(object):
    def __init__(self, item):
        self.my_item = item
    def __eq__(self, other):
        return self.my_item == other.my_item
    
a = Foo(5)
b = Foo(5)
a == b     # True
a != b     # False
a is b     # False

Tenga en cuenta que esta comparación simple supone que other (el objeto que se está comparando) es el mismo tipo de objeto. Comparando con otro tipo lanzará un error:

class Bar(object):
    def __init__(self, item):
        self.other_item = item
    def __eq__(self, other):
        return self.other_item == other.other_item
    def __ne__(self, other):
        return self.other_item != other.other_item
    
c = Bar(5)
a == c    # throws AttributeError: 'Foo' object has no attribute 'other_item'

Verificar isinstance() o similar ayudará a prevenir esto (si se desea).

Common Gotcha: Python no impone la escritura

En muchos otros idiomas, si ejecuta lo siguiente (ejemplo de Java)

if("asgdsrf" == 0) {
    //do stuff
}

... obtendrá un error. No puedes ir comparando cadenas con enteros como ese. En Python, esta es una declaración perfectamente legal, solo se resolverá en False .

Un gotcha común es el siguiente

myVariable = "1"
if 1 == myVariable:
    #do stuff

Esta comparación evaluará a False sin un error, cada vez, ocultando un error o rompiendo un condicional.