Why Does Python\'s \"is\" Operator Behave Differently with Large Integers in Different Code Blocks?

Python’s “is” Operator Behavior with Large Integers

Issue

In Python, the is operator checks object identity rather than equivalence. However, in certain scenarios, this behavior can be unexpected, as demonstrated below:

<code class="python">def func():
    a = 1000
    b = 1000
    return a is b

a = 1000
b = 1000

print(a is b, func())  # (False, True)</code>

The is comparison returns True within the function, but False outside it. Despite the different evaluation results, the integers a and b appear to have the same value.

Explanation

To understand this behavior, the Python interpreter's interpretation of code blocks is crucial. According to the Python reference manual, each command executed interactively constitutes a separate code block. The following are considered blocks:

• Modules
• Function bodies
• Class definitions

Within a single code block, Python caches certain objects, such as small integers (within the range [-5, 256]). When multiple variables refer to the same integer literal, they will all refer to the same cached integer object. However, if the literals are declared in different code blocks, distinct integer objects will be created.

Different Code Objects, Different Identities

To illustrate this, consider the code objects for each case:

• Function func: a and b refer to the same integer object (cached by Python since 1000 is within the cached integer range).
• Interactive commands: a and b refer to different integer objects because they are defined in separate code blocks.

As a result, a is b evaluates to True within the func block, where all integers are cached, and False outside the block, where separate objects are created.

Caveats

Note the following caveats:

• Chaining assignment statements within a single line can result in True identity checks.
• Module-level executions will return True due to the single code block for a module.
• Tests involving mutable objects will always return False because they are not cached.

Conclusion

Understanding the concept of code blocks in Python is essential for interpreting unexpected behavior involving identity comparisons. While is is useful for checking the identity of immutable objects, it is recommended to use the equality operator (==) for comparing values, as it does not rely on caching.

The above is the detailed content of Why Does Python\'s \"is\" Operator Behave Differently with Large Integers in Different Code Blocks?. For more information, please follow other related articles on the PHP Chinese website!