Типы данных

Типы массивов и преобразования между типами

NumPy поддерживает гораздо большее разнообразие числовых типов, чем Python. В этом разделе показано, какие типы доступны и как изменить тип данных массива.

Поддерживаемые примитивные типы тесно связаны с типами в C:

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

Числовые типы NumPy являются экземплярами dtype (тип данных) объектов, каждый из которых имеет уникальные характеристики. После импорта NumPy с помощью

>>> import numpy as np

типы данных доступны как np.bool_, np.float32, и т.д.

Расширенные типы, не указанные выше, рассматриваются в разделе Структурированные массивы.

Существует 5 основных числовых типов, представляющих булевы значения (bool), целые числа (int), беззнаковые целые числа (uint), числа с плавающей запятой (float) и комплексные числа. Те, у которых есть числа в их имени, указывают на размер типа в битах (т. е. сколько бит необходимо для представления одного значения в памяти). Некоторые типы, такие как int и intp, имеют разный размер в битах, зависящий от платформы (например, 32-битные и 64-битные машины). Это следует учитывать при взаимодействии с кодом низкого уровня (например, C или Fortran), где обращаются к исходной памяти.

Типы данных могут использоваться как функции для преобразования чисел Python в скаляры массива (см. раздел скаляр массива для объяснения), последовательностей чисел Python в массивы указанного типа или в качестве аргументов для ключевого слова dtype, которое принимают многие функции или методы NumPy. Некоторые примеры:

>>> import numpy as np
>>> x = np.float32(1.0)
>>> x
1.0
>>> y = np.int_([1,2,4])
>>> y
array([1, 2, 4])
>>> z = np.arange(3, dtype=np.uint8)
>>> z
array([0, 1, 2], dtype=uint8)

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

>>> np.array([1, 2, 3], dtype='f')
array([ 1.,  2.,  3.], dtype=float32)

Мы рекомендуем использовать объекты dtype.

Чтобы преобразовать тип массива, используйте метод .astype() (предпочтительный вариант) или сам тип в качестве функции. Например:

>>> z.astype(float)                 
array([  0.,  1.,  2.])
>>> np.int8(z)
array([0, 1, 2], dtype=int8)

Обратите внимание, что выше мы используем Python-объект float как тип данных. NumPy знает, что int относится к np.int_, bool означает np.bool_, что float это np.float_ и complex это np.complex_. Другие типы данных не имеют эквивалентов в Python.

Чтобы определить тип массива, посмотрите на атрибут dtype:

>>> z.dtype
dtype('uint8')

Объекты dtype также содержат информацию о типе, такую как его разрядность и порядок байтов. Тип данных также можно использовать косвенно для запроса свойств типа, таких как является ли он целым числом:

>>> d = np.dtype(int)
>>> d
dtype('int32')

>>> np.issubdtype(d, np.integer)
True

>>> np.issubdtype(d, np.floating)
False

Скаляры массивов

NumPy обычно возвращает элементы массивов в виде скаляров массивов (скаляр со связанным типом данных). Скаляры массивов отличаются от скаляров Python, но в основном их можно использовать взаимозаменяемо (главное исключение — для версий Python, более ранних чем v2.x, где скаляры целых массивов не могут использоваться как индексы для списков и кортежей). Существуют некоторые исключения, например, когда код требует очень специфических атрибутов скаляра или проверяет, является ли значение скаляром Python. Как правило, проблемы легко решаются путем явного преобразования скаляров массивов в скаляры Python с использованием соответствующей функции типа Python (например, int, float, complex, str, unicode).

Основное преимущество использования скаляров массивов заключается в том, что они сохраняют тип массива (Python может не иметь соответствующего скалярного типа, например int16). Таким образом, использование скаляров массивов гарантирует одинаковое поведение между массивами и скалярами, независимо от того, находится ли значение внутри массива или нет. Скаляры NumPy также имеют много таких же методов, как и массивы.

Ошибки переполнения

Фиксированный размер числовых типов NumPy может привести к ошибкам переполнения, когда значение требует больше памяти, чем доступно в типе данных. Например, numpy.power вычисляет 100 ** 8 правильно для 64-битных целых чисел, но возвращает 1874919424 (неправильно) для 32-битного целого числа.

>>> np.power(100, 8, dtype=np.int64)
10000000000000000
>>> np.power(100, 8, dtype=np.int32)
1874919424

Поведение NumPy и типов целых чисел Python существенно различается при переполнении целых чисел и может вводить в заблуждение пользователей, ожидающих, что целые числа NumPy будут вести себя так же, как целые числа Python int. В отличие от NumPy, размер целых чисел Python int гибкий. Это означает, что целые числа Python могут расширяться, чтобы вместить любое целое число, и не переполняться.

NumPy предоставляет numpy.iinfo и numpy.finfo для проверки минимальных или максимальных значений NumPy целых чисел и чисел с плавающей точкой соответственно

>>> np.iinfo(int) # Bounds of the default integer on this system.
iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64)
>>> np.iinfo(np.int32) # Bounds of a 32-bit integer
iinfo(min=-2147483648, max=2147483647, dtype=int32)
>>> np.iinfo(np.int64) # Bounds of a 64-bit integer
iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64)

Если 64-битные целые числа по-прежнему слишком малы, результат может быть преобразован в число с плавающей запятой. Числа с плавающей запятой предлагают больший, но неточный диапазон возможных значений.

>>> np.power(100, 100, dtype=np.int64) # Incorrect even with 64-bit int
0
>>> np.power(100, 100, dtype=np.float64)
1e+200

Расширенная точность

Числа с плавающей запятой Python обычно являются 64-битными числами с плавающей запятой, что почти эквивалентно np.float64. В некоторых редких ситуациях может быть полезно использовать числа с плавающей запятой с большей точностью. Возможность такого использования в NumPy зависит от аппаратного обеспечения и среды разработки: в частности, процессоры x86 предоставляют аппаратную плавающую запятую с точностью 80 бит, и хотя большинство компиляторов C предоставляют это как тип long double, MSVC (стандарт для Windows) делает long double идентичным double (64 бита). NumPy делает доступным тип long double компилятора как np.longdouble (и np.clongdouble для комплексных чисел). Вы можете узнать, что предоставляет ваш NumPy с помощью np.finfo(np.longdouble).

NumPy не предоставляет тип данных с большей точностью, чем C’s long double\; в частности, 128-битный тип данных с квадро-точностью IEEE (FORTRAN’s REAL*16\) недоступен.

Для эффективного выравнивания памяти np.longdouble обычно хранится, дополненным нулями до 96 или 128 бит. Эффективность зависит от аппаратного обеспечения и среды разработки; как правило, на 32-битных системах они дополняются до 96 бит, а на 64-битных — обычно до 128 бит. np.longdouble дополняется до значения по умолчанию системы; np.float96 и np.float128 предоставляются пользователям, которые хотят задать конкретное дополнение. Несмотря на названия, np.float96 и np.float128 предоставляют только такую же точность, как и np.longdouble, то есть 80 бит на большинстве машин x86 и 64 бит в стандартных сборках Windows.

Будьте осторожны, что даже если np.longdouble предлагает большую точность, чем python float, легко потерять эту дополнительную точность, так как Python часто заставляет значения проходить через float. Например, оператор форматирования % требует преобразования своих аргументов в стандартные типы Python, и поэтому невозможно сохранить расширенную точность даже при запросе многих десятичных знаков. Может быть полезно протестировать свой код со значением 1 + np.finfo(np.longdouble).eps.