Contents

## Introduction

While working with your machine learning and data science projects, you will come across instances where you will need to join different numpy arrays for performing an operation on them. This can be done by using numpy append or numpy concatenate functions. In this article, we will learn about **numpy.append() and numpy.concatenate()** and understand in-depth with some examples.

### Importing Numpy Library

Let us commence this article by importing numpy library.

```
import numpy as np
```

We’ll begin this article with **numpy append** function.

**Numpy Append : np.append()**

The **numpy.append()** function is used to add items/elements or arrays **to an already existing array.**

### Syntax

**numpy.append(arr, values, axis=None)**

**arr : array_like** – These are the values are appended to a copy of this array.

**values : array_like** – These values are appended to a copy of arr. It must be of the correct shape (the same shape as arr, excluding axis). If axis is not specified, values can be any shape and will be flattened before use.

**axis : int** (optional) – The axis along which values are appended. If the axis is not given, both arr and values are flattened before use.

The result obtained through **numpy.append()** is a copy of **arr** with values appended to the axis. This append is not **in-place** i.e. original array values are not changed, whereas a new array is allocated and filled. If axis is None, **out** is a flattened array.

### Example 1: Appending multiple arrays to an array

Here array **a** is created and then two arrays are appended to **a** with the help of **np.append()**. The resulting array of append function is a copy of the original array with other arrays added to it. The **original array** is always at the **beginning of the resulting array**.

```
a = np.array([1,2,3])
```

```
np.append(a, [[4, 5, 6], [7, 8, 9]])
```

### Example 2: When axis is specified as ‘0’

This example shows that it is important to take care of the shape of **values** argument when axis is specified. The array[1,5,7] is appended to 2-D array [[2,5,8],[3,4,7]].

```
np.array([[2,5,8],[3,4,7]])
```

```
np.array([[1,5,7]])
```

```
np.append([[2, 5, 8], [3, 4, 7]], [[1, 5, 7]], axis=0)
```

### Example 3 : When axis is specified as ‘0’ but shape of appending array is incorrect

We may encounter an error if the shape of the arrays are not compatible. Here the array[7,8,9] is flattened array which has caused error in appending.

```
np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
```

Moving onto the next function, we have **concatenate** function.

**Numpy Concatenate : np.concatenate()**

Whenever we wish to join two different arrays, then we use **numpy concatenate function**. Below we will learn about its syntax and arguments used in the function.

### Syntax

**numpy.concatenate((a1,a2,……), axis=0,out=None)**

**a1, a2,… : sequence of array_like** – These are the arrays used for concatenating with each other. The arrays should have same shape.

**axis : int** (optional) – The axis along which the arrays will be joined. If axis is None, arrays are flattened before use. Default is 0.

**out : ndarray** (optional) – If provided, this is the destination to place the result. The shape must be correct, matching that of what concatenate would have returned if no out argument were specified.

After executing this function, we get a **concatenated array**.

### Example 1: With axis as ‘None’

In this example, we will be using axis parameter value as **‘None’**, here the arrays will be flattened and then concatenation will be performed.

```
a = np.array([[5, 2], [8, 4]])
a
```

```
b = np.array([[9, 7]])
b
```

```
np.concatenate((a, b), axis=None)
```

### Example 2: With axis as ‘0’

When axis is ‘0’ then concatenation operation takes place on the columns. This is the reason array[5,6] is added column-wise to the 2-D Array [[1,2],[3,4]]

```
np.concatenate((a, b), axis=0)
```

Here we have transposed the **b** array to match the shape of both arrays. When axis is ‘1’ then concatenation operation takes place on the rows. This is the reason array[5,6] is added row-wise to the 2-D Array [[1,2],[3,4]]

```
# Transposing array 'b'
b.T
```

If the **array ‘b’** is not transposed, then the shape of concatenating arrays will not match and error will be produced.

```
np.concatenate((a, b.T), axis=1)
```

## Conclusion

We have reached the end of this article in which we learned about **numpy append and numpy concatenate functions** by studying the syntax and different practical usages. Both of these functions are helpful in joining elements/arrays to existing arrays.

*Reference-* https://numpy.org/doc/

- Also Read – Python Numpy Array – A Gentle Introduction to beginners
- Also Read – Tutorial – numpy.arange() , numpy.linspace() , numpy.logspace() in Python
- Also Read – Complete Numpy Random Tutorial – Rand, Randn, Randint, Normal
- Also Read – Tutorial – Numpy Shape, Numpy Reshape and Numpy Transpose in Python