3 Facts of the Integer Caching in Python

Understand some confusing results made by Python

Python has a special feature called integer caching, or integer interning. Sometimes, it may make us confused. For example, if we run the following code on a Python shell, the results are surprising:

>>> a=256
>>> b=256
>>> a is b
True
>>> x=257
>>> y=257
>>> x is y
False

Why 256 is 256 but 257 is not 257? Anything wrong?

And this is not the weirdest part yet, if we put the same code into a file and run it as a Python script, the results will surprise us again!

We put all the code into the above script called “test.py”. Then open a terminal and run the script:

$ python test.py
True
True

😱 What? The statement x is y becomes True at this time.

If you are confused about these as well, no worries at all. This article will demystify how the integer caching feature works and summary it into three facts. After reading, you will not be confused about it anymore.

1. A Range of Small Integers Are Singletons in Python

Actually, in order to save time and memory costs, Python always pre-loads all the small integers in the range of [-5, 256]. When a new integer variable in this range is declared, Python just references the cached integer to it and won’t create any new object.

In other words, all the integers in [-5, 256] are singletons and they’ve been already saved in the memory. We cannot create a new integer object in this range.

Therefore, the explanations of the first example are obvious:

• When the variables a and b were assigned to 256, they were referenced to the same memory location where the 256 was stored. They pointed to the same object.
• When the variables a and b were assigned to 257, they were two different objects in different memory locations because the 257 is not on the small integers caching range.

Since the is operator is to compare the memory locations of two variables, the a is b should output True, and the x is y should output False.

We can also use the id() function, which prints the memory location of a variable, to confirm the above explanations:

>>> a=256
>>> b=256
>>> id(a)==id(b)
True
>>> x=257
>>> y=257
>>> id(x)==id(y)
False

2. The Results Are Different if the Python Compiler Can See the Whole Picture

As shown previously, if we run the same code as a Python script, the x is y will output True. This of course is not an accident.

In fact, the Python compiler is very smart and will do many optimisations for us under the hood. If we run our code as a whole script, the Python compiler can “see” the whole program at once and do the corresponding optimisations.

As to our example, since the Python compiler saw the whole program, it knew there are two variables x and y and they are equal to the same integer 257. Therefore, it was reasonable to create one integer object and reference the two variables into it. This optimisation can save time and memory costs.

However, if we run the code line by line in the interactive Python shell, the compiler can only see one line of code each time.

It means when we input y=257, the compiler just sees this line of code, and cannot remember the previous code x=257. Because the 257 is not in the special range, which is [-5, 256], a new integer object is created.

Since we know this character of the Python compiler, we can use a trick to make the x is y output True on the interactive shell as well:

>>> x=257; y=257
>>> x is y
True

As shown above, we can put the two assignments into one line. Since the interactive Python interpreter can see the two variables at once now, the optimisation works again.

3. The Implementations and Versions of Python Affect the Integer Caching Feature

All the above examples and explanations are based on CPython, which is the standard implementation of Python. In fact, there are some alternative implementations, such as PyPy, IronPython and Jython, and some mechanisms of them may be different from CPython.

For example, the small integers caching feature is disabled in PyPy by default. If we would like to turn on this feature, we should enable it at first. For more details, we can check out the corresponding documents of PyPy.

Besides, the version of Python also matters. What we used in this article is Python 3.8. Since Python is continuously updated and evolved, no one can make sure that one special feature won’t be changed in future versions.

Conclusion

Python has many optimization mechanisms internally, we should understand how it works and affects our code. The integer caching feature is useful and necessary to reduce time and memory costs. There are three facts under the hood:

1. The integers in the range of [-5, 256] are singletons in Python and can’t be recreated again.
2. If the Python compiler can see the whole code, more optimisations may apply to the code.
3. Different implementations and versions of Python may have different mechanisms for the same feature.

Thanks for reading. If you like it, don’t forget to follow me to get more great articles about programming and technologies!

Relative articles: