5 min read

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.

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

- How To Install Python 3 on Mac OS
- How To Install Python On Windows
- How To Create Python Virtual Environments On Ubuntu

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

```
pip install numpy
```

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

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

matricesare strictly 2-dimensional, while NumPyarrays(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)
```

```
[ 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]
```

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

```
[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)
```

```
(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.zeros(shape, dtype=float, order='C')`

- 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]]
```

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')`

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.]]
```

```
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]]
```

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]`

PYTHON

Latest from djangocentral

The much-awaited pull request for an async-compatible interface to Queryset just got merged into the main branch of Django.Pull Request - https://github.com/django/django/pull/14843
The Django core team has been progressively adding async suppor…

Read more →

3 min read

Django admin is undoubtedly one of the most useful apps of Django. Over the years there has been very little change in the admin app as far as the UX is concerned and it's not a bad thing at all. Django admin was designed to provide a simple and minimali…

Read more →

4 min read