Append Numpy Array
One of the common operations you may need to perform with arrays is appending new elements to an existing array.Numpy is one of the most popular libraries used for numerical computing in Python. It provides a powerful array object called np.array that allows you to efficiently store and manipulate large multidimensional arrays of homogeneous data.
In this article, we will explore various methods to append arrays in Numpy, along with code examples and their execution results. We will cover both 1-dimensional and multi-dimensional cases.
Introduce append numpy array
The numpy.append() function is a versatile method that allows you to append elements to an existing array along a specified axis. It takes three parameters – the array to which you want to append elements, the values to append, and the axis along which the values should be appended. Let’s explore this with some code examples:
Example 1:
import numpy as np
arr = np.array([1, 2, 3])
values = [4, 5, 6]
result = np.append(arr, values)
print(result)
Output:
Explanation: In this example, we have an existing 1-dimensional array arr with values [1, 2, 3]. We want to append another 1-dimensional array values with values [4, 5, 6] to arr. The np.append() function concatenates the two arrays and returns a new array with the appended values.
Example 2:
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
values = [[7, 8, 9], [10, 11, 12]]
result = np.append(arr, values, axis=0)
print(result)
Output:
Explanation: In this example, we have a 2-dimensional array arr with shape (2, 3). We want to append another 2-dimensional array values with the same shape (2, 3) to arr. By specifying axis=0, we are appending the values along the rows. The resulting array has shape (4, 3).
Introduce append a single value
We can append a single value to a numpy array using numpy.append(). Let’s see an example:
Example 3:
import numpy as np
arr = np.array([1, 2, 3])
new_arr = np.append(arr, 4)
print(new_arr)
Output:
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.
Introduce append multiple values
To append multiple values to a numpy array, we can pass a list of values as the second parameter of numpy.append().
Example 4:
import numpy as np
arr = np.array([1, 2, 3])
new_arr = np.append(arr, [4, 5, 6])
print(new_arr)
Output:
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.
Introduce append arrays with different dimensions
Numpy allows us to append arrays with different dimensions along a specified axis.
Example 5:
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:
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.
Introduce append arrays with different dimensions along axis 1
We can also append arrays with different dimensions along axis 1.
Example 6:
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:
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).
Introduce append along different axes
In numpy, we can append arrays along different axes simultaneously.
Example 7:
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])
print(new_arr)
Output:
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.
Introduce append 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.
Example 8:
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array(['welcome', 'to', 'https://numpywhere.com/'])
new_arr = np.append(arr1, arr2)
print(new_arr)
Output:
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.
Introduce numpy hstack
The numpy.hstack() function is used to horizontally stack arrays. It takes a sequence of arrays as input and concatenates them horizontally. Let’s see how it works with an example:
Example 9:
import numpy as np
arr1 = np.array([0, 1, 2])
arr2 = np.array([3, 4, 5])
result = np.hstack((arr1, arr2))
print(result)
Output:
Explanation: In this example, we have two 1-dimensional arrays arr1 and arr2. The np.hstack() function horizontally stacks these arrays by concatenating them. The resulting array contains all the elements from both arrays in a single 1-dimensional array.
Introduce numpy vstack
The numpy.vstack() function is used to vertically stack arrays. It takes a sequence of arrays as input and concatenates them vertically. Let’s see an example:
Example 10:
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
result = np.vstack((arr1, arr2))
print(result)
Output:
Explanation: In this example, we have two 1-dimensional arrays arr1 and arr2. The np.vstack() function vertically stacks these arrays by concatenating them. The resulting array contains both arrays as rows in a 2-dimensional array.
Introduce numpy concatenate
The numpy.concatenate() function can be used to concatenate arrays along an existing axis. It takes a sequence of arrays and the axis along which the arrays should be concatenated. Let’s see an example:
Example 11:
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
result = np.concatenate((arr1, arr2))
print(result)
Output:
Explanation: In this example, we have two 1-dimensional arrays arr1 and arr2. The np.concatenate() function concatenates these arrays by merging them into a single 1-dimensional array.
Introduce numpy column_stack
The numpy.column_stack() function is used to stack 1-dimensional arrays as columns into a 2-dimensional array. Let’s see how it works:
Example 12:
import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
result = np.column_stack((arr1, arr2))
print(result)
Output:
Explanation: In this example, we have two 1-dimensional arrays arr1 and arr2. The np.column_stack() function stacks these arrays as columns into a 2-dimensional array. Each array becomes a column in the resulting array.
Introduce numpy row_stack
The numpy.row_stack() function is used to stack 1-dimensional arrays as rows into a 2-dimensional array. Let’s see an example:
Example 13:
import numpy as np
arr1 = np.array([0, 1, 2])
arr2 = np.array([3, 4, 5])
result = np.row_stack((arr1, arr2))
print(result)
Output:
Explanation: In this example, we have two 1-dimensional arrays arr1 and arr2. The np.row_stack() function stacks these arrays as rows into a 2-dimensional array. Each array becomes a row in the resulting array.
Introduce numpy insert
The numpy.insert() function allows you to insert elements into an array along a specified axis and at a particular position. Let’s explore this with an example:
Example 14:
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
result = np.insert(arr, 2, [100, 200])
print(result)
Output:
Explanation: In this example, we have an existing 1-dimensional array arr with values [1, 2, 3, 4, 5]. We want to insert the values [100, 200] at index 2. The np.insert() function inserts the values at the specified position and returns a new array.
Introduce numpy resize
The numpy.resize() function is used to resize an array to a specified size. If the new size is larger than the original size, the array is filled with repeated copies of the original data. If the new size is smaller, the original data is truncated. Let’s see an example:
Example 15:
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
result = np.resize(arr, (3, 3))
print(result)
Output:
Explanation: In this example, we have an existing 1-dimensional array arr with values [1, 2, 3, 4, 5]. We want to resize the array to a shape of (3, 3). The np.resize() function resizes the array and repeats the original data to fit the new size.
Compare numpy append with concatenate
Example 16:
import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9]])
result1 = np.append(arr1, arr2, axis=0)
result2 = np.concatenate((arr1, arr2), axis=0)
print(result1)
print(result2)
Output:
Explanation: In this example, we have a 2-dimensional array arr1 with shape (2, 3) and another 2-dimensional array arr2 with shape (1, 3). We want to append arr2 to arr1 along the rows. The np.append() function and np.concatenate() function produce the same result, which is a new array with shape (3, 3), containing all the rows from both arrays.
Conclusion of append numpy array
In this article, we have explored various methods to append Numpy arrays. We started by using the numpy.append() function, which allows you to append elements along a specified axis. Then, we looked at functions like numpy.hstack(), numpy.vstack(), and numpy.concatenate() that provide different ways to stack arrays horizontally and vertically.
We also discussed functions like numpy.column_stack() and numpy.row_stack() that stack 1-dimensional arrays into 2-dimensional arrays as columns and rows respectively. Additionally, we covered the numpy.insert() function to insert elements at a specific position in an array and the numpy.resize() function to resize arrays.
By understanding these methods, you can efficiently manipulate arrays in Numpy and perform operations like appending, stacking, and inserting elements based on your requirements.