Identity operators in Python are used to compare objects and determine whether they are the same object in memory. These operators don’t compare the values of the objects but rather their memory addresses.
Python provides two identity operators:
is: Returns True if both variables point to the same object (i.e., they are identical).
is not: Returns True if both variables point to different objects (i.e., they are not identical).
1. Identity Operators Syntax
is: Evaluates to True if two variables reference the same object in memory.
is not: Evaluates to True if two variables reference different objects in memory.
2. Identity Operators with Examples
a) Using the is Operator
The is operator checks if two variables refer to the same object in memory.
# Example using 'is' a = [1, 2, 3] b = a # Both 'a' and 'b' point to the same list object in memory # Check if 'a' and 'b' are the same object print(a is b) # Output: True # Check if 'a' and 'b' have the same value (also True) print(a == b) # Output: True
In this example, a and b reference the same list object, so a is b returns True.
b) Using the is not Operator
The is not operator checks if two variables refer to different objects in memory.
# Example using 'is not' a = [1, 2, 3] b = [1, 2, 3] # 'a' and 'b' contain the same values but are different objects # Check if 'a' and 'b' are not the same object print(a is not b) # Output: True # Check if 'a' and 'b' have the same value (True) print(a == b) # Output: True
In this case, a and b contain the same values, but they are two different objects in memory, so a is not b returns True.
3. Difference Between is and ==
is: Checks whether two variables reference the same object in memory.
==: Checks whether two variables have the same value, even if they are different objects.
# Example: Difference between 'is' and '==' a = [1, 2, 3] b = [1, 2, 3] # 'a' and 'b' have the same value print(a == b) # Output: True # 'a' and 'b' are different objects print(a is b) # Output: False
In this case, a == b evaluates to True because they contain the same values, but a is b evaluates to False because they are different objects.
4. Identity Operators with Immutable Data Types
In Python, immutable data types like integers, strings, and tuples can sometimes exhibit behavior where two variables with the same value refer to the same object in memory, thanks to Python’s optimization.
a) Identity with Integers
For small integers (usually between -5 and 256), Python reuses the same object in memory for optimization purposes.
# Example using small integers x = 100 y = 100 # Check if 'x' and 'y' refer to the same object print(x is y) # Output: True # Example using larger integers x = 1000 y = 1000 print(x is y) # Output: False (in most cases)
In the first case, x is y returns True because Python reuses small integer objects. In the second case, with larger integers, x is y typically returns False because Python creates separate objects for larger integers.
b) Identity with Strings
Python optimizes memory usage by reusing small string objects that are the same.
# Example using small strings a = "hello" b = "hello" print(a is b) # Output: True # Example using large or complex strings a = "this is a long string" b = "this is a long string" print(a is b) # Output: True (depends on Python's optimization, but usually True)
Python may reuse string objects for optimization, so a is b often returns True for identical strings.
5. Identity Operators with Mutable Data Types
For mutable data types like lists and dictionaries, identity operators generally show that different variables refer to different objects, even if the values are identical.
Example with Lists
# Example with lists list1 = [1, 2, 3] list2 = [1, 2, 3] # Check if list1 and list2 are the same object print(list1 is list2) # Output: False # Check if list1 and list2 have the same value print(list1 == list2) # Output: True
Even though list1 and list2 contain the same values, they are different objects, so list1 is list2 returns False.
6. Practical Examples with Identity Operators
a) Check if Two Variables Point to the Same Object
This example demonstrates checking whether two variables point to the same object in memory.
# Example: Checking identity of objects
x = [10, 20, 30]
y = x
if x is y:
print("x and y point to the same object in memory.")
else:
print("x and y are different objects.")
Since y = x points y to the same object as x, the output will be:
x and y point to the same object in memory.
b) Check if Two Variables Reference Different Objects
This example demonstrates checking whether two variables reference different objects.
# Example: Checking if two variables reference different objects
x = [10, 20, 30]
y = [10, 20, 30]
if x is not y:
print("x and y are different objects.")
else:
print("x and y point to the same object.")
Even though x and y have the same values, they are different objects, so the output will be:
x and y are different objects.
c) Identity Operators in Functions
Identity operators can also be useful when checking whether the same object is passed into a function.
def check_same_object(obj1, obj2):
if obj1 is obj2:
print("Both arguments refer to the same object.")
else:
print("The arguments refer to different objects.")
# Example: Passing the same object
a = [1, 2, 3]
b = a
check_same_object(a, b) # Output: Both arguments refer to the same object.
# Example: Passing different objects
c = [1, 2, 3]
check_same_object(a, c) # Output: The arguments refer to different objects.
7. Special Cases: None and Identity Operators
In Python, None is a special singleton object that is often compared using the is operator because there’s only one instance of None in memory.
# Example: Comparing None
x = None
y = None
print(x is y) # Output: True
# This is the recommended way to check if a variable is None
if x is None:
print("x is None.")
Summary
is: Checks if two variables reference the same object in memory.
is not: Checks if two variables reference different objects in memory.
Identity operators work with all types of objects, but are particularly useful when dealing with mutable objects and special values like None.
is vs. ==: is checks for object identity (same memory location), whereas == checks for value equality (same values but possibly different objects).
By understanding and using identity operators in Python, you can perform object comparisons at a deeper level, ensuring that you’re checking for object identity, which can be crucial when working with mutable data types or singleton objects like None.
