Join Our 4-Week Free Gen AI Course with select Programs.

Request a callback

or Chat with us on

Learning Hub

Articles

Identity Operator in Python – Types, Benefits and More

Basics of Python

5 Hrs. duration

9 Modules

1800+ 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))

Output

True

False

False

id(a) :  1638011033920

id(b) :  1638011031936

id(c) :  1638011033920

id(c) 1638011031936

Syntax of is Identity Operator in Python:

object1 is object2

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)

Output

False

True

is not Operator

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.

Internship Assurance

DevOps & Cloud Engineering

Explore

Is There a Difference Between == and is?

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.

Deploying Applications Over the Cloud Using Jenkins

Prashant Kumar Dey

Associate Program Director - Hero Vired

Ex BMW | Google

19 October, 12:00 PM (IST)

Limited Seats Left

Book a Free Live Class

Programs tailored for your success

Popular

Management

Data Science

Finance

Technology

Future Tech

3 ASSURED INTERVIEWS

Accelerator Program in

Business Analytics and Data Science

With

Part-time · 10 months

Apply by : 19 October, 2024

Financial Analysis, Valuation, & Risk Management

3 ASSURED INTERVIEWS

Certificate Program in

Financial Analysis, Valuation, & Risk Management

With

Part-time · 7 months

Apply by : 19 October, 2024

INTERNSHIP ASSURANCE

Certificate Program in

DevOps & Cloud Engineering

With

Part-time · 7.5 months

Apply by : 19 October, 2024

Upskill with expert articles

View all

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.

Data Science

Accelerator Program in Business Analytics & Data Science

Integrated Program in Data Science, AI and ML

Accelerator Program in AI and Machine Learning

Advanced Certification Program in Data Science & Analytics

Technology

Certificate Program in Full Stack Development with Specialization for Web and Mobile

Certificate Program in DevOps and Cloud Engineering

Certificate Program in Application Development

Certificate Program in Cybersecurity Essentials & Risk Assessment

Finance

Integrated Program in Finance and Financial Technologies