# Creating NumPy Arrays

NumPy is one of the most popular packages in the Python ecosystem. NumPy adds support to large multidimensional arrays and matrices with great efficiency.

Numpy arrays are a lot faster than traditional python lists because they are stored in continuous memory that allows faster processing and accessing thus making large data processing a lot faster and convenient.

In this tutorial, we will learn how to create NumPy arrays.

## Prerequisite

You must have Python3+ installed in your system, if that’s not the case following articles can help you.

Second, you must have the latest version of NumPy installed in your system. Use the following command to install NumPy.

``````pip install numpy
``````

## How to create NumPy arrays

There are multiple ways you can create an array in Numpy, let’s go over the most common ones one by one.

## Creating NumPy array with arrange function

NumPy comes with a built-in method `arrange()` that’s quite similar to the range() function in Python.

``````import numpy as np
a = np.arange(11) # creates a range from 0 to 10
print(a)
print(a.shape)``````

Output

``````[ 0  1  2  3  4  5  6  7  8  9 10]
(11,)
``````

First, we import the NumPy package as `np` then we invoked the `arrange()` method with a value. Since we passed only one value it will create a rank 1 array or one-dimensional array of 11 elements.

Noticed how indexing starts from 0? Therefore we don’t have the number 11 on the list.

The `shape` property returns the shape of the array which is a one-dimensional array with 11 elements or you can think of it as an 11*1 matrix.

Note – Arrays and Matrix are often used interchangeably. It’s very crucial to know the difference between the two in terms of NumPy.

Numpy matrices are strictly 2-dimensional, while NumPy arrays (ndarrays) are N-dimensional. Matrix objects are a subclass of `ndarray`, so they inherit all the attributes and methods of `ndarrays`.

As per the official documents, it’s not advisable to use matrix class since it will be removed in the future – https://numpy.org/doc/stable/reference/generated/numpy.matrix.html

You can play around with the `arrange()` function by passing negatives values such as.

``````import numpy as np
a = np.arange(-5, -1)
print(a)``````

Output

``````[-5 -4 -3 -2]
``````

As you can observe the default step between the elements is 1, this can also be configured.

``````import numpy as np
a = np.arange(0,11,2) # creates a range from 0 to 10, step 2
print(a)``````
Output
``````[ 0  2  4  6  8 10]
``````

Similar to python’s `range()` function we can pass attributes such as start, stop and step to the `arrange()` function.

``arange(start, stop, step)``

This step function can be used to count backward as well.

``````import numpy as np
a = np.arange(5, 1, -1)
print(a)``````

Output

``````[5 4 3 2]
``````

## Creating NumPy array with zeros function

``````import numpy as np
a = np.zeros(5) # create an array with all 0s
print(a) # [ 0. 0. 0. 0. 0.]
print(a.shape)``````
Output
``````[0. 0. 0. 0. 0.]
(5,)
``````

Now let’s create some two-dimensional arrays with the `zeros()` method.

``````import numpy as np
a = np.zeros((2,3)) # array of rank 2 with all 0s; 2 rows and 3 columns
print(a.shape)
print(a)``````
Output
``````(2, 3)
[[0. 0. 0.]
[0. 0. 0.]]``````

The `zeros()` method takes `shape` as the first argument

``zeros(shape)``

This shape could be an int for a 1D array and a tuple of ints for an N-D array. Thus we passed a tuple as an argument to create a 2D array where the former is the number of rows and the latter is the number of columns.

``np.zeros((2,3)) # array of rank 2 with all 0s; 2 rows and 3``

Let’s go ahead and create a 3D array with zeros.

``````import numpy as np
a = np.zeros((3,2,3)) # array of rank 3 with all 0s; 2 rows and 3
print(a.shape)
print(a)``````

Output

``````(3, 2, 3)
[[[0. 0. 0.]
[0. 0. 0.]]

[[0. 0. 0.]
[0. 0. 0.]]

[[0. 0. 0.]
[0. 0. 0.]]]
``````

To create a 3D array and above we need to pass a tuple with 3 elements to the `zeros()` method. Here the first element is the rank of the array and the latter are the number of rows and column respectively.

Other than shape zeros take two more arguments.

``numpy<span class="token punctuation">.</span>zeros<span class="token punctuation">(</span>shape<span class="token punctuation">,</span> dtype<span class="token operator">=</span><span class="token builtin">float</span><span class="token punctuation">,</span> order<span class="token operator">=</span><span class="token string">'C'</span><span class="token punctuation">)</span>``
• Here `dtype` is the datatype of the elements which by default is float.
• The order parameter determines how the data is stored in memory. C: C-style of storing multi-dimensional data in row-major memory. F: Fortran style of storing multi-dimensional data in column-major in memory.

So in case you want to create a zeros array with only integers you would wanna do something like this.

``````import numpy as np
a = np.zeros((2,3), int) # array of rank 2 with all 0s; 2 rows and 3 with integer values
print(a)``````

Output

``````[[0 0 0]
[0 0 0]]``````

## Creating Numpy arrays with the full function

Instead of 0’s let’s say you want to creates arrays full of a different number for instance let the number be 6, then you could use the `full()` function of NumPy.

``````import numpy as np
a = np.full((2,3), 6) # array of rank 2 with all 6s
print(a)``````

Output

``````[[6 6 6]
[6 6 6]]
``````

The function is quite similar to the `zeros()` function which we saw earlier this one just takes an additional argument `fill_value`.

``np.full(shape, fill_value, dtype = None, order = 'C')``

## Creating NumPy arrays with eye function

Sometimes, you need to create an array that mirrors an identity matrix. You can do so using the `eye()` function.

For those who don’t remember what an identity matrix is – A square matrix in which all the elements of the principal diagonal are ones and all other elements are zeros.

``a = np.eye(4) # 4x4 identity matrix``

Output

``````[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]
``````

## Creating NumPy array of random numbers

``````import numpy as np
a = np.random.random((2,4)) # rank 2 array (2 rows 4 columns) with random values in the half-open interval [0.0, 1.0)
print(a)``````

Output

``````[[0.60750379 0.86313917 0.06771915 0.38928062]
[0.03435306 0.45732639 0.50627336 0.69863683]]
``````

Similarly, you can create a 3D array using the `random()` function.

``a = np.random.random((3,2,4))``

Output

``````[[[0.98981043 0.87668365 0.60244216 0.18769144]
[0.95372264 0.92507173 0.74217822 0.39551042]]

[[0.03540292 0.43823864 0.28823769 0.71393248]
[0.84661176 0.58682121 0.33108038 0.91641688]]

[[0.83330768 0.40824907 0.01822309 0.2082025 ]
[0.77093124 0.72571395 0.81175314 0.08715285]]]
``````

Notice how all the values are within the range of (0,1)?

What if you want to create a uniform matrix within a different range?

For example a 2D array within the range of 1 to 10 having 2 rows and 3 columns. You can do so using the `random.uniform()` function.

``````import numpy as np
a = np.random.uniform(low=1, high=10, size=(2,3))
print(a)``````

Output

``````[[6.14970466 9.91562178 6.58209242]
[4.83473852 3.28020197 3.06821119]]
``````

## Creating NumPy array from a Python list

Of course, python allows the creation of NumPy array from a regular python list.

``````import numpy as np
some_list = [1,2,3,4,5]
arr = np.array(some_list)
print(arr)``````

Output

``[1 2 3 4 5]``

## Support Django Central

If you appreciate my work, or if it has helped you along your journey. It would mean a lot to me if you could write a message on my wall and share a cup of coffee (or tea) with me.