Типы данных объектов (dtype)

Объект типа данных (экземпляр класса numpy.dtype) описывает, как интерпретировать байты в блоке памяти фиксированного размера, соответствующем элементу массива. Он описывает следующие аспекты данных:

1. Тип данных (целое число, вещественное число, объект Python и т. д.)
2. Размер данных (сколько байтов занимает, например, целое число)
3. Порядок байтов данных (little-endian или big-endian)
4. Если тип данных является structured, агрегатом других типов данных (например, описывающим элемент массива, состоящий из целого числа и вещественного числа),
   1. какие имена «fields» структуры, с помощью которых к ним можно обратиться,
   2. какой тип данных каждого field , и
   3. какая часть блока памяти занимает каждый поле.
5. Если тип данных является подмассивом, каковы его форма и тип данных.

Для описания типа скалярных данных в NumPy существуют несколько встроенных скалярных типов для различных точностей целых чисел, чисел с плавающей точкой и т. д. Элемент, извлечённый из массива, например, путём индексирования, будет объектом Python, тип которого — скалярный тип, связанный с типом данных массива.

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

Структурированные типы данных формируются путём создания типа данных, fields которого содержат другие типы данных. Каждое поле имеет имя, с помощью которого к нему можно обратиться. Родительский тип данных должен иметь достаточный размер для размещения всех своих полей; родительский тип почти всегда основан на типе void , который позволяет произвольный размер элемента.

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

Если массив создаётся с использованием типа данных, описывающего подмассив, размерности подмассива добавляются к форме массива при создании массива. Подмассивы в поле структурированного типа ведут себя иначе; см. Доступ к полям.

Подмассивы всегда имеют непрерывную в стиле C компоновку памяти.

Пример

Простой тип данных, содержащий 32-битное целое число в формате big-endian: (см. Указание и построение типов данных для получения подробной информации о построении)

>>> dt = np.dtype('>i4')
>>> dt.byteorder
'>'
>>> dt.itemsize
4
>>> dt.name
'int32'
>>> dt.type is np.int32
True

Соответствующий скалярный тип массива — int32.

Пример

Структурированный тип данных, содержащий строку из 16 символов (в поле «имя») и подмассив из двух 64-битных чисел с плавающей точкой (в поле «оценки»):

>>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt['name']
dtype('|S16')
>>> dt['grades']
dtype(('float64',(2,)))

Элементы массива этого типа данных заключены в скалярный тип массива, который также имеет два поля:

>>> x = np.array([('Sarah', (8.0, 7.0)), ('John', (6.0, 7.0))], dtype=dt)
>>> x[1]
('John', [6.0, 7.0])
>>> x[1]['grades']
array([ 6.,  7.])
>>> type(x[1])
<type 'numpy.void'>
>>> type(x[1]['grades'])
<type 'numpy.ndarray'>

Указание и построение типов данных

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

Что может быть преобразовано в объект типа данных, описано ниже:

dtype объект

Используется как есть.

None

Тип данных по умолчанию: float_.

Скалярные типы массивов

Все 24 встроенных объекта скалярного типа массива преобразуются в соответствующий объект типа данных. Это также верно для их подклассов.

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

Пример

>>> dt = np.dtype(np.int32)      # 32-bit integer
>>> dt = np.dtype(np.complex128) # 128-bit complex floating-point number

Общие типы

Объекты общих иерархических типов преобразуются в соответствующие объекты типов в соответствии с ассоциациями:

Встроенные типы Python

Несколько типов Python эквивалентны соответствующему скалярному типу массива при использовании для генерации объекта dtype:

Пример

>>> dt = np.dtype(float)   # Python-compatible floating-point number
>>> dt = np.dtype(int)     # Python-compatible integer
>>> dt = np.dtype(object)  # Python object

Типы с .dtype

Несколько видов строк могут быть преобразованы. Распознаваемые строки могут быть префиксованы '>' (big-endian), '<' (little-endian), или '=' (родная для аппаратной платформы, по умолчанию), чтобы указать порядок байтов.

Строки из одного символа

Каждый встроенный тип данных имеет код символа (обновлённые числовые коды типов), который однозначно его идентифицирует.

Пример

>>> dt = np.dtype('b')  # byte, native byte order
>>> dt = np.dtype('>H') # big-endian unsigned short
>>> dt = np.dtype('<f') # little-endian single-precision float
>>> dt = np.dtype('d')  # double-precision floating-point number

