Максимальное значение Integer в Python

Короткий ответ: максимального значения у целых чисел в Python нет. Тип int имеет произвольную точность и растет, пока хватает памяти, поэтому 2 ** 200 или факториал тысячи это обычные числа, а не переполнение. Константа sys.maxsize, которую часто принимают за предел, ограничивает не значения, а размеры: это максимум для длины списка, длины строки и индексов в них, на 64-битных системах он равен 9223372036854775807.

Кратко

• У типа int в Python нет максимального значения: число растет, пока хватает памяти, и тихого переполнения, как у целых типов Java, не бывает.
• sys.maxsize это максимальное значение типа Py_ssize_t: 9223372036854775807, то есть 2 ** 63 - 1 на 64-битных системах и 2 ** 31 - 1 на 32-битных.
• Ограничивает он длину списка, длину строки и индексы в них, а не значения чисел: sys.maxsize + 1 спокойно вычисляется и остается обычным int.
• В Python 2 была константа sys.maxint, в Python 3 ее убрали именно потому, что предела у целых чисел больше нет.
• Если нужно «заведомо большое» начальное значение для поиска минимума, берут math.inf, а не sys.maxsize.
• Единственные реальные ограничения у больших чисел это память и лимит на перевод числа в строку: с Python 3.11 он равен 4300 цифрам и снимается вызовом sys.set_int_max_str_digits().

Введение в максимальное целое число в Python

В Python, в отличие от Java, целые числа не ограничены фиксированной шириной бита. Это означает, что Python может работать с произвольно большими целыми числами, если для их поддержки достаточно памяти. Прямого аналога Integer.MAX_VALUE из примитивных типов Java в Python нет: похожая по звучанию константа sys.maxsize ограничивает не значения чисел, а размеры структур данных.

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

Целые числа в Python имеют произвольную точность, что позволяет использовать широкий диапазон значений: отдельного «длинного» типа, как в Python 2, больше нет, есть только int. Атрибут sys.maxsize указывает максимальное значение переменной типа Py_ssize_t, которое она может принимать. Это предел не для значений, а для размеров: длины списка, длины строки и индексов в них. Документация описывает sys.maxsize как целое число, которое больше любого практического индекса списка или строки. Само значение легко превысить: sys.maxsize + 1 вычисляется без ошибок и остается обычным int.

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

Зачем использовать sys.maxsize в Python?

Использование sys.maxsize может быть полезно, когда вам нужно установить большое число в качестве порогового или начального значения, и вы хотите избежать жесткого кодирования конкретного большого числа. Правда, для «заведомо большого» порога в современном Python чаще берут math.inf: оно больше любого целого числа, и намерение читается сразу. sys.maxsize остается уместным там, где значение обязано остаться именно целым, например как заглушка для индекса или размера.

Пример использования в Python

import sys

def demonstrate_maxsize():
    max_number = sys.maxsize
    print("Max number:", max_number)
    
    number1 = max_number - 1
    print("Number1:", number1)
    
    if number1 < max_number:
        print("Number1 is less than max_number")

if __name__ == "__main__":
    demonstrate_maxsize()

Вывод программы

Max number: 9223372036854775807
Number1: 9223372036854775806
Number1 is less than max_number

Подробное объяснение

Max number: sys.maxsize дает максимальное значение типа Py_ssize_t: на 64-битной системе это 9223372036854775807, то есть 2 ** 63 - 1. Number1: Присвоение значения на единицу меньше, чем sys.maxsize. Сравнение: Проверяется, меньше ли Number1, чем max_number.

Проверим: предела действительно нет

Раз sys.maxsize ограничивает не значения, это несложно показать в коде. Прибавим к нему единицу и заодно посмотрим на число из двухсот двоичных разрядов.

import sys

print('sys.maxsize =', sys.maxsize)

# Число больше sys.maxsize это обычное целое, а не переполнение
big = sys.maxsize + 1
print('sys.maxsize + 1 =', big, '| тип:', type(big).__name__)

# Длина числа ограничена только памятью
huge = 2 ** 200
print('2 ** 200 =', huge)
print('двоичных разрядов:', huge.bit_length(), '| байт в памяти:', sys.getsizeof(huge))

Вывод программы

sys.maxsize = 9223372036854775807
sys.maxsize + 1 = 9223372036854775808 | тип: int
2 ** 200 = 1606938044258990275541962092341162602522202993782792835301376
двоичных разрядов: 201 | байт в памяти: 52

