Identity Operator in Python – Types, Benefits and More
Basics of SQL
12 Hrs. duration
12 Modules
2600+ Learners
Start Learning
Python is a widely used programming language. It supports various operators for different purposes, including the identity operator. The identity operator compares two objects to see whether they are identical. This article will explain the identity operator’s concept, benefits, and limitations in Python.
What is the Identity Operator in Python?
The identity operator is a comparison operator in the Python language. Every object in the Python language is stored at some memory location. The Identity Operator checks whether or not two objects are pointing to the same memory location in the computer’s memory. The Identity operators contain the addresses of two objects and return true if they are pointing to the same memory location; otherwise, they return false.
Types of Identity Operator in Python
There are two types of identity operators in Python.
Is
is not
is Operator
The “is” operator evaluates to true if both operand objects share the same memory location. This operator returns true if both objects have the same ID associated; otherwise, it returns false.
The following program demonstrates “is” Operator.
Program
a = [1, 2, 3, 4, 5]
b = [1, 2, 3, 4, 5]
c = a
d = b
print(a is c)
print(a is b)
print(c is d)
print("id(a) : ", id(a))
print("id(b) : ", id(b))
print("id(c) : ", id(c))
print("id(c)", id(d))
Object1 and object2 are two objects in Python that we want to compare in the program. The “is” operator will return true if the “object1” and “object2” are the same object in memory otherwise, it will return false.
The following program demonstrates the Operator in Python:
Program
x = [1, 2, 3]
y = [1, 2, 3]
z = x
print(x is y)
print(x is z)
The “is not” operator is a negative equivalence checking operator. It checks whether the two variables refer to the same object in memory. This operator returns true if both variable operators refer to different locations in the memory; otherwise, it will return false if both operators refer to the object in the memory.
The following program demonstrates the “is not” Operator:
Program
class Item:
def __init__(self, name, quantity):
self.name = name
self.quantity = quantity
def __repr__(self):
return f"Item(name={self.name}, quantity={self.quantity})"
class Inventory:
def __init__(self):
self.items = []
def add_item(self, item):
for existing_item in self.items:
if existing_item.name == item.name:
existing_item.quantity += item.quantity
print(f"Updated {existing_item}. New quantity: {existing_item.quantity}")
return
self.items.append(item)
print(f"Added {item} to inventory.")
def remove_item(self, item_name, quantity):
for existing_item in self.items:
if existing_item.name == item_name:
if existing_item.quantity >= quantity:
existing_item.quantity -= quantity
print(f"Removed {quantity} of {item_name}. New quantity: {existing_item.quantity}")
if existing_item.quantity == 0:
self.items.remove(existing_item)
print(f"Removed {item_name} from inventory.")
return
else:
print(f"Not enough quantity of {item_name} to remove.")
return
print(f"{item_name} not found in inventory.")
def display_inventory(self):
if not self.items:
print("Inventory is empty.")
else:
print("Current Inventory:")
for item in self.items:
print(item)
if __name__ == "__main__":
inventory = Inventory()
item1 = Item("Apple", 10)
item2 = Item("Banana", 5)
item3 = Item("Orange", 3)
item4 = Item("Apple", 5)
inventory.add_item(item1)
inventory.add_item(item2)
inventory.add_item(item3)
inventory.add_item(item4)
inventory.display_inventory()
inventory.remove_item("Banana", 2)
inventory.remove_item("Apple", 10)
inventory.display_inventory()
inventory.remove_item("Grapes", 1)
Output
Added Item(name=Apple, quantity=10) to inventory.
Added Item(name=Banana, quantity=5) to inventory.
Added Item(name=Orange, quantity=3) to inventory.
Updated Item(name=Apple, quantity=15). New quantity: 15
Current Inventory:
Item(name=Apple, quantity=15)
Item(name=Banana, quantity=5)
Item(name=Orange, quantity=3)
Removed 2 of Banana. New quantity: 3
Removed 10 of Apple. New quantity: 5
Current Inventory:
Item(name=Apple, quantity=5)
Item(name=Banana, quantity=3)
Item(name=Orange, quantity=3)
Grapes not found in inventory.
In Python, “==” and “is” serve different purposes when comparing objects. The == operator is used to check if the values of two objects are equal. It means they evaluate whether their contents are the same, even if they are distinct objects in the memory. If the two separate list contain the same elements, it will return true.
Otherwise, it will return false. The “is” operator checks for identity and determines whether two variables refer to the same object in the memory. Even if the objects have identical values, it will return a false if they are separate instances. Therefore, use == for value comparison and is for reference comparison.
Example:
# Define two lists
list1 = [1, 2, 3]
list2 = list1
list3 = list(list1)
# Using == operator
print("Using == operator:")
print(list1 == list2)
print(list1 == list3)
# Using is operator
print("nUsing is operator:")
print(list1 is list2)
print(list1 is list3)
# Modifying list1
list1.append(4)
print("nAfter modifying list1:")
print("list1:", list1)
print("list2:", list2)
print("list3:", list3)
# Checking equality and identity again
print("nFinal checks:")
print(list1 == list3)
print(list1 is list3)
Output
Using == operator:
True
True
Using is operator:
True
False
After modifying list1:
list1: [1, 2, 3, 4]
list2: [1, 2, 3, 4]
list3: [1, 2, 3]
Final checks:
False
False
Benefits of Identity Operator in Python
Let’s discuss some of the benefits of an identity operator in Python:
Memory Efficiency: The is operator can help determine if two variables point to the same object, which can be more efficient. It is very useful for immutable types like integers and strings.
Performance: Checking identity with “is” can be faster than checking equality with == , as it compares memory addresses rather than evaluating value, which may involve more complex logic.
Clarity: The “is” can make the source code’s intent, especially when checking if two variables reference the same object. It is very useful in scenarios involving.
Limitations of Identity Operator in Python
Let’s discuss some limitations of the identity operators in the Python language.
Reference Comparison: The “is” operator checks if two references point to the same object in memory, not if their values are equal.
Immutable Types: The immutable types (like integers, strings and tuples) Python may reuse objects for small values, leading to unexpected results when using it for value comparison.
Complex Objects: Comparing instances of user-defined classes will only return true if both variables point to the same instances.
Performance: It is generally fast due to its reference checking. However, it may lead to incorrect assumptions about equality, potentially making bugs harder to trace.
Conclusion
In this article, we learned about the identity operator in Python. It determines whether two variables reference the same object in memory. Unlike the equality operator ==, which checks the value equality, the identity operator checks for reference equality. This means that it will return True only if both variables point to the same object.
The operator is particularly useful when checking for None or comparing singleton objects like True and False. Using it appropriately allows developers to write more efficient and precise source code, ensuring they correctly assess object identities rather than just their values. Mastering the use of the identity operator enhances clarity and efficiency in Python programming language.
FAQs
What does the “is” operator do?
The operator checks if two variables point to the same object in memory, confirming reference equality.
How does “is” differ from ==?
While is checks if two variables refer to the same object (identity), == checks if their values are equal
Can “is’ be used with user-defined classes?
Yes, But be mindful that unless you override the equality methods, is will check for identity, not value.
Are there any best practices for using is?
The use “is” for checking None, True, or False and use == for comparing values. Always be clear about whether you’re checking for identity or equality.
Can “is” be used with tuples?
Yes, We can use “is” with tuples, but it will check if both variables point to the same tuple object in memory, not if they contain the same values.
Hero Vired is a leading LearnTech company dedicated to offering cutting-edge programs in collaboration with top-tier global institutions. As part of the esteemed Hero Group, we are committed to revolutionizing the skill development landscape in India. Our programs, delivered by industry experts, are designed to empower professionals and students with the skills they need to thrive in today’s competitive job market.