Python's layout of low-value ints in memory

Question

My question is: where do these patterns (below) originate? I learned (somewhere) that Python has unique "copies", if that's the right word, for small integers. For example: ``` >>> x = y = 0 >>> id(0) 4297074752 >>> id(x) 4297074752 >>> id(y) 4297074752 >>> x += 1 >>> id(x) 4297074728 >>> y 0 ``` When I look at the memory locations of ints, there is a simple pattern early: ``` >>> N = id(0) >>> for i in range(5): ... print i, N - id(i) ... 0 0 1 24 2 48 3 72 4 96 >>> bin(24) '0b11000' ``` It's not clear to me why this is chosen as the increment. Moreover, I can't explain this pattern at all above 256: ``` >>> prev = 0 >>> for i in range(270): ... t = (id(i-1), id(i)) ... diff = t[0] - t[1] ... if diff != prev: ... print i-1, i, t, diff ... prev = diff ... -1 0 (4297074776, 4297074752) 24 35 36 (4297073912, 4297075864) -1952 36 37 (4297075864, 4297075840) 24 76 77 (4297074904, 4297076856) -1952 77 78 (4297076856, 4297076832) 24 117 118 (4297075896, 4297077848) -1952 118 119 (4297077848…

Accepted Answer

Low-value integers are preallocated, high value integers are allocated whenever they are computed. Integers that appear in source code are the same object. On my system,

```
>>> id(2) == id(1+1)
True
>>> id(1000) == id(1000+0)
False
>>> id(1000) == id(1000)
True
```

You'll also notice that the ids depend on the system. They're just memory addresses, assigned by the system allocator (or possibly the linker, for static objects?)

```
>>> id(0)
8402324
```

Edit: The reason `id(1000) == id(1000)` is because the Python compiler notices that two of the integer constants in the code it's compiling are the same, so it only allocates one object for both. This would be an unacceptable performance hit at runtime, but at compile time it's not noticeable. (Yes, the interpreter is also a compiler. Most interpreters are also compilers, very few aren't.)

Python's layout of low-value ints in memory

Solution

Problem

Related problems