Различный размер объекта True и False в Python 3
Экспериментируя с магическими методами (__sizeof__ в частности) на разных объектах Python я наткнулся на следующее поведение:
Python 2.7
>>> False.__sizeof__()
24
>>> True.__sizeof__()
24
Python 3.x
>>> False.__sizeof__()
24
>>> True.__sizeof__()
28
Что изменилось в Python 3, что делает размер True больше чем размер False?
4 ответа
Это потому что bool это подкласс int в обоих Python 2 и 3.
>>> issubclass(bool, int)
True
Но int реализация изменилась.
В Python 2 int был тот, который был 32 или 64 бит, в зависимости от системы, а не произвольной длины long,
В Python 3 int произвольной длины - long Python 2 был переименован в int и оригинальный Python 2 int упал в целом.
В Python 2 вы получаете точно такое же поведение для длинных объектов 1L а также 0L:
Python 2.7.15rc1 (default, Apr 15 2018, 21:51:34)
[GCC 7.3.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.getsizeof(1L)
28
>>> sys.getsizeof(0L)
24
long /Python 3 int это объект переменной длины, как и кортеж - когда он выделяется, выделяется достаточно памяти для хранения всех двоичных цифр, необходимых для его представления. Длина переменной части хранится в заголовке объекта. 0 не требует двоичных цифр (переменная длина равна 0), но даже 1 разливается и требует дополнительных цифр.
Т.е. 0 представляется в виде двоичной строки длиной 0:
<>
и 1 представлен в виде 30-битной двоичной строки:
<000000000000000000000000000001>
Конфигурация по умолчанию в Python использует 30 бит в uint32_t; so 2**30 - 1 по-прежнему умещается в 28 байт на x86-64, и 2**30 потребуется 32;
2**30 - 1 будет представлен как
<111111111111111111111111111111>
т.е. все 30 битов значения установлены в 1; 2**30 потребуется больше, и у него будет внутреннее представление
<000000000000000000000000000001000000000000000000000000000000>
Что касается True используя 28 байтов вместо 24 - вам не нужно беспокоиться. True является одноэлементным, и поэтому в любой программе Python теряется всего 4 байта, а не 4 для каждого использования True,
И то и другое True а также False являются longobject s в CPython:
struct _longobject _Py_FalseStruct = { PyVarObject_HEAD_INIT(&PyBool_Type, 0) { 0 } }; struct _longobject _Py_TrueStruct = { PyVarObject_HEAD_INIT(&PyBool_Type, 1) { 1 } };
Таким образом, вы можете сказать, что логическое значение является подклассом Python-3.x int где True принимает в качестве значения 1, а также False принимает в качестве значения 0, Таким образом, мы призываем PyVarObject_HEAD_INIT с как type параметр ссылка на PyBool_Type и с ob_size как ценность 0 а также 1 соответственно.
Теперь, начиная с Python-3.x, нет long больше: они были объединены, и int Объект будет, в зависимости от размера числа, принимать другое значение.
Если мы проверяем исходный код longlobject типа, мы видим:
/* Long integer representation. The absolute value of a number is equal to SUM(for i=0 through abs(ob_size)-1) ob_digit[i] * 2**(SHIFT*i) Negative numbers are represented with ob_size < 0; zero is represented by ob_size == 0. In a normalized number, ob_digit[abs(ob_size)-1] (the most significant digit) is never zero. Also, in all cases, for all valid i, 0 <= ob_digit[i] <= MASK. The allocation function takes care of allocating extra memory so that ob_digit[0] ... ob_digit[abs(ob_size)-1] are actually available. CAUTION: Generic code manipulating subtypes of PyVarObject has to aware that ints abuse ob_size's sign bit. */ struct _longobject { PyObject_VAR_HEAD digit ob_digit[1]; };
Короче говоря, _longobject можно рассматривать как массив "цифр", но здесь вы должны видеть цифры не как десятичные цифры, а как группы битов, которые, таким образом, могут быть добавлены, умножены и т. д.
Теперь, как указано в комментарии, это говорит о том, что:
zero is represented by ob_size == 0.
Таким образом, если значение равно нулю, никакие цифры не добавляются, тогда как для маленьких целых чисел (значения менее 2 30 в CPython) требуется одна цифра и т. Д.
В python-2.x было два типа представлений для чисел, int s (с фиксированным размером), вы можете увидеть это как "одну цифру", и long s, с несколькими цифрами. Так как bool был подклассом int, и то и другое True а также False занимал одно и то же пространство.
Я не видел код CPython для этого, но я считаю, что это как-то связано с оптимизацией целых чисел в Python 3. Возможно, как long был отброшен, некоторые оптимизации были объединены. int в Python 3 - int произвольного размера - так же, как long был в Python 2. Как bool магазины так же, как новые int, это влияет на оба.
Интересная часть:
>>> (0).__sizeof__()
24
>>> (1).__sizeof__() # Here one more "block" is allocated
28
>>> (2**30-1).__sizeof__() # This is the maximum integer size fitting into 28
28
+ байты для заголовков объекта должны завершить уравнение.
Взгляните на код cpython для True а также False
Внутренне это представляется как целое число
PyTypeObject PyBool_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"bool",
sizeof(struct _longobject),
0,
0, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
bool_repr, /* tp_repr */
&bool_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
bool_repr, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
bool_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
&PyLong_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
bool_new, /* tp_new */
};
/* The objects representing bool values False and True */
struct _longobject _Py_FalseStruct = {
PyVarObject_HEAD_INIT(&PyBool_Type, 0)
{ 0 }
};
struct _longobject _Py_TrueStruct = {
PyVarObject_HEAD_INIT(&PyBool_Type, 1)
{ 1 }