Типы данных

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

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-объект с плавающей запятой как dtype. 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 * 10 ** 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 long double; в частности, 128-битный тип данных IEEE с четырёхкратной точностью (тип FORTRAN 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.