In Python , It is used to compare the memory locations of two objects. They help determine if two objects are the same object (sharing the same memory address) or if they are different objects. This distinction is particularly useful when working with mutable and immutable types.

Table of Contents

1. Introduction to Identity Operators
2. Types of Identity Operators
   • is
   • is not
3. How Identity Operators Work
4. Practical Examples of Identity Operators
5. Mini-Project: Duplicate Object Finder
6. Common Pitfalls and Best Practices
7. Interview Questions and Answers (Google, Amazon, TCS, Infosys, Zoho)

1. Introduction

Identity operators compare the memory addresses of two objects. Instead of checking for equality (==), they check if two variables point to the same object in memory.

Key Points:

• is and is not compare objects by identity (memory location).
• Use these operators to test object uniqueness, especially with mutable types.

2. Types of Identity Operators

a) is Operator

The is operator returns True if two variables refer to the same object (i.e., they share the same memory address). Otherwise, it returns False.

Syntax:

variable1 is variable2

Example:

x = [1, 2, 3]
y = x  # y refers to the same object as x
z = [1, 2, 3]  # z is a different object with the same value

print(x is y)  # Output: True
print(x is z)  # Output: False

b) is not Operator

The is not operator returns True if two variables do not refer to the same object. Otherwise, it returns False.

Syntax:

variable1 is not variable2

Example:

x = [1, 2, 3]
y = x
z = [1, 2, 3]

print(x is not y)  # Output: False
print(x is not z)  # Output: True

3. How Identity Operators Work

To understand identity operators, let’s dive into Python’s memory management:

1. Immutable Objects: For types like int, str, and tuple, Python reuses memory locations for identical values to optimize performance. This is why:

a = 10 b = 10 print(a is b) # Output: True

2. Mutable Objects: For types like list, dict, and set, Python creates a new memory location every time you initialize a new object, even if the values are the same.

4. Practical Examples of Identity Operators

1: Checking Object Identity

a = 10
b = 10
c = [1, 2, 3]
d = [1, 2, 3]

print(a is b)  # Output: True (both point to the same memory address)
print(c is d)  # Output: False (different objects)

2: Differentiating Equality (==) and Identity (is)

x = [1, 2, 3]
y = [1, 2, 3]

print(x == y)  # Output: True (same values)
print(x is y)  # Output: False (different objects)

3: Avoiding Redundant Object Creation

a = "hello"
b = "hello"
print(a is b)  # Output: True (string interning reuses memory)

5. Mini-Project: Duplicate Object Finder

Objective

Create a program that identifies if two variables refer to the same object in memory.

# Duplicate Object Finder

def check_object_identity(obj1, obj2):
    if obj1 is obj2:
        print("The objects are identical (share the same memory).")
    else:
        print("The objects are not identical (different memory locations).")

# Test cases
x = [1, 2, 3]
y = x
z = [1, 2, 3]

check_object_identity(x, y)  # Identical
check_object_identity(x, z)  # Not identical

Output:

The objects are identical (share the same memory).
The objects are not identical (different memory locations).

6. Common Pitfalls and Best Practices

Pitfall 1: Confusing is with ==

• is checks memory location.
• == checks value equality.

Example:

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)  # Output: True
print(a is b)  # Output: False

Pitfall 2: Immutable Object Optimization

Python optimizes memory by reusing small integers and short strings. Always test identity carefully with mutable objects.

Interview Questions and Answers

Google

Q: What is the difference between is and == in Python? Provide an example.
A: is checks if two variables refer to the same object in memory, while == checks if their values are equal.
Example:

x = [1, 2, 3]
y = [1, 2, 3]

print(x is y)  # Output: False
print(x == y)  # Output: True

Amazon

Q: How does Python manage memory for immutable and mutable objects in the context of identity operators?
A: Immutable objects like int and str are optimized for memory reuse, so identical values may share the same memory. Mutable objects like list and dict always allocate new memory.
Example:

a = 10
b = 10
print(a is b)  # Output: True (memory reuse)

x = [1, 2]
y = [1, 2]
print(x is y)  # Output: False (new memory allocation)

TCS

Q: Write a program to check if two tuples refer to the same object.
A:

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 3)

print(tuple1 is tuple2)  # Output: True (tuples are immutable)

Infosys

Q: Why does is return True for integers between -5 and 256?
A: Python caches integers in this range for performance optimization, so they share the same memory address.

Zoho

Q: Can the is operator be used with custom objects? Provide an example.
A: Yes, the is operator works with custom objects to check if they refer to the same instance.
Example:

class Test:
    pass

obj1 = Test()
obj2 = Test()
obj3 = obj1

print(obj1 is obj2)  # Output: False
print(obj1 is obj3)  # Output: True

Conclusion

Python’s identity operators (is and is not) are vital tools for comparing object references in memory. They are particularly useful when working with mutable objects, custom classes, and when optimizing memory usage. Understanding their nuances can help you write more efficient and error-free code.

Identity operators

Start Quiz

Question

Your answer:

Correct answer:

Next

You got {{SCORE_CORRECT}} out of {{SCORE_TOTAL}}

Your Answers