According to the numpy documentation: http://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html, numpy.void types are defined as flexible data types. Basically, these are data types where there is no pre-defined type associated to the variable(s) you're looking at. If you look at numpy, you have data types such as float, uint8, bool, string, etc.
void is to accommodate for more generic and flexible types and are for those data types that don't necessary fall into any one of these pre-defined data types. This situation is mostly encountered when you're loading in a struct where each element has multiple data types associated with multiple fields. Each structure element could have a combination of different data types, and the amalgamation of all of these data types to represent an instance of this structure element thus leads us to numpy.void.
With the documentation, you can certainly do the same operations like you would with any other data type. Take a look at the generic data type methods here: http://docs.scipy.org/doc/numpy/reference/generated/numpy.generic.html#numpy.generic . In fact, all numpy data types are derived from this generic class, including numpy.void.
In the first link I provided at the beginning of this post, it shows a good example of how to create a custom record type, where a record is a combination of a tuple of numbers and a string. When creating a list of these records, each type in the list is of type numpy.void and it demonstrates that a record is of this data type. However, bear in mind that this record list has a data type that is of this record, but each element of this list will be of type numpy.void.
However, as a matter of self-containment, let's re-create the example here: Let's create a custom record type where it has two fields associated for each variable you create:
- A 16-bit string with a field named
name
- A 2-element tuple of floating point numbers that are 64-bits each, with a field named
grades
As such, you'd do something like:
import numpy as np
dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
As such, let's create an example list of two elements and instantiate their fields:
x = np.array([('Sarah', (8.0, 7.0)), ('John', (6.0, 7.0))], dtype=dt)
Because we made this list into a numpy.array, we expect its data type to be so:
type(x)
We get:
<type 'numpy.ndarray'>
Remember, the list itself is a numpy.array, but not the individual elements.
To access the second element of this list, which is the second record, we do:
x[1]
We get:
('John', [6.0, 7.0])
To check the type of the second record, we do:
type(x[1])
We get:
<type 'numpy.void'> # As expected
Some additional bonuses for you
To access the name of the second record, we do:
x[1]['name']
We get:
'John'
To access the grades of the second record, we do:
x[1]['grades']
We get:
array([ 6., 7.])
To check the type of the name inside the second record, we do:
type(x[1]['name'])
We get:
<type 'numpy.string_'>
To check the type of the grades inside the second record, we do:
type(x[1]['grades'])
We get:
<type 'numpy.ndarray'>
Take note that each element in this list is of type numpy.void. However, the individual fields for each element in our list is either a tuple of numbers, or a string. The collection of these elements together is of type numpy.void.
