Целые числа int в Python

Обычные целые числа в Python имеют тип int и записываются как строки, состоящие из десятичных цифр. Целые числа типа int (положительные и отрицательные) имеют неограниченную точность, могут принимать сколь угодно большие значения. Тип int являются неизменяемым объектом, выполняя операцию над целыми числами, вы получаете новый числовой объект.

Целые числа поддерживают следующие операции:

• арифметические операции;
• побитовые операции;
• операции сравнения.

Тип int в языке Python представлен классом int(), он позволяет:

• преобразовать строку в целое число типа int с учетом указанного основания системы счисления (десятичные по основанию 10, шестнадцатеричные по основанию 16, восьмеричные по основанию 8 и двоичные по основанию 2).
• преобразовать вещественные числа типа float в тип int (отбрасывает дробную часть).
• преобразовать восьмеричные, шестнадцатеричные и двоичные литералы целых чисел в тип int

Класс int() не сможет преобразовать к типу int:

• числа типа complex, т.к. нет однозначного способа преобразования данного типа чисел.
• строку с записью числа с плавающей точкой (вещественного числа)

Примеры преобразования объектов к типу int:

# Преобразование строки с записью 
# целого числа в десятичной форме к типу int
>>> int(' -3 ', base=10)
# 3

# При преобразовании десятичных литералов, 
# записанных в строки, основание можно опускать
>>> int(' +5 ')
# 5
>>> int(' -15_125')
# -15125


# Преобразование типа float в тип `int`
>>> int(3.23)
# 3
>>> int(1.)
# 1
>>> int(3.14e-10)
# 0

# Восьмеричные литералы и строки с ними - в тип int
>>> int(0o177)
# 127
>>> int('  0o177 ', base=8)
# 127


# Шестнадцатеричные литералы и строки с ними - в тип int
>>> int(0x9ff)
# 2559
>>> int(' 0x9ff  ', base=16)
# 2559

# Двоичные литералы и строки с ними - в тип int
>>> int(0b101010)
# 42
>>> int('0b101010', base=2)
# 42

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

>>> 100_000, 0x_FF_FF, 0o7_777
 # (100000, 65535, 4095)

Целые числа еще могут записываться как, шестнадцатеричные (по основанию 16), восьмеричные (по основанию 8) и двоичные (по основанию 2).

• Шестнадцатеричные литералы начинаются с комбинации символов 0x или 0X, вслед за которыми следуют шестнадцатеричные цифры (0-9 и A-F). Шестнадцатеричные цифры могут вводиться как в нижнем, так и в верхнем регистре.
• Литералы восьмеричных чисел начинаются с комбинации символов 0o или 0O (ноль и следующий за ним символ «o» в верхнем или нижнем регистре), вслед за которыми следуют восьмеричные цифры (0-7).
• Двоичные литералы начинаются с комбинации символов 0b или 0B, вслед за которыми следуют двоичные цифры (0 – 1)

Все эти литералы создают объекты целых чисел, они являются всего лишь альтернативными формами записи значений. Для преобразования целого числа в строку с представлением в любой из трех систем счисления можно использовать встроенные функции hex(), oct() и bin()

Методы типа int:

int.bit_length():

Возвращает количество битов, необходимых для представления целого числа в двоичном виде, исключая знак и начальные нули:

>>> n = -37
>>> bin(n)
# '-0b100101'
>>> n.bit_length()
# 6

Эквивалентно:

def bit_length(self):
    # двоичное представление: bin(-37) => '- 0b100101' 
    s = bin(self)
    # удалить начальные нули и знак минус
    s = s.lstrip('-0b')
    # len('100101') => 6
    return len(s)

int.bit_count():

Добавлен в Python 3.10. Возвращает количество единиц в двоичном представлении абсолютного значения целого числа.

Пример:

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
# 3
>>> (-n).bit_count()
# 3

Эквивалентен:

def bit_count(self):
    return bin(self).count("1")

Новое в Python 3.10.

int.to_bytes(length, byteorder, *, signed=False):

Возвращает массив байтов, представляющих целое число. Параметры length, byteorder являются обязательными:
- length задает необходимое количество байтов,
- byteorder определяет в каком порядке возвращать байты и имеют значения 'big' - от старшего к младшему, 'little' - от младшего к старшему.
- signed позволяет установить использование дополнительного кода для представления целого числа. Если signed=False и задано отрицательное целое число, то бросается OverflowError.

>>> (1024).to_bytes(2, byteorder='big')
# b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
# b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
# b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
# b'\xe8\x03'

Если указанных байтов недостаточно для представления числа, то будет вызвано исключение OverflowError. Что бы узнать порядок байтов который использует платформа используйте sys.byteorder.

int.from_bytes(bytes, byteorder, *, signed=False):

Возвращает целое число, которое соответствует указанному массиву байтов.
Параметры bytes и byteorder являются обязательными.
- bytes должен быть байто-подобным объектом (строки байтов, массивы байтов, array.array и т.д.)
- byteorder определяет в каком порядке возвращать байты и имеют значения 'big' - от старшего к младшему, 'little' - от младшего к таршему.
- signed позволяет установить использование дополнительного кода для представления целого числа. Если signed=False и задано отрицательное елое число, то бросается OverflowError.

>>> int.from_bytes(b'\x00\x7f', byteorder = 'big')
# 127
>>> int.from_bytes(b'\x00\x7f', byteorder = 'little')
# 32512
>>> int.from_bytes(b'\xff\x81', 'big', signed = True)
# -127
>>> int.from_bytes([1, 0], 'big')    #  можно указать "массив" байтов
# 256
>>> int.from_bytes([255, 255], 'big')
# 65535