Целые числа (int) в Python — хранение, операции с примерами

В этом руководстве вы узнаете о целых числах и о том, как Python хранит целые числа в памяти.

Integers — это целые числа, которые включают отрицательные числа, ноль и положительные числа: -3, -2, -1, 0, 1, 2, 3. Python использует тип int для представления всех целых чисел. Все целые числа являются объектами.

• Как компьютеры хранят целые числа
• Как Python представляет целые числа
• Тип int в Python
• Получение размера целого числа
• Целочисленные операции в Python

Как компьютеры хранят целые числа

Компьютеры не могут напрямую хранить целые числа. Вместо этого они могут хранить только бинарные числа, такие как 0 и 1. Чтобы хранить целые числа, компьютеры должны использовать двоичные числа для их представления.

Например, чтобы сохранить число 5, необходимо представить его в виде числа с основанием 2:

5 = 1 x 2² + 0 x 2¹ + 1 x 2⁰

Как видите, для хранения числа 5 в памяти требуется 3 бита:

(101)₂ = (5)₁₀

Предположим, что у вас 8 бит, вы можете хранить до 255 целых чисел от нуля до 255:

255= 1x 2⁷ + 1 x 2⁶ + 1 x 2⁵ + 1x 2⁴ + 1 x 2³ + 1 x 2² + 1x 2¹ + 1 x 2⁰

Используя 8 бит, вы можете хранить до 2⁸ – 1 = 255 целых чисел.

Чтобы хранить отрицательные целые числа, ноль и положительные целые числа, вам необходимо зарезервировать 1 бит для хранения знака, отрицательного(-) и положительного(+). Следовательно, с 8 битами:

• Самое большое целое число, которое могут представить компьютеры, 2⁷ = 127.
• И компьютеры могут хранить все целые числа в диапазоне(-127, 127).

Поскольку число ноль не имеет знака, компьютеры могут получить дополнительное число. Следовательно, 8 бит могут хранить все целые числа от -128 до 127.

8 бит = [-2⁷, 2⁷ – 1]

Аналогично, если вы хотите использовать 16, 32 и 64 бита для хранения целых чисел, диапазоны будут такими:

• 16 бит ~ [-2¹⁵, 2¹⁵ – 1] = [-32 768, 32 767]
• 32 бита ~ [-2³¹, 2³¹ – 1] = [-2 147 483 648, 2 147 483 647]
• 64 бита ~ [-2⁶³, 2⁶³ – 1] = [-9 223 372 036 854 775 808, 9 223 372 036 854 775 807]

Как Python представляет целые числа

Другие языки программирования, такие как Java и C#, используют фиксированное количество бит для хранения целых чисел.

Например, в C# есть тип int, использующий 32 бита, и тип long, использующий 64 бита для представления целых чисел. На основе целочисленных типов вы можете определить диапазоны целых чисел, которые эти типы могут представлять.

Однако в Python нет фиксированного количества бит для хранения целых чисел. Вместо этого Python использует переменное количество бит. Например, 8 бит, 16 бит, 32 бита, 64 бита, 128 бит и так далее. Максимальное целое число, которое может представлять Python, зависит от доступной памяти.

Кроме того, целые числа являются объектами. Python требует дополнительного фиксированного количества байтов для каждого целого числа.

Важно отметить, что чем больше целые числа, тем медленнее будут вычисления, такие как +, -, ….

Тип int в Python

Ниже определяется переменная, которая ссылается на целое число и использует функцию type() для получения имени класса целого числа:

counter = 10
print(type(counter))

Выход:

<class 'int'>

Как ясно видно из вывода, целое число является экземпляром класса int.

Получение размера целого числа

Чтобы получить размер целого числа, используйте функцию getsizeof() модуля sys.

Функция getsizeof() возвращает количество байтов, которые Python использует для представления целого числа. Например:

from sys import getsizeof

counter = 0
size = getsizeof(counter)

print(size)  # 24 bytes

Выход:

24

Для хранения числа 0 Python использует 24 байта. С момента хранения числа ноль Python необходимо использовать только 1 бит. Как известно, 1 байт равен 8 битам.

Таким образом, вы можете подумать, что Python использует 24 байта в качестве служебных данных для хранения целочисленного объекта.

Следующая команда возвращает размер целого числа 100:

from sys import getsizeof

counter = 100
size = getsizeof(counter)

print(size)  # 28 bytes

Выход:

28

Он возвращает 28 байт. Поскольку 24 байта — это накладные расходы, Python использует 4 байта для представления числа 100.

Ниже показан размер целого числа 264:

from sys import getsizeof

counter = 2**64
size = getsizeof(counter)

print(size)  # 36 bytes

Выход:

36

Таким образом, для хранения целого числа 264 Python использует 36 байт.

Целочисленные операции в Python

Целые числа Python поддерживают все стандартные операции, включая:

• Сложение +
• Вычитание –
• Умножение *
• Деление /
• Экспоненты **

Результатом сложения, вычитания, умножения и возведения в степень целых чисел является целое число. Например:

a = 10
b = 20

c = a + b
print(c)
print(type(c))


c = a - b
print(c)
print(type(c))


c = a * b
print(c)
print(type(c))

c = a ** b
print(c)
print(type(c))

Выход:

30
<class 'int'>
-10
<class 'int'>
200
<class 'int'>
100000000000000000000
<class 'int'>

Однако деление двух целых чисел всегда возвращает число с плавающей запятой. Например:

a = 10
b = 5
c = a / b

print(c)
print(type(c))

Выход:

2.0
<class 'float'>