Identity operators

Identity operators are used to check whether two variables refer to the same object in memory. Unlike comparison operators, which compare the values of two variables, identity operators compare the memory locations of the objects.
Python provides two identity operators: "is" and "is not". These operators return a Boolean value ("True" or "False") depending on whether the variables point to the same object.
Identity operators are commonly used when checking for objects such as "None", comparing object references, and understanding how Python stores data in memory. In this article, we will learn what identity operators are, why they are important, their types, practical examples, common beginner mistakes, and frequently asked questions.
 

Table of Contents

What are Identity Operators?

Identity operators are used to determine whether two variables refer to the same object in memory.
Unlike comparison operators ("=="), identity operators do not compare values. Instead, they compare the identity (memory location) of objects.
Example: 
# Python program to implement identity
# operator
a = [1, 2, 3]
b = a
print(a is b)
Output:
True
Explanation:
  1. The variable "a" stores a list.
  2. The variable "b" refers to the same list as "a".
  3. Since both variables point to the same object in memory, the "is" operator returns "True".

Why are Identity Operators Important?

Identity operators help programmers determine whether two variables refer to the same object instead of simply having the same value. Some of the benefits of using identity operators are:
  1. Compares Object Identity: Identity operators check whether two variables refer to the same object in memory.
  2. Useful with "None": The "is" operator is the recommended way to check whether a variable is "None".
  3. Improves Program Accuracy: They help avoid confusion between comparing values and comparing object references.
  4. Useful in Object-Oriented Programming: Identity operators are commonly used while working with classes and objects.
  5. Helps Understand Memory Management: They provide insight into how Python stores and manages objects in memory.

Types of Identity Operators

1. "is" Operator: The "is" operator checks whether two variables refer to the same object in memory. If they are, it returns "True"; otherwise, it returns "False".
Syntax:
object1 is object2
Example: 
# Python program to implement "is" 
# operator
a = [10, 20]
b = a
print(a is b)
Output:
True
Explanation: The variable "b" refers to the same list as "a", so both variables point to the same memory location.

Example with Different Objects: 
# Python program to implement "is"
# operator with different objects
a = [10, 20]
b = [10, 20]
print(a is b)
Output:
False
Explanation: Although both lists contain the same values, they are stored as different objects in memory. Therefore, "is" returns "False".
 
2. "is not" Operator: The "is not" operator checks whether two variables refer to different objects in memory.
Syntax:
object1 is not object2
Example: 
# Python program to implement "is not" 
# operator
a = [10, 20]
b = [10, 20]
print(a is not b)
Output:
True
Explanation: The lists contain the same values but are different objects, so "is not" returns "True".

Difference Between "==" and "is"

Feature == Operator is Operator
Purpose Compares the values of two objects. Compares whether two variables refer to the same object in memory.
Comparison Type Value comparison Identity (memory) comparison
Returns True When Both objects have the same value. Both variables point to the same object in memory. 
Returns False When The values are different. The variables point to different objects, even if their values are the same.
Common use Comparing numbers, strings, lists, tuples, etc. Checking object identity, especially with None or object references.

Example: 
# Python program to show difference between
# == and is operator
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)
print(a is b)
Output:
True
False
Explanation:
  1. "a == b" returns "True" because both lists have the same values.
  2. "a is b" returns "False" because they are different objects in memory.

Difference Between "!=" and "is not"

Feature != Operator is not Operator
Purpose Checks whether the values of two objects are different. Checks whether two variables refer to different objects in memory.
Comparison Type Value comparison Identity (memory) comparison
Returns True when The values of the objects are different. The variables point to different objects in memory.
Returns False when Both objects have the same value. Both variables point to the same object in memory.
Common Use Comparing values to check inequality. Checking whether two variables are not the same object.

Example: 
# Python program to show difference between
# != and is not operator
a = [10, 20]
b = [10, 20]
print(a != b)
print(a is not b)
Output:

False
True

Explanation:
  1. "a != b" returns False because both lists contain the same values.
  2. "a is not b" returns True because "a" and "b" are stored as different objects in memory, even though their values are identical.

Complete Program Using Identity Operators

Below is the Python program to implement identity operators: 
# Python program to implement all identity operators 
# Creating variables
a = [1, 2, 3]
b = a
c = [1, 2, 3]
# Using 'is'
print(a is b)
print(a is c)
# Using 'is not'
print(a is not c)
Output:
True
False
True

Explanation:

  1. a = [1, 2, 3]: Creates a list and stores it in the variable "a".
  2. b = a: The variable "b" refers to the same object as "a".
  3. c = [1, 2, 3]: A new list is created with the same values, but it has a different memory location.
  4. print(a is b): Returns "True" because both variables point to the same object.
  5. print(a is c): Returns "False" because "a" and "c" are different objects.
  6. print(a is not c): Returns "True" because the two variables refer to different objects.

Common Beginner Mistakes

1. Using "is" Instead of "==" for Value Comparison: The "is" operator compares object identity, not values.
Wrong:
a = [1, 2]
b = [1, 2]
print(a is b)
 
Correct:
a = [1, 2]
b = [1, 2]
print(a == b)
2. Thinking Same Values Mean Same Object: Objects can have identical values but still be stored at different memory locations.
Wrong:
x = [5]
y = [5]
print(x is y)
 
Correct:
x = [5]
y = [5]
print(x == y)
3. Using "== None" Instead of "is None": The recommended way to check for "None" is by using "is".
Wrong:
value = None
print(value == None)
 
Correct:
value = None
print(value is None)
4. Confusing "is not" with "!=": "is not" checks object identity, whereas "!=" compares values.
Wrong:
a = [1]
b = [2]
print(a is not b)
 
Correct (when comparing values):
a = [1]
b = [2]
print(a != b)
5. Assuming Strings and Numbers Always Behave the Same: Python may reuse some small integers and strings internally, so the result of "is" can sometimes be unexpected. Use "==" when you want to compare values.
Wrong:
x = "Python"
y = "Python"
print(x is y)
 
Correct:
x = "Python"
y = "Python"
print(x == y)

Conclusion

Identity operators are used to determine whether two variables refer to the same object in memory. Python provides two identity operators: "is" and "is not". Unlike comparison operators, identity operators do not compare values; instead, they compare object identity. Understanding identity operators helps you write more accurate Python programs, especially when working with objects and checking for "None" as a result instead of errors.

Frequently Asked Questions

1. What are identity operators in Python?
Identity operators are used to check whether two variables refer to the same object in memory.
2. Which identity operators are available in Python?
Python provides two identity operators: "is" and "is not".
3. What is the difference between "==" and "is"?
"==" compares values, whereas "is" compares whether two variables refer to the same object in memory.
4. When should I use the "is" operator?
The "is" operator is commonly used to compare object identity and to check whether a variable is "None".
5. What does the "is not" operator do?
The "is not" operator checks whether two variables refer to different objects in memory.
6. Do identity operators return Boolean values?
Yes. Identity operators always return either "True" or "False".
July 4, 2026 12:00 AM
users profile
By Ayush Srivastava

I'm a computer science diploma student with interest in programming and technical writing. I enjoy creating simple, easy to understand content that helps beginners learn python and other programming concepts.

0 Comments
Leave a Reply