Почему размер 2⁶³ 36 байт, но 2⁶³ -1 составляет всего 24 байта?

Все в Python - это объект. Таким образом, размер int в Python будет больше обычного.

>>> sys.getsizeof(int())
24

Хорошо, но почему требуется еще 2 байта для 2⁶³ по сравнению с 2⁶³ - 1 а не только один?

>>> sys.getsizeof(2**63)
36
>>> sys.getsizeof(2**62)
24

Я получаю, что 2⁶³ - это длинный и 2⁶³-1 int, но почему 12 байтов разницы?

Не более интуитивно, я пробовал некоторые другие вещи:

>>> a = 2**63
>>> a -= 2**62
>>> sys.getsizeof(a)
36

a по-прежнему сохраняется как длинный, даже если он может быть в int сейчас. Так что неудивительно. Но:

>>> a -= (2**63 - 1)
>>> a = 2**63
>>> a -= (2**63 - 1)
>>> a
1L
>>> sys.getsizeof(a)
28

Новый размер.

>>> a = 2**63
>>> a -= 2**63
>>> a
0L
>>> sys.getsizeof(a)
24

Возврат к 24 байтам, но с длинным.

Последнее, что я получил:

>>> sys.getsizeof(long())
24

Вопрос:

Как память хранится в этих сценариях?

Суб-вопросы:

Почему существует пробел в 12 байт, чтобы добавить то, что говорит нам наша интуиция, всего лишь 1 бит?

Почему int() и long() 24 байта, но long(1) уже 28 байтов и int(2⁶²)?

NB: Python 3.X работает немного по-другому, но не более интуитивно. Здесь я сосредоточился на Python 2.7; Я не тестировал предыдущие версии.

ОТВЕТЫ

Ответ 1

почему он получает еще 12 байтов для 2⁶³ по сравнению с 2⁶³ - 1, а не только один?

В системе LP64 1 Python int состоит из фиксированных трех частей размера указателя:

  • указатель типа
  • счетчик ссылок
  • фактическое значение, C long int

Всего 24 байта. С другой стороны, Python long состоит из:

  • указатель типа
  • счетчик ссылок
  • число цифр, целое число указателя
  • встроенный массив цифр значений, каждый из которых содержит 30 бит значения, но сохраняется в 32-битных единицах (один из неиспользуемых битов используется для эффективного переноса/записи во время сложения и вычитания)

2 ** 63 требует хранения 64 бит, поэтому он помещается в три 30-битные цифры. Поскольку каждая цифра имеет ширину 4 байта, весь Python long будет принимать 24 + 3 * 4 = 36 байт.

Другими словами, разница возникает из-за long хранения размера номера (8 дополнительных байтов), и от него немного меньше пространства для хранения значения (12 байтов для хранения цифр 2 ** 63). В том числе размер, значение 2 ** 63 в long занимает 20 байтов. Сравнивая это с 8 байтами, занятыми любым значением простого int получаем наблюдаемую 12-байтовую разницу.

1 64-разрядная версия Windows отличается тем, что сохраняет 32-битный long int , предположительно для совместимости с исходным кодом, с большим количеством старого кода, который использовал char, short и long как "удобные" псевдонимы для 8, 16 и 32-битных значений, которые работали как на 16, так и на 32-битных системах. Чтобы получить фактический 64-разрядный тип на Windows x86-64, нужно использовать __int64 или (в более новых версиях компилятора) long long или int64_t. Поскольку Python 2.7 внутренне зависит от того, как Python int вписывается в C в разных местах, sys.maxint остается 2**31-1, даже в 64-битной Windows. Все это исправлено в Python 3, чей единственный тип int имеет переменную ширину, например Python 2 long.

Ответ 2

Хотя я не нашел его в документации, вот мое объяснение.

Python 2 поддерживает int до long неявно, когда значение превышает значение, которое может быть сохранено в int. Размер нового типа (long) - это размер по умолчанию long, который равен 32. С этого момента размер вашей переменной будет определяться его значением, которое может увеличиваться и уменьшаться.

from sys import getsizeof as size
a = 1
n = 32

# going up
for i in range(10):
    if not i:
        print 'a = %100s%13s%4s' % (str(a), type(a), size(a))
    else:
        print 'a = %100s%14s%3s' % (str(a), type(a), size(a))
    a <<= n

# going down
for i in range(11):
    print 'a = %100s%14s%3s' % (str(a), type(a), size(a))
    a >>= n


a =                                                                                                    1 <type 'int'>  24
a =                                                                                           4294967296 <type 'long'> 32
a =                                                                                 18446744073709551616 <type 'long'> 36
a =                                                                        79228162514264337593543950336 <type 'long'> 40
a =                                                              340282366920938463463374607431768211456 <type 'long'> 44
a =                                                    1461501637330902918203684832716283019655932542976 <type 'long'> 48
a =                                           6277101735386680763835789423207666416102355444464034512896 <type 'long'> 52
a =                                 26959946667150639794667015087019630673637144422540572481103610249216 <type 'long'> 56
a =                       115792089237316195423570985008687907853269984665640564039457584007913129639936 <type 'long'> 60
a =              497323236409786642155382248146820840100456150797347717440463976893159497012533375533056 <type 'long'> 64
a =    2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576 <type 'long'> 68
a =              497323236409786642155382248146820840100456150797347717440463976893159497012533375533056 <type 'long'> 64
a =                       115792089237316195423570985008687907853269984665640564039457584007913129639936 <type 'long'> 60
a =                                 26959946667150639794667015087019630673637144422540572481103610249216 <type 'long'> 56
a =                                           6277101735386680763835789423207666416102355444464034512896 <type 'long'> 52
a =                                                    1461501637330902918203684832716283019655932542976 <type 'long'> 48
a =                                                              340282366920938463463374607431768211456 <type 'long'> 44
a =                                                                        79228162514264337593543950336 <type 'long'> 40
a =                                                                                 18446744073709551616 <type 'long'> 36
a =                                                                                           4294967296 <type 'long'> 32
a =                                                                                                    1 <type 'long'> 28

Как вы можете видеть, тип остается long после того, как он стал слишком большим для int, а начальный размер был 32, но размер изменяется со значением (может быть выше или ниже [или равно, очевидно] до 32)

Итак, чтобы ответить на ваш вопрос, размер базы составляет 24 для int, а 28 для long, а в то же long имеет место для сохранения больших значений (которое начинается как 4 байта - следовательно, 32 байта в long, но может идти вверх и вниз в соответствии с к значению)

Что касается вашего подзапроса, создание уникального типа (с уникальным размером) для нового номера невозможно, поэтому у Python есть "подклассы" long типа, которые имеют дело с диапазоном чисел, поэтому, если вы превысите лимит из вашего старого long вы должны использовать новее, в котором также учитываются гораздо большие числа, поэтому он имеет еще несколько байтов.