Ни ошибки, ни ухода в минус: sys.maxsize + 1 остается обычным int. Видна и цена произвольной точности: 2 ** 200 занимает 52 байта против 28 у нуля, и чем длиннее число, тем медленнее с ним арифметика. Но это память и скорость, а не предел значения.

Единственный жесткий лимит: 4300 цифр

С Python 3.11 у больших чисел появилось ограничение, о котором обычно узнают неожиданно: перевод из числа в строку и обратно ограничен 4300 цифрами. Само число при этом считается нормально, а вот напечатать его не получится.

import math
import sys

number = math.factorial(2000)
print('двоичных разрядов:', number.bit_length())

try:
    print('цифр в числе:', len(str(number)))
except ValueError as error:
    print('ошибка:', error)

sys.set_int_max_str_digits(0)
print('цифр в числе:', len(str(number)))

Вывод программы

двоичных разрядов: 19053
ошибка: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit
цифр в числе: 5736

Ограничение придумали как защиту: перевод в десятичную запись нельзя выполнить за линейное время, и на гигантском числе он занимает секунды, чем можно подвесить сервис (документация ссылается на CVE 2020-10735). Поэтому лимит касается только десятичной системы, а hex(), oct() и bin() работают без ограничений. Снять или изменить его можно вызовом sys.set_int_max_str_digits(), ключом запуска -X int_max_str_digits=0 или переменной окружения PYTHONINTMAXSTRDIGITS. Текущее значение показывает sys.get_int_max_str_digits(), а минимально допустимое, кроме нуля, равно 640.

Вывод

Понимание и использование sys.maxsize в Python полезно для различных приложений, где вам нужно очень большое целочисленное значение. Практикуясь на приведенных примерах, вы сможете улучшить свои навыки кодирования и применить полученные знания для решения реальных задач. Продолжайте экспериментировать и учиться! Не стесняйтесь обращаться к этому руководству, когда вам понадобится дополнительная информация. Счастливого кодинга!

Вопросы и ответы

Какое максимальное значение int в Python?

Его нет. В Python 3 целые числа имеют произвольную точность: число занимает столько памяти, сколько нужно, и растет, пока памяти хватает. Поэтому 2 ** 200 или факториал тысячи вычисляются без всяких хитростей. За максимум часто ошибочно принимают sys.maxsize, но это предел длины контейнеров, а не значений.

Что такое sys.maxsize и чему он равен?

Это максимальное значение переменной типа Py_ssize_t, которым в CPython измеряются размеры и индексы. На 64-битных системах он равен 9223372036854775807 (2 ** 63 - 1), на 32-битных 2147483647 (2 ** 31 - 1). Практический смысл такой: список или строка длиннее sys.maxsize невозможны, а вот число больше sys.maxsize абсолютно нормально.

Почему в Python 3 нет sys.maxint?

Константу убрали в Python 3.0 вместе с делением на int и long. В списке изменений Python 3.0 это сказано прямо: sys.maxint удалили, поскольку у значения целых чисел больше нет предела, а sys.maxsize можно использовать как число, которое больше любого практического индекса списка или строки. Обращение к sys.maxint в Python 3 даст AttributeError.

Как задать заведомо большое начальное значение для поиска минимума?

Для этого есть math.inf (то же самое, что float('inf')): оно больше любого целого числа, поэтому первое же сравнение сработает. Учтите, что это значение типа float, и превратить его обратно в целое нельзя: int(math.inf) выбросит OverflowError. Если результат обязан остаться целым, sys.maxsize подойдет, но только как договоренность, а не как настоящий предел.

Есть ли вообще предел у больших чисел в Python?

Есть два. Первый это память: очень длинное число просто не поместится. Второй появился в Python 3.11, и о нем часто узнают неожиданно: перевод числа в строку и обратно ограничен 4300 цифрами. Например, str(math.factorial(2000)) выбросит ValueError, хотя сам факториал (5736 цифр) уже посчитан. Лимит снимается вызовом sys.set_int_max_str_digits(0), он защищает от зависаний на разборе гигантских чисел.

Чем int в Python отличается от int в Java?

В Java int это 4 байта фиксированной ширины, и при выходе за границу значение молча уходит в минус. В Python int хранит столько разрядов, сколько нужно, и ближе не к int, а к BigInteger. Расплата это память и скорость: под ноль в Python уходит 28 байт, под 2 ** 1000 уже 160 байт, а операции с длинными числами идут медленнее машинной арифметики.

Читайте также:

• Типы данных в Python
• Арифметические операции в Python
• Целочисленное деление в Python
• Приведение типов в Python