Skip to main content
`Ctrl`+`K`

# numpy.dtype

class numpy.dtype(dtype, align=False, copy=False, **kwargs)

  –

  dtype(dtype, align=False, copy=False, [metadata])

  Create a data type object.

  A numpy array is homogeneous, and contains elements described by a dtype object. A dtype object can be constructed from different combinations of fundamental numeric types.

  Parameters:
    dtype

      Object to be converted to a data type object.

    align bool, optional

      Add padding to the fields to match what a C compiler would output for a similar C-struct. Can be `True` only if obj is a dictionary or a comma-separated string. If a struct dtype is being created, this also sets a sticky alignment flag `isalignedstruct`.

    copy bool, optional

      Make a new copy of the data-type object. If `False`, the result may just be a reference to a built-in data-type object.

    metadata dict, optional

      An optional dictionary with dtype metadata.

  Attributes:
    `alignment`

      The required alignment (bytes) of this data-type according to the compiler.

    `base`

      Returns dtype for the base element of the subarrays, regardless of their dimension or shape.

    `byteorder`

      A character indicating the byte-order of this data-type object.

    `char`

      A unique character code for each of the 21 different built-in types.

    `descr`

      __array_interface__ description of the data-type.

    `fields`

      Dictionary of named fields defined for this data type, or `None`.

    `flags`

      Bit-flags describing how this data type is to be interpreted.

    `hasobject`

      Boolean indicating whether this dtype contains any reference-counted objects in any fields or sub-dtypes.

    `isalignedstruct`

      Boolean indicating whether the dtype is a struct which maintains field alignment.

    `isbuiltin`

      Integer indicating how this dtype relates to the built-in dtypes.

    `isnative`

      Boolean indicating whether the byte order of this dtype is native to the platform.

    `itemsize`

      The element size of this data-type object.

    `kind`

      A character code (one of ‘biufcmMOSTUV’) identifying the general kind of data.

    `metadata`

      Either `None` or a readonly dictionary of metadata (mappingproxy).

    `name`

      A bit-width name for this data-type.

    `names`

      Ordered list of field names, or `None` if there are no fields.

    `ndim`

      Number of dimensions of the sub-array if this data type describes a sub-array, and `0` otherwise.

    `num`

      A unique number for each of the 21 different built-in types.

    `shape`

      Shape tuple of the sub-array if this data type describes a sub-array, and `()` otherwise.

    `str`

      The array-protocol typestring of this data-type object.

    `subdtype`

      Tuple `(item_dtype, shape)` if this `dtype` describes a sub-array, and None otherwise.

    type

  Methods

  `newbyteorder`([new_order]) | Return a new dtype with a different byte order.

  See also

  `result_type`

  Examples

  Using array-scalar type:

      >>> import numpy as np
      >>> np.dtype(np.int16)
      dtype('int16')

  Structured type, one field name ‘f1’, containing int16:

      >>> np.dtype([('f1', np.int16)])
      dtype([('f1', '<i2')])

  Structured type, one field named ‘f1’, in itself containing a structured type with one field:

      >>> np.dtype([('f1', [('f1', np.int16)])])
      dtype([('f1', [('f1', '<i2')])])

  Structured type, two fields: the first field contains an unsigned int, the second an int32:

      >>> np.dtype([('f1', np.uint64), ('f2', np.int32)])
      dtype([('f1', '<u8'), ('f2', '<i4')])

  Using array-protocol type strings:

      >>> np.dtype([('a','f8'),('b','S10')])
      dtype([('a', '<f8'), ('b', 'S10')])

  Using comma-separated field formats. The shape is (2,3):

      >>> np.dtype("i4, (2,3)f8")
      dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])

  Using tuples. `int` is a fixed type, 3 the field’s shape. `void` is a flexible type, here of size 10:

      >>> np.dtype([('hello',(np.int64,3)),('world',np.void,10)])
      dtype([('hello', '<i8', (3,)), ('world', 'V10')])

  Subdivide `int16` into 2 `int8`’s, called x and y. 0 and 1 are the offsets in bytes:

      >>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))
      dtype((numpy.int16, [('x', 'i1'), ('y', 'i1')]))

  Using dictionaries. Two fields named ‘gender’ and ‘age’:

      >>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})
      dtype([('gender', 'S1'), ('age', 'u1')])

  Offsets in bytes, here 0 and 25:

      >>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
      dtype([('surname', 'S25'), ('age', 'u1')])