Строки типа протокола массива (см. Интерфейс массива)

Первый символ указывает тип данных, а оставшиеся символы — количество байтов на элемент, за исключением Unicode, где он интерпретируется как количество символов. Размер элемента должен соответствовать существующему типу, иначе будет выброшено исключение. Поддерживаемые типы:

Пример

>>> dt = np.dtype('i4')   # 32-bit signed integer
>>> dt = np.dtype('f8')   # 64-bit floating-point number
>>> dt = np.dtype('c16')  # 128-bit complex floating-point number
>>> dt = np.dtype('a25')  # 25-character string

Строка с полями, разделёнными запятыми

Короткий способ задания формата структурированного типа данных — строка с базовыми форматами, разделёнными запятыми. Базовый формат в этом контексте — необязательное указание формы, за которым следует строка типа протокола массива. Скобки обязательны для формы, имеющей более одной размерности. NumPy позволяет изменить формат, в том смысле, что любая строка, которая однозначно идентифицирует тип, может быть использована для задания типа данных в поле. Сгенерированные поля типа данных называются 'f0', 'f1', ..., 'f<N-1>', где N (>1) — количество основных форматов, разделённых запятыми, в строке. Если указано необязательное значение формы, то тип данных для соответствующего поля описывает подмассив.

Пример

• поле с именем f0 содержащее 32-битное целое число
• поле с именем f1 содержащее 2x3 подмассив 64-битных чисел с плавающей точкой
• поле с именем f2 содержащее 32-битное число с плавающей точкой

>>> dt = np.dtype("i4, (2,3)f8, f4")

• поле с именем f0 содержащее строку из 3 символов
• поле с именем f1 содержащее подмассив формы (3,) с 64-битными беззнаковыми целыми числами
• поле с именем f2 содержащее 3x4 подмассив, содержащий строки из 10 символов

>>> dt = np.dtype("a3, 3u8, (3,4)a10")

Строки типов

Любая строка в numpy.sctypeDict.keys():

Пример

>>> dt = np.dtype('uint32')   # 32-bit unsigned integer
>>> dt = np.dtype('Float64')  # 64-bit floating-point number

(flexible_dtype, itemsize)

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

Пример

>>> dt = np.dtype((void, 10))  # 10-byte wide data block
>>> dt = np.dtype((str, 35))   # 35-character string
>>> dt = np.dtype(('U', 10))   # 10-character unicode string

(fixed_dtype, shape)

Первый аргумент — любой объект, который может быть преобразован в объект фиксированного размера типа данных. Второй аргумент — желаемая форма этого типа. Если параметр формы равен 1, то объект типа данных эквивалентен фиксированному типу. Если shape является кортежем, то новый тип данных определяет подмассив заданной формы.

Пример

>>> dt = np.dtype((np.int32, (2,2)))          # 2 x 2 integer sub-array
>>> dt = np.dtype(('S10', 1))                 # 10-character string
>>> dt = np.dtype(('i4, (2,3)f8, f4', (2,3))) # 2 x 3 structured sub-array

[(field_name, field_dtype, field_shape), ...]

obj должен быть списком полей, где каждое поле описывается кортежем длины 2 или 3. (Эквивалентно элементу descr в атрибуте __array_interface__).

Первый элемент, field_name, — это имя поля (если это '' , то назначается стандартное имя поля, 'f#'). Имя поля также может быть 2-кортежем строк, где первая строка — это «заголовок» (который может быть любой строкой или строкой unicode) или метаданные для поля, которые могут быть любым объектом, а вторая строка — это «имя», которое должно быть допустимым идентификатором Python.

Второй элемент, field_dtype, может быть чем угодно, что может быть интерпретировано как тип данных.

Необязательный третий элемент field_shape содержит форму, если это поле представляет собой массив типа данных во втором элементе. Обратите внимание, что 3-кортеж с третьим аргументом, равным 1, эквивалентен 2-кортежу.

Этот стиль не принимает align в конструкторе dtype, так как предполагается, что вся память учитывается описанием интерфейса массива.

Пример

Тип данных с полями big (целое число 32 бита большого порядка) и little (целое число 32 бита малого порядка):

>>> dt = np.dtype([('big', '>i4'), ('little', '<i4')])

