What happens behind the scenes when python adds small ints? [duplicate]

Question

I was fiddling around with id recently and realized that (c?)Python does something quite sensible: it ensures that small ints always have the same id.

>>> a, b, c, d, e = 1, 2, 3, 4, 5 >>> f, g, h, i, j = 1, 2, 3, 4, 5 >>> [id(x) == id(y) for x, y in zip([a, b, c, d, e], [f, g, h, i, j])] [True, True, True, True, True] 

But then it occurred to me to wonder whether the same is true for the results of mathematical operations. Turns out it is:

>>> nines = [(x + y, 9) for x, y in enumerate(reversed(range(10)))] >>> [id(x) == id(y) for x, y in nines] [True, True, True, True, True, True, True, True, True, True] 

Seems like it starts failing at n=257...

>>> a, b = 200 + 56, 256 >>> id(a) == id(b) True >>> a, b = 200 + 57, 257 >>> id(a) == id(b) False 

But sometimes it still works even with larger numbers:

>>> [id(2 * x + y) == id(300 + x) for x, y in enumerate(reversed(range(301)))][:10] [True, True, True, True, True, True, True, True, True, True] 

What's going on here? How does python do this?

Answer 1

You've fallen into a not uncommon trap:

id(2 * x + y) == id(300 + x) 

The two expressions 2 * x + y and 300 + x don't have overlapping lifetimes. That means that Python can calculate the left hand side, take its id, and then free the integer before it calculates the right hand side. When CPython frees an integer it puts it on a list of freed integers and then re-uses it for a different integer the next time it needs one. So your ids match even when the result of the calculations are very different:

>>> x, y = 100, 40000 >>> id(2 * x + y) == id(300 + x) True >>> 2 * x + y, 300 + x (40200, 400)