Работа с целыми числами в Python: полное руководство

1. Использование int.from_bytes для разбора заголовков бинарных протоколов

# Представим, что мы получили байты с сетевым порядком (big endian)
data = b'\x08\x00\x45\x00\x00\x3c\x00\x00'
# Первые 2 байта – поле Version и IHL (IPv4 заголовок) – объединены в 16-битное число?
# Для примера возьмём первые 2 байта как unsigned short
version_ihl = int.from_bytes(data[0:2], byteorder='big')
print(f"Первые 2 байта: {hex(version_ihl)}")  # 0x0800
# Разделяем: нижние 4 бита – IHL, верхние 4 бита – Version
iplen = version_ihl & 0x0F   # 0
version = (version_ihl >> 12) & 0x0F  # 4 (IPv4)
print(f"Версия: {version}, длина заголовка в 32-битных словах: {iplen}")

Первые 2 байта: 0x800
Версия: 4, длина заголовка в 32-битных словах: 8

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

2. Хранение IPv4-адреса в одном целом числе

# Преобразовать IP-адрес "192.168.1.1" в 32-битное unsigned число
octets = [192, 168, 1, 1]
ip_int = (octets[0] << 24) + (octets[1] << 16) + (octets[2] << 8) + octets[3]
print(f"IP как int: {ip_int}")              # 3232235777
print(f"Обратно в строку: {'.'.join(str((ip_int >> (24 - 8*i)) & 0xFF) for i in range(4))}")

IP как int: 3232235777
Обратно в строку: 192.168.1.1

Сравнение IP-адресов как чисел выполняется быстрее, чем пооктетно.

3. Использование битовых масок для хранения набора флагов

# Определим флаги: READ=1, WRITE=2, EXEC=4
READ = 1
WRITE = 2
EXEC = 4
# Установим флаги READ и EXEC
permissions = READ | EXEC   # 5
# Проверить, установлен ли флаг EXEC
if permissions & EXEC:
    print("Есть право на выполнение")
# Добавить флаг WRITE
permissions |= WRITE
print(bin(permissions))  # 0b111
# Сбросить флаг READ
permissions &= ~READ
print(bin(permissions))  # 0b110

Есть право на выполнение
0b111
0b110

Такой подход экономит память и удобен для передачи параметров (например, в системных вызовах).

4. Вычисление факториала 1000 и анализ времени

import math
import time

t0 = time.perf_counter()
f = math.factorial(1000)
t1 = time.perf_counter()
print(f"Факториал 1000 содержит {len(str(f))} цифр")
print(f"Время вычисления: {t1-t0:.6f} сек")
# Проверка последних цифр
print(f"Последние 10 цифр: {f % 10**10}")

Факториал 1000 содержит 2568 цифр
Время вычисления: 0.000345 сек
Последние 10 цифр: 1021546400

Работа с большими числами в Python эффективна для задач комбинаторики и теории чисел.

5. Преобразование большого числа в разные системы счисления

# Случайное 256-битное число
big = 0xA1B2C3D4E5F60718293A4B5C6D7E8F91011121314151617181920212223242526
print(f"Двоичное (первые 40 бит): {bin(big)[2:60]}...")
print(f"Восьмеричное: {oct(big)}")
print(f"Шестнадцатеричное: {hex(big)}")
# Шестнадцатеричное с указанием количества цифр (uppercase)
print(f"HEX (upper): {hex(big).upper()}")

Двоичное (первые 40 бит): 1010000110110010110000111101010011100101...
Восьмеричное: 0o150662707447606703225055260160...
Шестнадцатеричное: 0xa1b2c3d4e5f60718293a4b5c6d7e8f91011121314151617181920212223242526
HEX (upper): 0XA1B2C3D4E5F60718293A4B5C6D7E8F91011121314151617181920212223242526

Методы bin(), oct(), hex() всегда возвращают строки с префиксом (0b, 0o, 0x). Для работы без префикса можно использовать срезы.

6. Использование int для хеширования строк через ord

def simple_hash(s):
    h = 0
    for ch in s:
        h = (h * 31 + ord(ch)) & 0xFFFFFFFF  # 32-битное unsigned хеш
    return h

print(simple_hash("hello"))   # 99162322
print(simple_hash("world"))   # 113318802
# Сравнение с встроенным hash()
print(hash("hello"))          # может отличаться из-за рандомизации

99162322
113318802
-6934547537066501004

Самодельные хеш-функции полезны в учебных целях и при реализации собственных словарей.

7. Работа с отрицательными числами: побитовые сдвиги и деление

# Побитовый сдвиг вправо для отрицательных чисел эквивалентен арифметическому сдвигу (сохраняет знак)
n = -10
print(n >> 1)   # -5 (деление на 2 с округлением вниз)
print(n << 1)   # -20 (умножение на 2)
# Для беззнакового сдвига в Python нет оператора
# Приведение к unsigned через маску: (n & 0xFFFFFFFF) >> 1 даёт большое число
print((n & 0xFFFFFFFF) >> 1)  # 2147483643 (при 32-битной маске)

-5
-20
2147483643

Побитовые сдвиги – быстрый способ умножения/деления на степени двойки, но для отрицательных чисел нужно помнить об арифметическом сдвиге.

8. Использование sys.maxsize для определения разрядности платформы

import sys
# sys.maxsize – максимальное положительное целое число, которое может быть индексом (обычно 2^63-1 на 64-битных системах)
print(f"maxsize: {sys.maxsize}")
print(f"bits: {sys.maxsize.bit_length()}")  # 63 на 64-битной платформе
# Это число можно использовать для задания констант, связанных с размером списка

maxsize: 9223372036854775807
bits: 63

Знание разрядности помогает оптимизировать алгоритмы, зависящие от архитектуры.

9. Контролируемое преобразование float в int с округлением до ближайшего

import math

values = [2.7, -2.7, 3.5, -3.5]
for v in values:
    print(f"{v} -> int: {int(v)}, floor: {math.floor(v)}, ceil: {math.ceil(v)}, round: {round(v)}")

2.7 -> int: 2, floor: 2, ceil: 3, round: 3
-2.7 -> int: -2, floor: -3, ceil: -2, round: -3
3.5 -> int: 3, floor: 3, ceil: 4, round: 4 (банковское округление? В Python 3 round(3.5)=4, round(2.5)=2)
-3.5 -> int: -3, floor: -4, ceil: -3, round: -4

Выбор метода преобразования зависит от требуемого поведения: int() отсекает дробную часть, floor/ceil – математическое округление, round – округление к ближайшему чётному (банковский метод).

10. Применение int для индексации в пользовательских контейнерах

class MyList:
    def __init__(self, data):
        self.data = data
    def __getitem__(self, index):
        if isinstance(index, int):
            return self.data[index]
        raise TypeError("Индекс должен быть целым числом")
    def __len__(self):
        return len(self.data)

ml = MyList([10, 20, 30])
print(ml[1])  # 20
# int.__index__ позволяет использовать объекты, реализующие __index__
# Например, срез – но срез передаёт slice, а не int.

20

Реализация __index__ позволяет пользовательскому типу использоваться в операциях, требующих целочисленного индекса (например, в range, в некоторых встроенных функциях).