NumPy supports a much greater variety of numerical types than Python does. The following table shows different scalar data types defined in NumPy.

NumPy numerical types are instances of dtype (data-type) objects, each having unique characteristics. The dtypes are available as np.bool_, np.float32, etc.

A data type object describes interpretation of fixed block of memory corresponding to an array, depending on the following aspects −

**Type of data (integer, float or Python object)****Size of data****Byte order (little-endian or big-endian)**

In case of structured type, the names of fields, data type of each field and part of the memory block taken by each field.

If data type is a subarray, its shape and data type

The byte order is decided by prefixing '<' or '>' to data type. '<' means that encoding is little-endian (least significant is stored in smallest address). '>' means that encoding is big-endian (most significant byte is stored in smallest address).

A dtype object is constructed using the following syntax −

```
numpy.dtype(object, align, copy)
```

The parameters are −

**Object** − To be converted to data type object

**Align** − If true, adds padding to the field to make it similar to C-struct

**Copy** − Makes a new copy of dtype object. If false, the result is reference to builtin data type object

Each built-in data type has a character code that uniquely identifies it.

**'b'** − boolean

**'i'** − (signed) integer

**'u'** − unsigned integer

**'f'** − floating-point

**'c'** − complex-floating point

**'m'** − timedelta

**'M'** − datetime

**'O'** − (Python) objects

**'S', 'a'** − (byte-)string

**'U'** − Unicode

**'V'** − raw data (void)

Data Types | Description | |||
---|---|---|---|---|

bool_ |
Boolean (True or False) stored as a byte | |||

int_ |
Default integer type (same as C long; normally either int64 or int32) | |||

intc |
Identical to C int (normally int32 or int64) | |||

intp | Integer used for indexing (same as C ssize_t; normally either int32 or int64) | |||

int8 | Byte (-128 to 127) | |||

int16 | Integer (-32768 to 32767) | |||

int32 | Integer (-2147483648 to 2147483647) | |||

int64 | Integer (-9223372036854775808 to 9223372036854775807) | |||

uint8 | Unsigned integer (0 to 255) | |||

uint16 | Unsigned integer (0 to 65535) | |||

uint32 | Unsigned integer (0 to 4294967295) | |||

uint64 | Unsigned integer (0 to 18446744073709551615) | |||

float_ | Shorthand for float64 | |||

float16 | Half precision float: sign bit, 5 bits exponent, 10 bits mantissa | |||

float32 | Single precision float: sign bit, 8 bits exponent, 23 bits mantissa | |||

float64 | Double precision float: sign bit, 11 bits exponent, 52 bits mantissa | |||

complex_ | Shorthand for complex128 | |||

complex64 | Complex number, represented by two 32-bit floats (real and imaginary components) | |||

complex128 | Complex number, represented by two 64-bit floats (real and imaginary components) |

In [1]:

```
# using array-scalar type
import numpy as np
dt = np.dtype(np.int32)
print (dt)
```

In [3]:

```
#int8, int16, int32, int64 can be replaced by equivalent string 'i1', 'i2','i4', etc.
import numpy as np
dt = np.dtype('i4')
print (dt)
```

In [4]:

```
# using endian notation
import numpy as np
dt = np.dtype('>i4')
print (dt)
```

In [5]:

```
# first create structured data type
import numpy as np
dt = np.dtype([('age',np.int8)])
print (dt)
```

In [6]:

```
# now apply it to ndarray object
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print (a)
```

Dolly Solanki