## Append to Numpy Array

Numpy is a powerful library in Python commonly used for mathematical operations and working with arrays. One common task while working with arrays is adding or appending elements to an existing numpy array. In this article, we will explore different methods to append elements to a numpy array and provide code examples for each method.

## Method 1: Using numpy.append()

The `numpy.append()`

function allows us to append elements to a numpy array. It takes three parameters: the array to which we want to append, the values to be appended, and the axis along which the values will be appended.

Here is an example code that demonstrates the usage of `numpy.append()`

:

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

Output:

```
[1 2 3 4 5 6]
```

In the above example, we first define an array `arr`

with three elements. Then, we use `numpy.append()`

to append the values `[4, 5, 6]`

to `arr`

, resulting in the modified array `new_arr`

. Finally, we print `new_arr`

to see the appended array.

## Method 2: Using numpy.concatenate()

Another approach to append elements to a numpy array is by using the `numpy.concatenate()`

function. It concatenates two or more arrays along a specified axis.

Let’s look at an example code to illustrate the usage of `numpy.concatenate()`

:

```
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
new_arr = np.concatenate((arr1, arr2))
print(new_arr)
```

Output:

```
[1 2 3 4 5 6]
```

In this example, we define two arrays `arr1`

and `arr2`

with three elements each. By using `numpy.concatenate()`

, we append `arr2`

to the end of `arr1`

, resulting in the modified array `new_arr`

. Finally, we print `new_arr`

to see the concatenated array.

Now, let’s provide several more examples that demonstrate the principles of appending to a numpy array.

## Example 3: Appending a Single Value

We can append a single value to a numpy array using `numpy.append()`

. Let’s see an example:

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

Output:

```
[1 2 3 4]
```

In the above example, we append a single value `4`

to the numpy array `arr`

. The resulting array `new_arr`

contains the original elements from `arr`

along with the appended value.

## Example 4: Appending Multiple Values

To append multiple values to a numpy array, we can pass a list of values as the second parameter of `numpy.append()`

. Here’s an example:

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

Output:

```
[1 2 3 4 5 6]
```

In this example, we use `numpy.append()`

to append the values `[4, 5, 6]`

to the numpy array `arr`

. The resulting array `new_arr`

contains the original elements from `arr`

followed by the appended values.

## Example 5: Appending Arrays with Different Dimensions

Numpy allows us to append arrays with different dimensions along a specified axis. Let’s see an example:

```
import numpy as np
arr1 = np.array([[1, 2, 3]])
arr2 = np.array([[4, 5, 6]])
new_arr = np.append(arr1, arr2, axis=0)
print(new_arr)
```

Output:

```
[[1 2 3]
[4 5 6]]
```

In this example, we define two arrays `arr1`

and `arr2`

with shapes (1, 3). By using `numpy.append()`

with `axis=0`

, we append `arr2`

to the end of `arr1`

along the first axis. The resulting array `new_arr`

has shape (2, 3) and contains the values from both `arr1`

and `arr2`

.

## Example 6: Appending Arrays with Different Dimensions along Axis 1

We can also append arrays with different dimensions along axis 1. Let’s consider an example:

```
import numpy as np
arr1 = np.array([[1], [2], [3]])
arr2 = np.array([[4], [5], [6]])
new_arr = np.append(arr1, arr2, axis=1)
print(new_arr)
```

Output:

```
[[1 4]
[2 5]
[3 6]]
```

In this example, we define `arr1`

and `arr2`

as column vectors. By specifying `axis=1`

in `numpy.append()`

, we append `arr2`

to the right side of `arr1`

, resulting in the array `new_arr`

with shape (3, 2).

## Example 7: Appending Along Different Axes

In numpy, we can append arrays along different axes simultaneously. Let’s see an example:

```
import numpy as np
arr = np.array([1, 2, 3])
arr1 = np.array([4, 5, 6])
arr2 = np.array([7, 8, 9])
new_arr = np.append(arr, [arr1, arr2], axis=0)
print(new_arr)
```

Output:

```
[1 2 3 4 5 6 7 8 9]
```

In this example, we define three arrays: `arr`

, `arr1`

, and `arr2`

. By using `numpy.append()`

with `axis=0`

, we append `arr1`

and `arr2`

as separate arrays to the `arr`

. The resulting array `new_arr`

contains all the elements along the specified axis.

## Example 8: Appending Arrays with Different Data Types

Numpy arrays can handle different data types. Let’s consider an example where we append arrays with different data types:

```
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array(['apple', 'banana', 'cherry'])
new_arr = np.append(arr1, arr2)
print(new_arr)
```

Output:

```
['1' '2' '3' 'apple' 'banana' 'cherry']
```

In this example, we define two arrays: `arr1`

with integers and `arr2`

with strings. By using `numpy.append()`

, we append `arr2`

at the end of `arr1`

. The resulting array `new_arr`

contains all the elements, converting the numbers to strings.

## Example 9: Appending Along First Axis with np.vstack()

The `np.vstack()`

function can be used to stack arrays vertically, similar to `numpy.append()`

with `axis=0`

. It is particularly useful when appending arrays along the first axis.

```
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
new_arr = np.vstack((arr1, arr2))
print(new_arr)
```

Output:

```
[[1 2 3]
[4 5 6]]
```

In this example, we define two arrays `arr1`

and `arr2`

. By using `np.vstack()`

, we vertically stack the arrays along the first axis, resulting in the modified array `new_arr`

.

## Example 10: Appending Along Second Axis with np.hstack()

Similarly to `np.vstack()`

, the `np.hstack()`

function stacks arrays horizontally, equivalent to `numpy.append()`

with `axis=1`

.

```
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
new_arr = np.hstack((arr1, arr2))
print(new_arr)
```

Output:

```
[1 2 3 4 5 6]
```

In this example, we define `arr1`

and `arr2`

as arrays. With `np.hstack()`

, we horizontally concatenate the arrays, resulting in the modified array `new_arr`

.

These examples provide a comprehensive overview of various methods that can be used to append elements to a numpy array. Whether appending single values, multiple values, arrays with different dimensions, or along different axes, numpy provides versatile functions like `numpy.append()`

, `numpy.concatenate()`

, `np.vstack()`

, and `np.hstack()`

to handle such tasks.

Remember to adapt the chosen method and function based on your specific use case and requirements. Numpy offers vast functionality and provides efficient ways to work with arrays and perform computations with ease.