Тип данных с полями R, G, B, A, каждое из которых является беззнаковым целым числом 8 бит:

>>> dt = np.dtype([('R','u1'), ('G','u1'), ('B','u1'), ('A','u1')])

{'names': ..., 'formats': ..., 'offsets': ..., 'titles': ..., 'itemsize': ...}

Этот стиль имеет два обязательных и три необязательных ключа. Ключи names и formats обязательны. Их соответствующие значения — списки равной длины с именами полей и форматами полей. Имена полей должны быть строками, а форматы полей могут быть любыми объектами, принимаемыми конструктором dtype.

Если предоставлены необязательные ключи offsets и titles, их значения должны быть списками той же длины, что и списки names и formats. Значение offsets — это список байтовых смещений (целые числа) для каждого поля, а значение titles — это список заголовков для каждого поля (None может быть использовано, если для данного поля заголовок не требуется). Значения titles могут быть любыми string или unicode объектами и добавят ещё одну запись в словарь полей, ключом которой будет заголовок, а значением — тот же кортеж полей, который будет содержать заголовок как дополнительный член кортежа.

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

Пример

Тип данных с полями r, g, b, a, каждое из которых является беззнаковым целым числом 8 бит:

>>> dt = np.dtype({'names': ['r','g','b','a'],
...                'formats': [uint8, uint8, uint8, uint8]})

Тип данных с полями r и b (с указанными заголовками), которые оба являются беззнаковыми целыми числами 8 бит, первое — в байтовой позиции 0 с начала поля, а второе — в позиции 2:

>>> dt = np.dtype({'names': ['r','b'], 'formats': ['u1', 'u1'],
...                'offsets': [0, 2],
...                'titles': ['Red pixel', 'Blue pixel']})

{'field1': ..., 'field2': ..., ...}

Этот способ использования не рекомендуется, потому что он неоднозначен с другим методом построения на основе словаря. Если у вас есть поле, называемое «names», и поле, называемое «formats», возникнет конфликт.

Этот стиль позволяет передать атрибут fields объекта типа данных.

obj должен содержать строковые или unicode-ключи, которые ссылаются на (data-type, offset) или (data-type, offset, title) кортежи.

Пример

Тип данных, содержащий поле col1 (строка длиной 10 символов в байтовой позиции 0), col2 (вещественное число 32 бита в байтовой позиции 10) и col3 (целые числа в байтовой позиции 14):

>>> dt = np.dtype({'col1': ('S10', 0), 'col2': (float32, 10),
    'col3': (int, 14)})

(base_dtype, new_dtype)

В NumPy 1.7 и более поздних версиях этот формат позволяет base_dtype интерпретироваться как структурированный тип данных. Массивы, созданные с этим типом данных, будут иметь базовый тип base_dtype, но будут иметь поля и флаги, взятые из new_dtype. Это полезно для создания пользовательских структурированных типов данных, как это делается в массивах записей.

Этот формат также позволяет указать структурированные типы данных с перекрывающимися полями, функционирующими как тип «union» в C. Однако от этого использования рекомендуется отказаться, и предпочтительнее механизм объединения.

Оба аргумента должны быть преобразуемы в объекты типа данных с одинаковым общим размером. .. предостережение:: Пример

Целое число 32 бита, первые два байта которого интерпретируются как целое число через поле real, а следующие два байта — через поле imag.

>>> dt = np.dtype((np.int32,{'real':(np.int16, 0),'imag':(np.int16, 2)})

Целое число 32 бита, которое интерпретируется как подмассив формы (4,), содержащий целые числа 8 бит:

>>> dt = np.dtype((np.int32, (np.int8, 4)))

Целое число 32 бита, содержащее поля r, g, b, a, которые интерпретируют 4 байта в целом как четыре беззнаковых целых числа:

>>> dt = np.dtype(('i4', [('r','u1'),('g','u1'),('b','u1'),('a','u1')]))

dtype

Описания типов данных Numpy являются экземплярами класса dtype.

Атрибуты

Тип данных описывается следующими атрибутами dtype:

Размер данных описывается:

Порядок байтов в данных:

Информация о подтипах в structured типе данных:

Для типов данных, описывающих подмассивы:

Атрибуты, предоставляющие дополнительную информацию:

Методы

Типы данных имеют следующий метод для изменения порядка байтов:

Следующие методы реализуют протокол pickle: