Максимальное значение для длинного целого

Как я могу присвоить максимальное значение для длинного целого числа переменной, аналогично, например, C++ LONG_MAX,

Источник

9 ответов

Решение

Длинные целые числа:

Там нет явно определенного предела. Количество доступного адресного пространства образует практический предел.
(Взято с сайта). Смотрите документы по числовым типам, где вы увидите, что Long integers have unlimited precision, В Python 2 целые числа автоматически переключаются на длинные, когда они выходят за пределы своего предела:

>>> import sys
>>> type(sys.maxsize)
<type 'int'>
>>> type(sys.maxsize+1)
<type 'long'>


для целых чисел мы имеем

maxint и maxsize:

Максимальное значение типа int можно найти в Python 2.x с sys.maxint, Он был удален в Python 3, но sys.maxsize часто может использоваться вместо Из журнала изменений:

Константа sys.maxint была удалена, так как больше нет ограничения на значение целых чисел. Однако sys.maxsize может использоваться как целое число, большее, чем любой практический список или строковый индекс. Он соответствует "естественному" целочисленному размеру реализации и, как правило, такой же, как sys.maxint в предыдущих выпусках на той же платформе (при условии, что используются те же параметры сборки).

и для тех, кто заинтересован в разнице (Python 2.x):

sys.maxint Наибольшее положительное целое число, поддерживаемое обычным целочисленным типом Python. Это как минимум 2**31-1. Наибольшее отрицательное целое число равно -maxint-1 - асимметрия является результатом использования двоичной арифметики дополнения 2.

sys.maxsize Самое большое положительное целое число, поддерживаемое типом платформы Py_ssize_t, и, таким образом, может иметь списки максимального размера, строки, dicts и многие другие контейнеры.

и для полноты вот версия Python 3:

sys.maxsize Целое число, дающее максимальное значение, которое может принимать переменная типа Py_ssize_t. Обычно это 32^ 1-1 на 32-битной платформе и 2^63 - 1 на 64-битной платформе.

поплавки:

Там в float("inf") а также float("-inf"), Их можно сравнить с другими числовыми типами:

>>> import sys
>>> float("inf") > sys.maxsize
True
Источник

Питон long может быть сколь угодно большим. Если вам нужно значение, которое больше, чем любое другое значение, вы можете использовать float('inf'), так как Python без проблем сравнивает числовые значения разных типов. Аналогично, для значения, меньшего, чем любое другое значение, вы можете использовать float('-inf'),

Источник

Прямой ответ на заглавный вопрос:

Целые числа не ограничены в размере и не имеют максимального значения в Python.

Ответьте, на какие адреса указан основной вариант использования:

Согласно вашему комментарию о том, что вы пытаетесь сделать, вы в настоящее время думаете что-то вроде

minval = MAXINT;
for (i = 1; i < num_elems; i++)
    if a[i] < a[i-1]
        minval = a[i];

Это не то, как думать в Python. Лучший перевод на Python (но все же не самый лучший) будет

minval = a[0]  # Just use the first value
for i in range(1, len(a)):
    minval = min(a[i], a[i - 1])

Обратите внимание, что выше не использует MAXINT вообще. Эта часть решения применима к любому языку программирования: вам не нужно знать максимально возможное значение, чтобы найти наименьшее значение в коллекции.

Но в любом случае, то, что вы действительно делаете в Python, это просто

minval = min(a)

То есть вы вообще не пишете цикл. Встроенный min() Функция получает минимум всей коллекции.

Источник

long Тип в Python 2.x использует арифметику произвольной точности и не имеет такого понятия, как максимально возможное значение. Он ограничен доступной памятью. Python 3.x не имеет специального типа для значений, которые не могут быть представлены целым числом собственной машины - все int и преобразование обрабатывается за кулисами.

Источник

В отличие от C/C++ Long в Python имеют неограниченную точность. Обратитесь к разделу Числовые типы в Python для получения дополнительной информации. Чтобы определить максимальное значение целого числа, вы можете просто сослаться sys.maxint, Вы можете получить более подробную информацию из документации sys.

Источник

Вы можете использовать: максимальное значение с плавающей точкой

float('inf')

для негатива

float('-inf')
Источник

В CPython 3.11 в 64-битной системе максимальное целое число равно

      2 ** 276701161105643274210 - 1

Для его хранения вам потребуется 35 эксабайт памяти, что будет стоить около 70 миллиардов долларов по сегодняшним (май 2023 года) ценам в 65 долларов за 32 ГБ на NewEgg. На практике максимальное целое число Python ограничено объемом памяти вашего компьютера.

CPython 3.11 хранит целые числа в этой структуре C :

      struct PyLongObject {
    Py_ssize_t ob_refcnt;
    PyTypeObject* ob_type;
    Py_ssize_t ob_size;
    uint32_t ob_digit[1];
};

Таким образом, целые числа Python реализуются как массив 32-битных целых чисел (uint32_t ob_digit[1]), из которых только 30 бит используются для хранения абсолютного значения целого числа, а 64-битное целое число со знаком, дополненное до двух, хранит длину этого массива (Py_ssize_t ob_size), а также знак целого числа Python, поэтому отрицательное целое число имеет отрицательный «размер». Итак, у нас есть

      2 ** ((2 ** 63 - 1) * 30) - 1
Источник

В python3 вы можете отправить значение с плавающей точкой в ​​функцию int, получив число 1.7976931348623157e+308 в целочисленном представлении.

import sys    
int(sys.float_info.max)
Источник

А) Для дешевого сравнения / арифметики используйте пустышку math.inf. Или же math.nan, который сравнивает FALSE в любом направлении (в том числе nan == nan) кроме проверки личности (is) и отображает любую арифметику (например, nan - nan) nan. Или достаточно высокое действительное целое число в соответствии с вашим вариантом использования (например, sys.maxsize). Для фиктивной битовой маски (например, в mybits & bitmask) использовать -1.

Б) Чтобы получить примитив платформы с максимальным подписанным длинным int (или длинным длинным):

>>> 256 ** sys.int_info.sizeof_digit // 2 - 1  # Python’s internal primitive
2147483647
>>> 256 ** ctypes.sizeof(ctypes.c_long) // 2 - 1  # CPython
2147483647
>>> 256 ** ctypes.sizeof(ctypes.c_longlong) // 2 - 1  # CPython
9223372036854775807
>>> 2**63 - 1  # Java / JPython primitive long
9223372036854775807

C) Максимальное целое число Python можно оценить с помощью длительного цикла, дразнящего переполнение памяти (попробуйте 256**int(8e9) - можно остановить KeyboardInterrupt). Но его нельзя не использовать разумно, потому что его представление уже потребляет всю память и ее намного больше, чем sys.float_info.max.

Источник
Другие вопросы по тегам