Целое число Python и переполнение данных Numpy

Python

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

Глядя на картинку, первым впечатлением было то, что данные переполнились. Если данные превышают максимальное значение, которое может быть представлено, появятся странные результаты.

Затем он продолжил отправку изображения, содержание — это print(100000*208378), что означает прямую печать E[0]*G[0] на картинке выше, результат 20837800000, что является правильным результатом.

Итак, новый вопрос: если данные на приведенном выше рисунке переполняются, почему число, умноженное прямым образом, не переполняется?

Поскольку я игнорировал правила представления данных (каков верхний предел целочисленного типа?) и мало что знаю о Numpy, я также неправильно истолковал результаты на рисунке, думая, что все данные неверны, поэтому я не могу ответить на него.

Наконец, после некоторого обсуждения в учебной группе, я, наконец, понял, что происходит, поэтому в этой статье разбираются соответствующие точки знаний.

Прежде чем мы начнем, давайте обобщим темы, к которым приведет приведенная выше картинка:

  • Какова верхняя граница для целых чисел в Python 3? А как насчет Питона 2?
  • Какова верхняя граница целых чисел в Numpy? Что делать, если происходит целочисленное переполнение?

Для первого вопроса давайте посмотрим на Python 2, который имеет два типа целых чисел:

  • Один из них — это короткие целые числа, также известные как целые числа, представленные int, и есть встроенная функция int(). Его размер ограничен и может быть пройден черезsys.maxint()Просмотр (в зависимости от того, является ли платформа 32-разрядной или 64-разрядной)
  • Один из них — длинное целое, целое число бесконечного размера, представленное как long и имеющее встроенную функцию long(). Оно пишется с прописной L или строчной l после числа, например 1000L.

Когда целое число выходит за пределы диапазона коротких целых чисел, оно автоматически представляется как длинное целое число. Например, распечатать2**100, в конце результата будет добавлена ​​буква L, чтобы указать, что это длинное целое число.

Но с Python 3 ситуация иная: он имеет только одно встроенное целое число, представленное как int, которое формально является коротким целым числом Python 2, но на самом деле оно может представлять бесконечный диапазон и ведет себя скорее как длинное целое число. Каким бы большим ни было число, буква L в конце не требуется, чтобы его отличить.

Другими словами, Python 3 объединяет два целочисленных представления, и пользователям больше не нужно различать себя и оставлять это на нижнем уровне для обработки по требованию.

Теоретически целые числа в Python 3 не имеют верхнего предела (пока они не превышают объем памяти). Это объясняет прямое печатание умножения двух чисел в предыдущей статье, почему результат будет правильным.

Этот переход описан в PEP-237 (Объединение длинных целых и целых чисел). Это объясняет цель этого:

Это займет на одно домашнее задание меньше для новых программистов Python (независимо от того, являются ли они новичками в программировании или нет).

Python экранирует множество тривиальных задач на уровне приложения языка, таких как выделение памяти, поэтому нам не нужно беспокоиться об использовании таких объектов, как строки, списки или словари. Преобразование целочисленных типов также предназначено для удобства. (Недостаток в том, что приносится в жертву некоторая эффективность, поэтому я не буду говорить об этом здесь)

Вернемся ко второй теме: каков верхний предел целого числа в NUMPY?

Поскольку он реализован на языке C, он использует правила языка C для целочисленного представления, то есть различает целые числа и длинные целые числа.

Есть один способ просмотра:

import numpy as np

a = np.arange(2)
type(a[0])

# 结果：numpy.int32

Другими словами, его целое число int по умолчанию составляет 32 бита, что означает диапазон от -2 147 483 648 до 2 147 483 647.

По сравнению со скриншотом выше, есть только два набора чисел, которые не переполняются при умножении: 100007*4549, 100012*13264, а другие наборы данных переполняются, поэтому получается странный отрицательный результат.

Numpy поддерживает больше типов данных, чем Python, и между ними много разных границ:

Источник скриншота:WOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOAOOUMUM PY / NUM PY ...

Чтобы решить проблему целочисленного переполнения, вы можете указать dtype:

import numpy as np

q = [100000]
w = [500000]

# 一个溢出的例子：
a = np.array(q)
b = np.array(w)
print(a*b)  # 产生溢出，结果是个奇怪的数值

# 一个解决的例子：
c = np.array(q, dtype='int64')
d = np.array(w, dtype='int64')
print(c*d) # 没有溢出：[50000000000]

Что ж, на предыдущие вопросы были даны ответы. Подведем итоги:

  • Python 3 значительно упрощает представление целых чисел Эффект можно выразить так: целые числа имеют только один тип целых чисел (int), и никакие другие типы целых чисел (long, int8, int64 и т. д.)
  • Целочисленный тип в Numpy соответствует типу данных языка C. Каждое «целое число» имеет свой интервал, для решения проблемы переполнения данных необходимо указать больший тип данных (dtype).

Нет публики【Питон кот], в этом выпуске публикуется серия высококачественных статей, в том числе серия Meow Star Philosophy Cat, расширенная серия Python, серия рекомендаций по хорошим книгам, технические статьи, высококачественные рекомендации и перевод на английский язык и т. д. Добро пожаловать, обратите внимание.

Категории