Identity Operator in Python

Last Updated : 12 Jun 2025

In Python, identity operators are special operators used to compare the memory locations of two objects. Instead of comparing the values held by the variables, they check whether two variables refer to the exact same object in memory.

Python provides two identity operators:

Operator	Description
is	Checks if two variables refer to the same object in memory
is not	Checks if two variables refer to different objects in memory

These are particularly useful in situations where it matters whether two variables point to the same object, not just equivalent values.

Python 'is' operator

The 'is' operator in Python checks whether two variables refer to the same object in memory.

Here is a simple example of Python 'is' operator:

Example

# defining variables
x = 10
y = 10

# using is operator
print(x is y)

Execute Now

Output:

True

Explanation:

In the above example, we have used the 'is' operator to check if x and y refer to the exact same object in the memory.

Note: Python reuses small integer objects (from -5 to 256) to save memory. So, variables with the same value in this range may point to the same object.

Let us now see another example:

Example

# Immutable Types
a = 100
b = 100
print("a is b:", a is b)  

x = 10000
y = 10000
print("x is y:", x is y)  

# Mutable Types
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print("list1 == list2:", list1 == list2)  
print("list1 is list2:", list1 is list2)  

list3 = list1
print("list1 is list3:", list1 is list3)  

# Strings (interning behavior)
s1 = "hello"
s2 = "hello"
print("s1 is s2:", s1 is s2)  

s3 = "".join(["he", "llo"])
print("s1 == s3:", s1 == s3)  
print("s1 is s3:", s1 is s3)  

# Using 'is' with None
val = None
print("val is None:", val is None)  

# Creating two identical dicts
dict1 = {"a": 1}
dict2 = {"a": 1}
print("dict1 is dict2:", dict1 is dict2)  

Execute Now

Output:

a is b: True
x is y: False
list1 == list2: True
list1 is list2: False
list1 is list3: True
s1 is s2: True
s1 == s3: True
s1 is s3: False
val is None: True
dict1 is dict2: False

Explanation:

The 'is' operator checks if two variables point to the same object in memory. For small numbers and simple strings, Python often reuses the same object, so it can return True. But for larger numbers, lists, dictionaries, or newly created strings, even if the values are the same, they are usually stored separately, so it returns False. It's also commonly used to check if something is None, like val is None.

Python 'is not' Operator

The 'is not' operator in Python is used to check if two variables do NOT refer to the same object in memory.

Here is an example of Python 'is not' operator:

Example

# defining variables
x = 1000
y = 1000

# using 'is not' operator
print(x is not y)

Execute Now

Output:

True

Explanation:

In this example, we used the 'is not' operator to check if both variables pointing to the same object.

Since both variables are referring to the different objects in memory, the output returns as True.

Let us see another example:

Example

# Immutable Objects
a = 100
b = 100
print("a is not b:", a is not b)  # False - same object (interned)

x = 10000
y = 10000
print("x is not y:", x is not y)  # True - may be different objects (not interned)

# Mutable Objects
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print("list1 is not list2:", list1 is not list2)  # True - same values, different objects
print("list1 != list2:", list1 != list2)          # False - values are same

list3 = list1
print("list1 is not list3:", list1 is not list3)  # False - exact same object

# Strings
str1 = "hello"
str2 = "hello"
print("str1 is not str2:", str1 is not str2)  # False - interned strings, same object

str3 = "".join(["he", "llo"])
print("str1 is not str3:", str1 is not str3)  # True - dynamically created, might differ

# None check (best use case)
value = None
print("value is not None:", value is not None)  # False - value IS None

# Custom objects
class Car:
    pass

car1 = Car()
car2 = Car()
car3 = car1

print("car1 is not car2:", car1 is not car2)  # True - different instances
print("car1 is not car3:", car1 is not car3)  # False - same object

Execute Now

Output:

a is not b: False
x is not y: True
list1 is not list2: True
list1 != list2: False
list1 is not list3: False
str1 is not str2: False
str1 is not str3: True
value is not None: False
car1 is not car2: True
car1 is not car3: False

Explanation:

In Python, the expression x is not y checks if x and y are not the same object in memory. It returns True if they are two separate objects, even if they look the same or have the same value.

Note: Even if two things look the same, they might still be different objects.

Difference Between 'is' and '=='

The following table shows the difference between 'is' and '==':

Operator	Checks	Returns (if True)
==	Value Equality	The contents/values of the objects are the same
is	Object Identity (memory)	Both variables point to the same object

Let us understand the difference between the two with the help of an example:

Example

# defining variables
var_1 = ['tpoint', 'tech']
var_2 = ['tpoint', 'tech']
var_3 = var_1 # var_3 and var_1 point to same object in memory

# use of '==' operator
print("var_1 == var_2 =>", var_1 == var_2)
print("var_1 == var_3 =>", var_1 == var_3)

print()

# use of 'is' operator
print("var_1 is var_2 =>", var_1 is var_2)
print("var_1 is var_3 =>", var_1 is var_3)

Execute Now

Output:

var_1 == var_2 => True
var_1 == var_3 => True

var_1 is var_2 => False
var_1 is var_3 => True

Explanation:

In this example, we can clearly see the difference between the '==' and 'is' operators.

Conclusion

In Python, the 'is' and 'is not' operators are used to check if two variables point to the same object in memory. They don't compare values like '==' does. Use is when you want to see if two things are exactly the same object, and use is not to check if they are different objects. This is especially helpful when checking for None or when working with mutable data like lists and dictionaries.