LanguagesHow to Create Arrays in NumPy: A Beginner's Guide

# How to Create Arrays in NumPy: A Beginner’s Guide

NumPy stands for Numerical Python. It’s an open-source Python library used in many engineering fields, especially data science and Artificial Intelligence (AI). Numpy is also used for working with arrays, which we will be covering in this Python tutorial.

You could use Python lists to work with your numeric data instead, but lists are slower than arrays and less efficient. Using Numpy is up to 100x faster than using lists. Unlike lists, NumPy arrays only store items of the same data type. For this reason, they are stored in contiguous memory locations, making them faster to access.

## Benefits of NumPy Arrays

There are a number of benefits to using NumPy arrays, other than the fact that they are faster than Python lists. For starters, they require less memory to store data than lists do. This means they help optimize your Pythonic code more. Mathematical operations are also easier to perform on NumPy arrays, thanks to the nature of their N-dimensional properties.

One example of this is the fact that numeric and mathematical operators work the same on NumPy arrays as they do in regular mathematical calculations. If you multiply a NumPy array, the values in the array actually get multiplied; this is not the case with regular Python arrays.

## Defining Arrays in NumPy

In this section, we will discuss how to create and define arrays using NumPy. First, ensure that you have NumPy installed. If you do not, then you can install NumPy by using the code below in your terminal or in Jupyter Notebook:

```pip install numpy
```

You can now import the numpy library in your Jupyter Notebook project (or other Python project) and begin to create arrays. To import numpy, use the following code:

```import numpy as np
```

You can also use a Python file, but using Jupyter Notebook is easier.

To create an array, you’ll need to pass a list to NumPy’s array() method, as shown in the following code:

```my_list1= [2, 4, 6, 8]
array1 = np.array(my_list) # create array
print (array1) # output array elements
```

The array created (array1) has integer values. To check the datatype of NumPy array elements, developers can use the dtype property, as shown in the following code example:

```my_list1.dtype # output for this statement is: dtype('int64')
```

It is also possible to pass more than one list to the array method. See the example below, which passes two lists to the array() method.

```my_list2 = [1,3,5,7]
my_list3 = [4,7,3,9]

my_lists= [my_list2,my_list3]
array2 = np.array(my_lists)
print (array2)
```

## Dimensions and Arrays in NumPy

A dimension is a value that defines the number of indexes you need to specify to select an array element. Note: the code in the last example demonstrated a multidimensional array.

The first array (array1) was a one-dimensional array (1D). The second array (array2) was a two-dimensional array (2D). An array with one dimension is called a vector and the one with two dimensions is called a matrix.

You can also have three-dimensional (3D) and so on. Arrays with 3D or more are normally called Tensors.

To get the size of an array along each dimension, Python developers can use the shape property:

```array2.shape
```

The above statement will output 2, 4, meaning that your array is a 2 × 4 matrix. 2 × 4 implies two rows by four columns.

## Special Arrays in NumPy

There are some special array types that NumPy offers. You can have an array of ones or even zeros. Use the ones() and zero() methods, respectively, to create these types of special arrays. You’ll also need to provide the number of items for both of these as an argument, as shown in the following example:

```np.ones(3)
np.zeros(3)
```

Notice that the results printed are floating-point values or floats. This is the default type for numerical values. In case you would like to specify the data type, developers can use the dtype property. Here is how that looks in Python code:

```np.ones(4, dtype=np.int64)
```

It is also possible to create an empty array. In this sense, it won’t be you to explicitly define what elements your array should contain. Rather, the random content in memory will be used to initialize the array for you.

You can use empty() to declare such an array:

```np.empty()
```

You can also define an array by specifying the range. In this case, you’ll need to put the range (n) in the arrange() method. The array will contain the elements ranging from 0 to (n-1) in linear increments of 1:

```np.arrange(5)
```

At a certain point, you may need to have a custom increment and starting value. Use the syntax below to achieve this:

```# the syntax is arange( start, stop, step)
arange (3, 27, 4) # result is array([ 3, 7, 11, 15, 19, 23])
```

Another method you can use to specify linear values for an array within a particular interval is linspace(). Here is some code showing this in use:

```np.linspace(10, 25, num = 10) # the result  is array([ 10. , 13.75, 17.5, 21.25, 25. ])
```

## Python Lists versus NumPy Arrays

However fast they may be, NumPy arrays are not a one-size-fits-all solution; they aren’t always faster than Python lists. If they were, then the Python community would have already done away with lists.

A good example of where lists are faster than NumPy arrays is when it comes to appending data. The list implementation of appending data is so many times faster than that of NumPy arrays. Actually, algorithm analysis using the big-O notation shows that NumPy’s append method is O(n), while that of lists is O(1).

Subscribe to Developer Insider for top news, trends & analysis