There are several ways to create numpy arrays.
You can create an array of zeros using the zeros function, supplying the required array length:
>>> import numpy as np >>> a = np.zeros(5) >>> print(a) [ 0. 0. 0. 0. 0.]
This creates an array with 5 elements, each set to 0. The array elements are floating point values - this is the default, but you can create an array with different typed elements (eg integers), using the dtype parameter:
>>> a = np.zeros(5, dtype=np.int32) >>> print(a) [0 0 0 0 0]
This creates an array of 32 bit integers. There are various different types, discussed here
You can also create 2 dimensional arrays. Instead of supplying a length, you should supply a tuple containing the number of rows and columns:
>>> a = np.zeros((5, 4)) >>> print(a) [[ 0. 0. 0. 0.] [ 0. 0. 0. 0.] [ 0. 0. 0. 0.] [ 0. 0. 0. 0.] [ 0. 0. 0. 0.]]
You can use 3 dimensions or even higher:
>>> a = np.zeros((2, 3, 4)) >>> print(a) [[[ 0. 0. 0. 0.] [ 0. 0. 0. 0.] [ 0. 0. 0. 0.]] [[ 0. 0. 0. 0.] [ 0. 0. 0. 0.] [ 0. 0. 0. 0.]]]
The ones function creates an array with all elements set to 1, which is sometimes useful:
>>> a = np.ones(7) >>> print(a) [ 1. 1. 1. 1. 1. 1. 1.]
As with the zeros function, you can use dtype to change the type, and you can create multidimensional arrays.
The empty function creates an array where the elements haven't been initialised at all, they just contains whatever happened to be in the memory.
>>> a = np.empty(4) >>> print(a) [ 1.18553402e-311 1.18554384e-311 0.00000000e+000 0.00000000e+000]
You can use this if you are creating an array where the initial values don't matter (if you intend to fill it with other data). empty is slightly faster than zeros because it doesn't need to fill the memory with values.
Note that the data isn't necessarily random. It might contain actual data left over from whenever the memory was last used.
You can create a numpy array from existing data in a list (or any sequence), using the array function:
>>> a = np.array([1, 2, 3, 4]) >>> print(a) [1 2 3 4]
By default, the type of the array will be the same type as the items in the list. For example, if all the items are ints, the array will use default sized ints (normally this will be 32-bit integers). If some or all of the values are floats, the array will use default sized floats (normally double precision). If the list is mixed, the type will be the float, with all the ints converted to float (the elements of a numpy array must all be the same type).
You can change this using the dtype parameter. For example, in the case above we might want an array of bytes (8-bit ints), so we could do this:
>>> a = np.array([1, 2, 3, 4], dtype=np.int8) >>> print(a) [1 2 3 4]
The result looks the same as before, but it now an array of bytes.
You can create a multidimensional array from a multidimensional list:
>>> m = np.array([[1, 2], [3, 4], [5, 6]]) >>> print(m) [[1 2] [3 4] [5 6]]
Copyright (c) Axlesoft Ltd 2020