Identity Operators

Python offers a unique set of operators called identity operators, which are used to compare the memory locations of objects, rather than their values. Unlike equality operators (== and !=), which check for value equality, identity operators (is and is not) check if two variables point to the same object in memory. Understanding this distinction is important for writing efficient and error-free Python code.

This post will look into the functionality of Python’s identity operators, is and is not, with clear examples to illustrate their usage and potential pitfalls.

The is Operator

The is operator returns True if two variables refer to the same object in memory; otherwise, it returns False. It’s essentially checking for object identity.

x = [1, 2, 3]
y = x  # y now points to the same list object as x

print(x is y)  # Output: True
print(x == y)  # Output: True (value equality)


a = [1, 2, 3]
b = [1, 2, 3]  # a and b are distinct list objects, even if they have the same values.

print(a is b)  # Output: False (different memory locations)
print(a == b)  # Output: True (value equality)

Notice how x and y point to the same list object, resulting in True for is. However, a and b, despite containing the same elements, are distinct objects in memory, leading to False for is, but True for == as their values are equal.

The is not Operator

The is not operator is the converse of is. It returns True if two variables refer to different objects in memory; otherwise, it returns False.

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

print(x is not y)  # Output: True (different objects)

x = 10
y = 10

print(x is not y) # Output: False (for small integers, python often reuses objects for efficiency)

z = 1000
w = 1000

print(z is not w) # Output: True (for larger numbers, distinct objects might be created)

The example above highlights that Python’s optimization for small integers might reuse objects, influencing the outcome of is and is not. For larger numbers, however, this optimization is less likely.

Common Use Cases

• Checking for None: The is operator is frequently used to check if a variable is None:

my_variable = None
if my_variable is None:
    print("The variable is None")

• Singleton Pattern: The is operator can be utilized to enforce the singleton pattern, ensuring that only one instance of a class exists:

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

Understanding identity operators enhances your ability to write more precise Python code, particularly when dealing with mutable objects and memory management. They are a powerful tool for managing object references and identity checks within your applications.