Igualdad de clases de Python

1. Igualdad de objetos de clase en Python
2. Igualdad de clases de Python usando el método __eq__()
3. Igualdad de clases de Python usando el método id()

En Python, podemos comparar diferentes tipos de datos usando operadores de comparación. Sin embargo, no podemos simplemente compararlos usando los operadores de comparación al crear clases personalizadas.

Este artículo discutirá diferentes formas de verificar la igualdad de los objetos definidos usando clases personalizadas en Python.

Igualdad de objetos de clase en Python

Cuando tenemos objetos incorporados como números enteros o cadenas, podemos verificar fácilmente su igualdad usando el operador ==, como se muestra a continuación.

num1 = 12
num2 = 10
result = num1 == num2
print("{} and {} are equal:{}".format(num1, num2, result))

Producción :

12 and 10 are equal:False

Aquí, el operador == da el valor correcto como salida porque los valores 12 y 10 son números enteros. Sin embargo, cuando tenemos objetos de clases personalizadas, el intérprete de Python funciona de manera diferente.

Por ejemplo, supongamos que tenemos una clase Longitud con un solo atributo, longitud, como se muestra a continuación.

class Length:
    def __init__(self, value):
        self.length = value

Crearemos dos instancias de la clase Longitud con el mismo valor en el atributo longitud.

class Length:
    def __init__(self, value):
        self.length = value


len1 = Length(10)
len2 = Length(10)

Si compara los objetos usando el operador ==, el resultado será False aunque ambas instancias tengan el mismo valor en el atributo longitud. Puedes observar esto en el siguiente código.

class Length:
    def __init__(self, value):
        self.length = value


len1 = Length(10)
len2 = Length(10)
result = len1 == len2
print("len1 and len2 are equal:", result)

Producción :

len1 and len2 are equal: False

El comportamiento anterior del intérprete de Python se puede describir usando la forma en que compara dos objetos de clases definidas por el usuario. Cuando verificamos la igualdad de dos objetos de clase en Python usando el operador ==, el resultado será True solo si ambos objetos se refieren a la misma ubicación de memoria.

En otras palabras, habrá dos variables pero solo un único objeto de Python. Puedes observar esto en el siguiente ejemplo.

class Length:
    def __init__(self, value):
        self.length = value


len1 = Length(10)
len2 = len1
result = len1 == len2
print("len1 and len2 are equal:", result)

Producción :

len1 and len2 are equal: True

Es posible que haya entendido que el operador de igualdad devolverá True solo cuando ambas variables se refieran a la misma instancia de la clase definida por el usuario.

¿Qué debemos hacer si necesitamos verificar la igualdad de diferentes instancias de una clase en Python? Averigüémoslo.

Igualdad de clases de Python usando el método __eq__()

Al anular el método __eq__(), podemos modificar cómo funciona el operador == con clases personalizadas. Por ejemplo, para verificar la longitud de dos instancias de la clase Length, podemos anular el método __eq__().

Usaremos los pasos discutidos a continuación dentro del método __eq__().

1. El método __eq__(), cuando se invoca en una instancia de la clase Length, tomará otro objeto como argumento de entrada.

2. Dentro del método __eq__(), primero comprobaremos si el objeto de entrada es una instancia de la clase Length o no. Para ello, podemos utilizar la función isinstance().

3. La función isinstance() toma un objeto de Python como primer argumento de entrada y el nombre de la clase como segundo argumento de entrada. Después de la ejecución, devuelve True si el objeto es una instancia de la clase proporcionada en el argumento de entrada.

4. Pasaremos la clase Longitud como segundo argumento de entrada en nuestro programa. Si el objeto pasado en el primer argumento no es una instancia de la clase Length, devolverá False.

   De lo contrario, seguiremos adelante.

5. Para verificar la igualdad de clase de los dos objetos, compararemos el valor del atributo longitud en ambos objetos. Si los valores son iguales, devolveremos True.

   En caso contrario, devolveremos False.

Una vez implementado el método __eq__() en la clase Length, podemos comparar correctamente dos instancias de la clase Number utilizando el operador ==.

Supongamos que tenemos dos instancias de la clase Length, digamos len1 y len2. Cuando ejecutamos len1==len2, se ejecutará el método len1.__eq__(len2).

De igual forma, cuando ejecutamos len2==len1, se ejecutará el método len2.__eq__(len1).

Después de ejecutar el código, len1==len2 devolverá True si el valor de longitud de ambos objetos tiene el mismo valor. De lo contrario, devolverá False.

Puedes observar esto en el siguiente ejemplo.

class Length:
    def __init__(self, value):
        self.length = value

    def __eq__(self, other):
        isLength = isinstance(other, self.__class__)
        if not isLength:
            return False
        if self.length == other.length:
            return True
        else:
            return False


len1 = Length(10)
len2 = Length(10)
result = len1 == len2
print("len1 and len2 are equal:", result)

Producción :

len1 and len2 are equal: True

Igualdad de clases de Python usando el método id()

También puede verificar si dos variables que tienen objetos de clases personalizadas se refieren al mismo objeto o no. Para ello, puedes utilizar la función id().

La función id() toma un objeto como argumento de entrada y devuelve un número de identidad único en cualquier ubicación de memoria. Puedes observar esto en el siguiente ejemplo.

class Length:
    def __init__(self, value):
        self.length = value

    def __eq__(self, other):
        isLength = isinstance(other, self.__class__)
        if not isLength:
            return False
        if self.length == other.length:
            return True
        else:
            return False


len1 = Length(10)
len2 = Length(10)
result1 = id(len1)
result2 = id(len2)
print("ID of len1 is ", result1)
print("ID of len2 is ", result2)

Producción :

ID of len1 is  140057455513712
ID of len2 is  140057454483488

Si dos objetos se refieren a la misma ubicación de memoria, la función id() dará la misma salida para ambos objetos. Al comparar la salida de la función id(), podemos verificar si los objetos se refieren a la misma ubicación de memoria o no.

Puedes observar esto en el siguiente ejemplo.

class Length:
    def __init__(self, value):
        self.length = value

    def __eq__(self, other):
        isLength = isinstance(other, self.__class__)
        if not isLength:
            return False
        if self.length == other.length:
            return True
        else:
            return False


len1 = Length(10)
len2 = Length(10)
result1 = id(len1)
result2 = id(len2)
result = result1 == result2
print("len1 and len2 are equal:", result)

Producción :

len1 and len2 are equal: False

Aquí, puede observar que no hemos verificado el valor de los atributos en los objetos para verificar la igualdad de clases.

En este caso, solo estamos verificando si los objetos se refieren a la misma ubicación de memoria o no. Por lo tanto, este enfoque para verificar la igualdad de clases de Python es equivalente a usar el operador == sin implementar el método __eq__() en la definición de clase.