Тип int в Python: от обычных чисел до неограниченной точности

Пример 1: Факториал большого числа

Вычисление факториала для чисел в несколько тысяч демонстрирует произвольную точность int.

import math
import sys

n = 1000
fact = math.factorial(n)
print(f"Факториал {n} содержит {len(str(fact))} цифр")
print(f"Размер объекта в памяти: {sys.getsizeof(fact)} байт")

Факториал 1000 содержит 2568 цифр
Размер объекта в памяти: 1120 байт

Число занимает более 1000 байт, но все операции, как с обычным int, по-прежнему корректны.

Пример 2: Битовые маски для флагов

Целые числа удобно использовать для хранения набора бинарных флагов. Каждый бит отвечает за один флаг.

# Определение флагов
READ = 1    # 0b001
WRITE = 2   # 0b010
EXECUTE = 4 # 0b100

flags = READ | WRITE  # 0b011 = 3
print(f"Начальные флаги: {flags:03b}")

# Проверка наличия флага
if flags & READ:
    print("Разрешение на чтение есть")

# Добавление флага
flags |= EXECUTE
print(f"После добавления: {flags:03b}")

# Снятие флага
flags &= ~WRITE
print(f"После снятия записи: {flags:03b}")

Начальные флаги: 011
Разрешение на чтение есть
После добавления: 111
После снятия записи: 101

Пример 3: Преобразование в систему счисления с произвольным основанием (2–36)

Стандартная функция int() принимает основание только до 36. Можно расширить, используя собственную реализацию или int() с предварительной конвертацией.

# Преобразование числа в строку с основанием до 36 (встроенное)
num = 255
print(bin(num))           # 0b11111111
print(oct(num))           # 0o377
print(hex(num))           # 0xff

# Собственное преобразование для основания > 36
import string
digits = string.digits + string.ascii_lowercase  # 0-9 a-z

def to_base(n, base):
    if n == 0:
        return '0'
    result = []
    while n > 0:
        result.append(digits[n % base])
        n //= base
    return ''.join(reversed(result))

print(to_base(255, 16))   # ff
print(to_base(255, 36))   # 73

0b11111111
0o377
0xff
ff
73

Пример 4: Разбор сетевого пакета с помощью int.from_bytes

При работе с бинарными протоколами часто требуется прочитать целое число из последовательности байтов с определённым порядком байтов.

import struct

# Имитация полученных данных (4 байта)
data = b'\x00\x01\x02\x03'

# Разные способы интерпретации
val_big = int.from_bytes(data, byteorder='big')
val_little = int.from_bytes(data, byteorder='little')
print(f"Big-endian: {val_big}")
print(f"Little-endian: {val_little}")

# С помощью struct (аналогично)
val_struct = struct.unpack('>I', data)[0]
print(f"Struct big-endian: {val_struct}")

Big-endian: 66051
Little-endian: 50462976
Struct big-endian: 66051

Пример 5: Проверка, является ли число степенью двойки

Битовые операции позволяют эффективно проверить, является ли натуральное число степенью двойки.

def is_power_of_two(n):
    # n > 0 и (n & (n-1)) == 0
    return n > 0 and (n & (n - 1)) == 0

test_numbers = [1, 2, 3, 4, 16, 255, 256, 1024]
for num in test_numbers:
    print(f"{num:5} -> {is_power_of_two(num)}")

    1 -> True
    2 -> True
    3 -> False
    4 -> True
   16 -> True
  255 -> False
  256 -> True
 1024 -> True

Алгоритм основан на том, что степень двойки имеет ровно один установленный бит. Выражение n & (n-1) обнуляет младший единичный бит; если после этого остаётся 0, то бит был единственным.