All different ways of Creating Numpy Arrays!
Published: 2022-12-27 15:09:50

---
title: All different ways of Creating Numpy Arrays!
published: true
date: 2021-05-20 12:35:57 UTC
tags: 
canonical_url: https://sree-gaya3.hashnode.dev/numpy-part1
---

## import numpy as np

Hello Guys👋

In this article, we will see all the different ways of creating Numpy Arrays.

So, Without much ado, Let's get started with the article👍.

- [Numpy Arrays vs Python Lists](#numpy-arrays-vs-python-lists) 
- [Creating Numpy Arrays from Lists](#creating-numpy-arrays-from-lists)
- [Creating Numpy Constant Arrays](#creating-numpy-constant-arrays)
- [Creating Numpy Sequence Arrays](#creating-numpy-sequence-arrays)
- [Creating ndarrays and understanding their properties](#creating-ndarrays-and-know-its-properties)
- [Conclusion](#conclusion)

## Numpy Arrays vs Python Lists 🤨:

The main difference difference is the time taken by them to perform operations. To measure this, we use %timeit function. N loops indicate that the function has been called N times to compute the average time to execute the function. Best of K indicates that the %timeit has been run K times to take the best average. These constants can also be modified and given as argument to the %timeit function.

Let's use %timeit and see the difference:

```
vec_size = 1000
def add_python_lists():
    X = range(vec_size)
    Y = range(vec_size)
    Z = [X[i] + Y[i] for i in range(len(X))]
    return Z

%timeit add_python_lists()

```

The output of the above %timeit function is : 1000 loops, best of 5: 260 s per loop

```
vec_size = 1000
def add_numpy_arrays():
    X = np.arange(vec_size)
    Y = np.arange(vec_size)
    Z = X + Y
    return Z
%timeit add_numpy_arrays()

```

The output of the above %timeit function is : The slowest run took 1698.30 times longer than the fastest. This could mean that an intermediate result is being cached. 100000 loops, best of 5: 3.85 s per loop

So, we can clearly see that to add two lists of same size, Python takes 260s per loop whereas Numpy takes only 3.85s per loop🙂.

## Creating Numpy Arrays from Lists🙃

Numpy arrays can be created using a list with `numpy.array`All elements of a numpy array should be of the same type

- `numpy.array` chooses a data type which fits all of the elements in the array
- We can also specify the data type with the `dtype` parameter

Let's create a numpy array.

```
int_array = np.array([1, 5, 7, 9, -2], dtype=np.int16)
print("int_array:", int_array)

typecasted_int_array = np.array([1, 5, 7, 9, -2.54], dtype=np.int64)
print("typecasted_int_array:", typecasted_int_array)

```

The above code prints

```
int_array: [1 5 7 9 -2] 
typecasted_int_array: [1 5 7 9 -2]

```

Here, int\_array is a numpy array of type int16. The typecasted\_int\_array is the numpy array of type int64. Here what we need to observe is, when we specified the dtype as int, 2.54 is typecasted as 2.

## Creating Numpy Constant Arrays

**np.zeros** (shape, dtype=float) - Returns a new array of given shape and type, filled with zeros.

```
zeros_5 = np.zeros(5)  
print("zeros_5:", zeros_5)

zeros_7 = np.zeros(7, dtype=int)
print("zeros_7:", zeros_7)

zeros_2_3 = np.zeros((2,3), dtype=int)
print("zeros_2_3:", zeros_2_3)

```

The above code prints

```
zeros_5: [0. 0. 0. 0. 0.]
zeros_7: [0 0 0 0 0 0 0]
zeros_2_3: [[0 0 0]
            [0 0 0]]

```

**np.ones** (shape, dtype=float) - Returns a new array of given shape and type, filled with ones.

This functions similar to np.zeros. As the name suggests, the only difference is it returns an array filled with ones instead of zeroes.

**np.full** (shape, fill\_value, dtype=None) - Returns a new array of given shape and type, filled with fill\_value. The default data type is derived from the fill\_value

```
fill_int_array = np.full(10, fill_value=7.5, dtype=int)
print("fill_int_array:",fill_int_array)

fill_bool_array = np.full(6, fill_value=False)
print("fill_bool_array:",fill_bool_array)

```

The above code prints

```
fill_int_array: [7 7 7 7 7 7 7 7 7 7]
fill_bool_array: [False False False False False False]

```

So, here fill\_int\_array is an array of size 10, type int and filled with 7.5. There is no need to specify the dtype as it automatically derive that from the fill\_value as shown in example 2. There we haven't specified any dtype, but the type of fill\_bool\_array is boolean.

## Creating Numpy Sequence Arrays

**np.arange** (start, stop, step, dtype=None) :

- Equivalent to the Python built-in range, but returns an ndarray rather than a list
- Values are generated within the half-open interval [start, stop) 
- Much more efficient than np.array(range(\_))

```
first_10_numbers = np.arange(10)
print("first_10_numbers:",first_10_numbers)

numbers_with_step = np.arange(5, 13, 2, dtype=float)
print("numbers_with_step:",numbers_with_step)

```

And the above code prints

```
first_10_numbers: [0 1 2 3 4 5 6 7 8 9]
numbers_with_step: [5. 7. 9. 11.]

```

Here numbers\_with\_step is an array containing numbers starting from 5 till 13 (excluding) with a step of 2, and of type float. We need not specify the start, step value, by default they are 0 as shown in first\_10\_numbers. It is an array of consecutive numbers from 0 to 10.

**np.linspace** (start, stop, num, endpoint, retstep, dtype) :

Returns evenly spaced numbers, calculated over the interval [start, stop]. The number of evenly spaced numbers returned is equal to num

We Can control whether the last number stop can be included or excluded with the endpoint parameter

```
a = 4.0
b = 5.0
n = 6
sequential_array = np.linspace(a, b, num=n)
print("sequential_array:",sequential_array)

```

This code prints

```
sequential_array: [4. 4.2 4.4 4.6 4.8 5.]

```

This returns an array of 6 numbers between 4 and 5 that are evenly spaced.

## 🖐Some more Methods of Creating Numpy Arrays

**np.empty** (shape, dtype) - Creates an uninitialized empty array of the given shape. It might contain garbage values.

```
empty_array = np.empty(4, dtype=int)
print("empty_array:",empty_array)

```

The above code gives

```
empty_array: [4632796641680687104 4630263366890291200 4645547458125679821 4643121143826433966]

```

This may not give the same values always because they are garbage and will differ everytime we run.

**np.random.random** (shape) - Creates an array of the given shape with random values in the interval [0,1]

```
random_valued_array = np.random.random(4)
print("random_valued_array:",random_valued_array)

```

This code prints

```
random_valued_array: [0.71697819 0.70451885 0.18953959 0.587543]

```

The values are not always same as the name suggests they are randomly generated.

**np.eye** (num) - Returns the identity matrix of size num\*num. Default data type is float.

```
identity_matrix = np.eye(7)
print(identity_matrix)

```

This prints an identity matrix of size 7\*7.

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

```

**np.diag** (list of elements) - Returns a diagonal matrix with the list of elements as diagonal elements. The size is automatically derived from the list.

```
diagonal_matrix = np.diag((1, 2, 3, 5, 8, 10))
print(diagonal_matrix)

```

This code prints a diagonal matrix of size 6\*6 with these elements as diagonal elements.

```
[[1 0 0 0 0 0]
 [0 2 0 0 0 0]
 [0 0 3 0 0 0]
 [0 0 0 5 0 0]
 [0 0 0 0 8 0]
 [0 0 0 0 0 10]]

```

## 🖐Creating ndarrays & know its Properties

Lets create a 3darray and understand its properties.

```
array_2d = np.array([[1, -2, 0], 
                     [3, 4, 2],
                    [3, 8, 9]])
print(array_2d)

```

The above code prints a 3\*3 matrix as below.

```
[[1 -2 0]
 [3 4 2]
 [3 8 9]]

```

### Properties of ndarray 😮😮

1. **size** : Returns the total number of elements in the array
2. **ndim** : Returns the no.of dimensions of the array
3. **shape** : Returns the shape of array

Lets see an example.

```
array_2d = [[1 -2 0]
            [3 4 2]
            [3 8 9]]
print("size: ", array_2d.size)
print("ndim: ", array_2d.ndim)
print("shape: ", array_2d.shape)

```

The above code prints

```
size: 9
ndim: 2
shape: (3, 3)

```

## 🖐Conclusion

Finally, The methods we discussed in this article are

- np.array
- np.zeros, np.ones, np.full
- np.arrange, np.linespace
- np.empty, np.eye, np.diag
- np.random.random
- nd Arrays

What's Next ?

Thank you for reading so far🙏. I hope you enjoyed following it and understood different ways of creating Numpy Arrays. I highly recommend you to play around with these methods.

In the next part, we will discuss the **Indexing and Slicing** of Numpy Arrays in detail !! So Stay Tuned👀👀!!!!

Do share your valuable suggestions and your honest feedback, also Constructive Criticism. If you have any comments, questions, or concerns, Do comment them and I am more than happy to take them💬.

Happy Learning 😊👍!!