Тип int в Python: арифметика, преобразования и продвинутые примеры

Раздел: Python -> Основные сведения

Основные сведения о целых числах

Как объявить целое число и выполнить базовые арифметические операции?

Тип int

Целые числа в Python представляются типом int. Они обладают неограниченной точностью. Пример объявления:

a = 42
b = -17
c = 0

целое python (целые числа в python)

Основные арифметические операции:

a = 10
b = 3
print(a + b)   # 13
print(a - b)   # 7
print(a * b)   # 30
print(a / b)   # 3.333... (float)
print(a // b)  # 3 (целочисленное деление)
print(a % b)   # 1 (остаток)
print(a ** b)  # 1000 (возведение в степень)

Операции можно комбинировать с учётом приоритета. Для изменения порядка используются круглые скобки.

Типичные ошибки

Деление на ноль: a // 0 или a % 0 вызывает ZeroDivisionError. Необходимо проверять делитель перед операцией.
Преобразование float к int: int(3.9) даёт 3 (отбрасывание дробной части). Если нужна другая стратегия округления, можно обратиться к round(), math.floor(), math.ceil().
Потеря производительности при работе с очень большими числами (миллионы бит) - операции могут замедляться, но это редко встречается в типичных задачах.

Как преобразовать строку в целое число и обработать ошибку?

Функция int() принимает строку, содержащую десятичное целое число (возможно со знаком и пробелами), и возвращает соответствующее целое. Если строка не является корректным представлением, выбрасывается ValueError.

s = '   -123  '
num = int(s)   # -123
print(num)
# Ошибка при некорректной строке:
# num = int('abc')   # ValueError

Для безопасного преобразования можно применить try-except или предварительную проверку (например, isdigit() с учётом знака).

Распространённая ошибка

Попытка преобразовать строку с пробелами внутри (кроме ведущих/замыкающих) или с символом валюты. Решение: строку можно очистить от лишних символов перед вызовом int().

Как работать с числами произвольной точности?

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

big = 2 ** 1000
print(big)
# Вывод: 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376

Сложности могут возникнуть при выводе на экран или при сравнении с числами типа float (из-за потери точности последних). Для точных дробных вычислений подходит модуль decimal.

Потенциальная проблема

При работе с чрезвычайно большими числами (например, факториал 100000) операции могут потребовать много времени и памяти. Это не ошибка, а ограничение ресурсов.

Как получить двоичное, восьмеричное или шестнадцатеричное представление числа?

Функции bin(), oct(), hex() возвращают строки с префиксами ('0b', '0o', '0x'). Для получения без префикса применяют format(x, 'b'). Обратное преобразование: int('1010', 2).

x = 42
print(bin(x))  # 0b101010
print(oct(x))  # 0o52
print(hex(x))  # 0x2a
print(format(x, 'b'))  # 101010
print(int('101010', 2)) # 42

Типичная ошибка

Передача строки с неправильными символами (например, '0b' внутри) в int с основанием. int('0b1010', 2) вызовет ValueError. Решение: строку можно передавать без префикса или задавать второй аргумент 0 для автодетекта: int('0b1010', 0).

Как узнать, сколько бит требуется для хранения числа?

Метод bit_length() возвращает количество бит, необходимых для представления числа в двоичной системе (без знака). Для отрицательных чисел возвращается количество бит для модуля.

x = 0
print(x.bit_length())  # 0
x = 255
print(x.bit_length())  # 8
x = -255
print(x.bit_length())  # 8 (модуль 255)

Это полезно для распределения памяти под сериализацию.

Неправильное понимание

Для отрицательных чисел битовая длина не учитывает знак. Если нужно учесть знак, можно добавить 1 бит или применить структуру с фиксированным размером.

Как выполнить целочисленное деление и взять остаток для отрицательных чисел?

В Python результат // округляется вниз (floor), а % возвращает неотрицательный остаток (если делитель положителен). Это отличается от некоторых других языков.

print(-7 // 3)  # -3 (потому что -3*3 = -9, -2*3 = -6, floor -7/3 = -2.333 -> -3)
print(-7 % 3)   # 2 (остаток: -7 - (-3)*3 = -7 + 9 = 2)
# Использование divmod:
print(divmod(-7, 3))  # (-3, 2)

Если требуется деление с округлением к нулю, можно применить int(x / y) для чисел с плавающей точкой (но с риском потери точности). Для целых существует функция math.trunc().

Путаница с другими языками

Программисты, привыкшие к C/Java, ожидают, что -7 % 3 = -1. В Python это 2. Нужно учитывать при переносе алгоритмов.

Как безопасно обработать деление на ноль?

Перед операцией деления или взятия остатка следует проверить, что делитель не равен нулю. Если есть вероятность нулевого делителя, можно применить условную конструкцию или try-except.

a = 10
b = 0
if b != 0:
    result = a // b
else:
    result = None  # или другое значение по умолчанию
# Альтернатива с try:
try:
    result = a // b
except ZeroDivisionError:
    result = None

Выбор метода зависит от контекста: условный оператор проще и быстрее, try-except удобен, если деление происходит в цепочке вычислений.

Типичная ошибка

Забыть проверку. Иногда деление на ноль случается неявно (например, при делении суммы на количество, которое может быть нулём). Рекомендуется всегда проверять.

Расширенные примеры работы с целыми числами

Битовые операции

Целые числа поддерживают побитовые операторы: & (AND), | (OR), ^ (XOR), ~ (NOT), << (сдвиг влево), >> (сдвиг вправо). Они полезны для флагов и низкоуровневой работы.

Пример

a = 0b1100  # 12
b = 0b1010  # 10
print(a & b)  # 0b1000 = 8
print(a | b)  # 0b1110 = 14
print(a ^ b)  # 0b0110 = 6
print(~a)     # -13 (в дополнительном коде)
print(a << 2) # 48 (110000)
print(a >> 2) # 3 (11)

Преобразование между системами счисления

Функция int() с основанием позволяет прочитать число из любой системы (2-36). Обратно – format() или f-строки.

Пример

# Шестнадцатеричное в десятичное
hex_str = 'FF'
dec = int(hex_str, 16)
print(dec)  # 255
# Десятичное в шестнадцатеричное с префиксом
print(hex(255))  # 0xff
# Без префикса
print(format(255, 'X'))  # FF (верхний регистр)
# Двоичное с ведущими нулями
print(format(5, '08b'))  # 00000101

255
0xff
FF
00000101

Работа с байтами: представление IP-адреса

Метод to_bytes() конвертирует целое в последовательность байтов. from_bytes() восстанавливает.

Пример

ip_int = 3232235521  # 192.168.0.1 в десятичном виде
ip_bytes = ip_int.to_bytes(4, 'big')
print(ip_bytes)
ip_int2 = int.from_bytes(ip_bytes, 'big')
print(ip_int2)
ip_str = '.'.join(str(b) for b in ip_bytes)
print(ip_str)

b'\\xc0\\xa8\\x00\\x01'
3232235521
192.168.0.1

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

Классический битовый трюк: число является степенью двойки, если оно больше 0 и его битовое И с (n-1) равно 0.

Пример

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

print(is_power_of_two(1))   # True
print(is_power_of_two(16))  # True
print(is_power_of_two(18))  # False
print(is_power_of_two(0))   # False

True
True
False
False

Использование int для генерации последовательностей через range

Функция range() принимает только целые числа. Она создаёт неизменяемую последовательность, которая не хранит все элементы в памяти.

Пример

for i in range(5, 10, 2):
    print(i, end=' ')
print()
# list(range(5)) = [0, 1, 2, 3, 4]

5 7 9

Вычисление факториала больших чисел с использованием math.factorial

Модуль math содержит функцию factorial, возвращающую целое произвольной точности. Вычисление факториала 100 даёт огромное число.

Пример

import math
fact = math.factorial(100)
print(fact)
# Количество цифр: len(str(fact))

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Факториал 100 содержит 158 цифр. Это пример произвольной точности Python int.

Использование int как ключа в словаре

Целые числа неизменяемы и хешируемы, поэтому могут служить ключами. Часто используются для индексации, например, при подсчёте частоты.

Пример

counter = {}
data = [1, 2, 3, 1, 2, 1]
for num in data:
    counter[num] = counter.get(num, 0) + 1
print(counter)  # {1: 3, 2: 2, 3: 1}

{1: 3, 2: 2, 3: 1}

Целые числа в Python - comments

целое python (python)