Difference Between '_eq_' VS 'is' VS '==' in Python

Object examination is a principal part of Python programming, empowering designers to assess the balance and personality of items. In Python, objects are at the centre of everything - factors, information designs, capabilities, and more are objects. In this way, understanding how items are thought about and assessed is critical for composing productive and right code. Whether it's looking at values, really looking at object character, or characterizing custom balance conduct, object examination assumes a crucial part in different parts of programming improvement.

Introduction to eq(), is, and == for Comparison Tasks:

In Python, three essential systems are utilized for correlation assignments: _eq_(), is, and ==. Every system fills a particular need and works in an unexpected way:

_eq_(): This technique is utilized to characterize custom fairness conduct for client characterized classes. It permits designers to determine how examples of a class ought to be looked at for correspondence.
is: The is operator is utilized to think about object personality, deciding if two items reference a similar memory area.
==: The == operator is utilized for esteem examination, contrasting the items in objects with check assuming that they are equivalent as per their characterized balance rules.

Understanding the distinctions between these systems and knowing when to utilize everyone is fundamental for composing clear and effective code in Python.

The eq() Technique: Custom Fairness Correlation:

The _eq_() technique is a unique strategy in Python classes that permits designers to characterize custom uniformity conduct. By superseding this technique, designers can indicate how occurrences of a class ought to be looked at for balance. The language structure for executing _eq_() is clear, and it considers adaptability in characterizing custom examination rationale customized to the necessities of the class. How about we investigate the language structure and see a few guides to comprehend its application better.

Syntax:

 
def __eq__(self, other):
    # Here, we are Custom comparison logic
    return self.attribute == other.attribute   

Example:

 
class Person:     # here, we are declaring a class
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __eq__(self, other):
        return self.name == other.name and self.age == other.age
# Here, we are Creating instances of Person class
person1 = Person("Alice", 30)
person2 = Person("Alice", 30)
person3 = Person("Bob", 25)
# Here, we are Using custom equality comparison
print(person1 == person2)  
print(person1 == person3)     

Output:

 
True (equal)
False (not equal)

Explanation:

In this model, we characterize an Individual class with a custom _eq_() technique to look at two cases in light of their name and age credits. At the point when we analyze person1 and person2, both have a similar name ("Alice") and age (30), so the custom equity examination returns Valid, it is equivalent to demonstrate that they. Nonetheless, when we look at person1 and person3, they have different name or age, bringing about a Misleading assessment, it is not equivalent to show that they.

Example 2:

 
class Product:          # here, we are declaring a class
    def __init__(self, name, price):
        self.name = name
        self.price = price
    def __eq__(self, other):
        return self.name == other.name and self.price == other.price
# Here, we are Creating instances of Product class
product1 = Product("Laptop", 1000)
product2 = Product("Laptop", 1000)
product3 = Product("Phone", 500)
# Here, we are Using custom equality comparison
print(product1 == product2)  
print(product1 == product3)     

Output:

 
True (equal)
False (not equal)

Explanation:

In this model, we characterize an Item class with a custom _eq_() strategy to look at two occurrences in view of their name and cost credits. At the point when we think about product1 and product2, both have a similar name ("PC") and cost (1000), so the custom equity correlation returns Valid, it is equivalent to demonstrate that they. In any case, when we look at product1 and product3, they have different name or cost, bringing about a Bogus assessment, it is not equivalent to show that they.

The is Operator: Article Character Examination:

In Python, the is operator is utilized for object character examination. It checks whether two articles reference similar memory area, demonstrating that they are a similar article. Dissimilar to the == operator, which analyses the upsides of articles, the is operator looks at the characters of items. This differentiation is critical, particularly while managing alterable articles and character checks. We should dig into the utilization of the is operator to acquire a more profound comprehension of item character examination.

The is operator in Python is clear to utilize. It assesses to Valid assuming that two factors reference a similar article and Misleading in any case. Here is a basic model showing the use of the is operator:

Example:

 
a = [1, 2, 3]
b = a      # Here, we are b references the same object as a
print(a is b)  
c = [1, 2, 3]
print(a is c)     

Output:

 
True
False (different objects)

Explanation:

In this model, we have a rundown a containing [1, 2, 3]. We then, at that point, relegate a to b, making b reference a similar rundown object as a. In this way, when we utilize the is operator to look at an and b, it assesses to Valid, demonstrating that they reference a similar article in memory. Nonetheless, when we make another rundown c with similar items as a, it is a different item in memory. Hence, when we look at an and c utilizing is, it assesses to Bogus, demonstrating that they are various articles.

Example 2:

 
a = [1, 2, 3]
b = a      # Here, we are b references the same object as a
print(a is b) 
c = a[:]
print(a is c)     

Output:

 
True
False (different objects)

Explanation:

In this model, an and b reference a similar rundown object, so the is administrator assesses to Valid. Be that as it may, when we make a shallow duplicate c of a utilizing cutting, c turns into an alternate rundown object, despite the fact that it contains similar components as a. In this way, when we look at an and c utilizing is, it assesses to Misleading, showing that they are various articles.

The == operator: Worth Examination:

Dissimilar to the is operator, which checks for object personality, the == operator is utilized for esteem correlation. It thinks about the items in objects to decide whether they are equivalent as per their characterized equity rules. For worked in types like whole numbers, strings, and records, == looks at the upsides of the items. Here is a model exhibiting the use of the == operator:

Example:

 
class Rectangle:         # here, we are declaring a class
    def __init__(self, width, height):
        self.width = width
        self.height = height
# Here, we are Creating instances of Rectangle class
rect1 = Rectangle(10, 20)
rect2 = Rectangle(10, 20)
rect3 = Rectangle(15, 25)
# Here, we are Using value comparison
print(rect1 == rect2)  
print(rect1 == rect3)     

Output:

 
True (same width and height)
False (different width or height)

Explanation:

In this model, we characterize a Square shape class to address square shapes with width and level credits. Since we haven't characterized a custom _eq_() technique, the == operator plays out a worth examination by looking at the qualities of the examples. At the point when we think about rect1 and rect2, both have a similar width (10) and level (20), so the worth correlation returns Valid, it are equivalent to demonstrate that they. Nonetheless, when we look at rect1 and rect3, they have different width or level, bringing about a Misleading assessment, it are not equivalent to show that they.

Example 2:

 
class Point:             # here, we are declaring a class
    def __init__(self, x, y):
        self.x = x
        self.y = y
# Here, we are Creating instances of Point class
point1 = Point(1, 2)
point2 = Point(1, 2)
point3 = Point(3, 4)
# Here, we are Using value comparison
print(point1 == point2)  
print(point1 == point3)     

Output:

 
True (same coordinates)
False (different coordinates)

Explanation:

In this model, the Point class addresses focus in a 2D plane with x and y organizes. Since we haven't characterized a custom _eq_() technique, the == administrator plays out a worth correlation by looking at the properties of the examples. At the point when we analyze point1 and point2, both have a similar x (1) and y (2) organizes, so the worth examination returns Valid, it are equivalent to show that they. In any case, when we look at point1 and point3, they have various directions, bringing about a Misleading assessment, it are not equivalent to demonstrate that they.

Next TopicDisassembler for python bytecode

← prev next →