Why Does Python's `is` Operator Behave Differently with Small and Large Integers?

The 'is' Operator's Puzzling Behavior with Integers

In Python, the 'is' operator checks if two objects refer to the same object in memory. While this typically works as expected, it exhibits unexpected behavior with integers, leading to confusion among developers.

Unexpected Outcome with Large Integers

Consider the following code:

a = 256
b = 256
a is b  # True (expected)
a = 257
b = 257
a is b  # False (unexpected)

Why does the 'is' operator return False in the second comparison? Isn't 257 equal to 257?

CPython Implementation Detail

The odd behavior stems from a subtle implementation detail in CPython, the most common Python interpreter. For integers between -5 and 256, CPython maintains an array of integer objects. When you create an integer in this range, you simply get a reference to the existing object in the array. This means that for small integers within this range, the 'is' operator checks if they refer to the same object in the array.

Consequences and Implications

In the example above, when we assign 256 to a and b, we receive the same object from the array. Therefore, 'a is b' evaluates to True. However, when we assign 257 to a and b, we create two new objects that are not identical, resulting in 'a is b' returning False.

Alternative Comparison Method

To compare two arbitrary objects for equality, regardless of their type, you can use the '==' operator instead of 'is'. This will check the values of the objects rather than their identity.

a = 257
b = 257
a == b  # True

Remember, the 'is' operator should only be used when you need to check if two objects refer to the exact same object in memory, while '==' should be used to compare values.

The above is the detailed content of Why Does Python's `is` Operator Behave Differently with Small and Large Integers?. For more information, please follow other related articles on the PHP Chinese website!