Arrays in Python

An array is a collection of objects of the same data type stored at the contiguous memory location. An array helps us to store multiple items of the same type together.

For example, if we want to store three numerical values, we can declare three variables and store the values. But, let us assume that we want to store 1000 numerical values, declaring 1000 variables and assigning them with their values will be difficult and time-consuming. In such cases, we can create an array of the specified size and store the values.

The below figure represents an array of integers of length 5. Each integer takes 4 bytes of memory.

The properties of an array are described as follows.

• An array can store the elements of a specified data type.
• Each element of an array has a unique index. We can access the elements in an array by using the index value.
• The size or length of an array is predefined and cannot be modified.
• All the elements in an array are stored in the contiguous memory location.

Types of Array

An array can be classified based on the number of dimensions. The classification is given as follows.

One-dimensional array

A one-dimensional array is also known as a linear array. In the one-dimensional array, each element is represented with a single index value. One dimensional array has only one row and multiple columns.

The following figure represents a one-dimensional array. We can access any element in the array by using the index values. For example, array[1] represents number 8, array[2] represents number 9, and so on.

All the elements in the one-dimensional array are stored contiguously. The below figure represents the memory allocation of the one-dimensional array. Since it is an array of integers, each element takes 4 bytes of memory.

The total memory allocated to an array is the number of elements multiplied by the size of the individual element. In the above example, the total number of elements = 5 and the size of an integer element is 4 bytes. Hence, the total memory allocated is 5 * 4 = 20 bytes.

Two-dimensional array

A two-dimensional array is a combination of 1D arrays. In the two-dimensional array, the elements are stored in the form of a table and each element is represented with double index values. A two-dimensional array can have multiple rows and multiple columns.

The syntax for accessing an element in a two-dimensional array is,

#syntax:
array_name[i][j]
#i represents row number
#j represents column number

The following figure represents a two-dimensional array with three rows and three columns. The arr[0][0] represents number 3, arr[0][1] represents 6, and so on.

The multi-dimensional arrays are stored in the memory in a row-wise order or column-wise order. In the row-wise order, all the elements of the 0th row will be followed by the elements of the 1st row and so on, and in the column-wise order, the elements of the 0th column will be followed by the 1st column and so on.

The below figure represents a 2D array stored in a row-wise manner in the memory. The total number of elements = 9 and since it is an array of integers, the size of the element = 4 bytes. The total memory space consumed = 9 * 4 = 36 bytes.

Three-dimensional array

A three-dimensional array is a combination of two-dimensional arrays. The elements in the three-dimensional array are represented with three index values.

The syntax for accessing an element in a three-dimensional array is,

#syntax:
array_name[i][j][k]
#i represents array number
#j represents row number
#k represents the column number

The following figure represents a three-dimensional array. The arr[1][1][2] represents number 8, arr[2][0][0] represents number 3 in the three-dimensional array given below.

The below figure represents a 3D array stored in a row-wise manner in the memory, i.e. all the rows of the first array will be followed by the rows of the second array and so on.

Creating an Array

In python, we don’t have an inbuilt array data structure. Instead of an array, we have another inbuilt data structure called a list, which can store a collection of objects of different data types. A user can treat a list as an array, but the main drawback of using a list is the user cannot constrain the type of elements stored in the list.

We can create an array in python, by using the array module. An array module creates an array of specified data types.

The syntax for creating an array is given below.

#syntax:
from array import *
array_name = array(type_code, [initializers])

The type of array is specified by using a type code, which is a single character. The different type codes are listed as follows.

Type Code	C type	Python Type	Minimum size(in bytes)
‘b’	signed char	int	1
‘B’	unsigned char	int	1
‘u’	wchar_t	unicode character	2
‘h’	signed short	int	2
‘H’	unsigned short	int	2
‘i’	signed int	int	2
‘I’	unsigned int	int	2
‘l’	signed long	int	4
‘L’	unsigned long	int	4
‘q’	signed long long	int	8
‘Q’	unsigned long long	int	8
‘f’	float	float	4
‘d’	double	float	8

In the following example, we create an array arr_1 of integer data type using ‘i’ type code and another array arr_2 of double data type using ‘d’ type code.

from array import *

#creating an array of integer data type
arr_1 = array('i', [3, 2, 7, 6, 9])
print(arr_1)
#Output: array('i', [3, 2, 7, 6, 9])

#creating an array of double data type
arr_2 = array('d', [1.4, 7.8, 9.6, 8.2])
print(arr_2)
#Output: array('d', [1.4, 7.8, 9.6, 8.2])

Time and space complexity of creating an array

The time complexity of creating an array is O(1) as we are just assigning a list of values to a variable, and the space complexity of creating an array is O(n), “n” represents the length of the array.

Getting the user input for an Array

Python has an inbuilt input() function which allows the programmer to ask users for input text. The control of the program pauses executing when it encounters an input() function and resumes the execution again when the user has given the input. 

In the following example, we create an empty array arr_1 of integer data type using the array module. In the next step, we ask the user for the length of the array.

Then, we use a for loop that iterates for a range between 0 to the length of the array. In each iteration, we ask the user for the value and add it to the arr_1 using the append() function.

from array import *

#creating an empty array
arr_1 = array('i', [])

#Asking the user for the length of the array
n = int(input("Enter the length of the array: "))

#Adding the elements to the array using for loop
for i in range(n):
    val = int(input("Enter value: "))
    arr_1.append(val)
print("Array: ", arr_1)

The above code returns the output as

Enter the length of the array: 4
Enter value: 5
Enter value: 7
Enter value: 14
Enter value: 12
Array:  array('i', [5, 7, 14, 12])

Inserting an element in an Array

We can insert an element in an array using the insert() function. The insert() function inserts an element at a specific index in the array.

The syntax for the insert() function is as follows.

#syntax:
array_name.insert(index, element)

Parameters:

• index: The index represents the position, where the element is to be inserted.
• element: The element represents the new item that will be inserted into the array.

In the following example, we create an array arr_1 and insert a new element at different positions.

from array import *

#creating an array of integer data type
arr_1 = array('i', [5, 3, 4, 8, 9])
print(arr_1)
#Output: array('i', [5, 3, 4, 8, 9])

#inserting the element 1 at the 0th index
arr_1.insert(0, 1)
print(arr_1)
#Output: array('i', [1, 5, 3, 4, 8, 9])

#inserting the element 7 at the 2nd index
arr_1.insert(2, 7)
print(arr_1)
#Output: array('i', [1, 5, 7, 3, 4, 8, 9])

Time and space complexity of the insert()

The time complexity of the insert() function depends on the position in which we insert an element.

For example, inserting an element at the beginning of an array i.e. at the 0th index will shift each element to the right by one index. Hence, the time complexity will be O(N) where N is the number of elements.

But, inserting an element at the end of an array will just take constant time, i.e O(1) because we are not moving any element to the right or left.

The space complexity for insert() operation is O(1) because we are allocating just one extra space for the insertion of an element.

Traversing an Array

Traversing means going through all the elements one by one. We can traverse an array using a for loop. In the following example, a for loop traverses through all the elements of arr_1 and prints the element in each iteration.

from array import *
#creating an array of integer data type
arr_1 = array('i', [5, 3, 4, 8, 9])

#Traversing the array arr_1
for ele in arr_1:
    print(ele)

The above program returns the output as

5
3
4
8
9

Time and space complexity to traverse an array

The time complexity of the above code is linear, i.e O(N) as the for loop traverses each element of the array and the space complexity is O(1) because we are not using any extra space for traversing.

Accessing an element of an Array

We can access an element at a specific index using the index [] operator. The syntax to access an element in an array is as follows.

#syntax:
array_name[index_val]

If the index_val is greater than or equal to the length of the array, the program raises an IndexError exception.

To overcome this error, we use a conditional statement to check if the index_val is greater than or equal to the length of the array. If the condition is True, the program gives output as “No element found”. Otherwise, the program prints the element as output.

from array import *
def access_ele(arr, index_val):
    #checking if index_val greater than len(arr)
    if index_val >= len(arr): 
        return "No element Found"
    else:
        return arr[index_val]

#creating an array of integer data type
my_arr = array('i', [5, 3, 4, 8, 9])

#Accessing an element at the 2nd index
print(access_ele(my_arr, 2))
#Output: 4

#Accessing an element at the 5th index
print(access_ele(my_arr, 5))
#Output: "No element Found"

Time and space complexity of accessing an element

The time complexity to access an element in an array is constant, i.e. O(1) and the space complexity is also O(1) as we are not using any additional space to access an element.

Searching for an element in an Array

In the following example, we use the linear search algorithm to search for an element in the array. We use a for loop to iterate over all the elements in the array. The program compares if the element at a specific index is equal to the key element in each iteration.

If the element is found in the array, the index value is returned as output. Otherwise, the program returns the statement “Element not found” as output.

from array import *

def search_ele(arr, key):
    for i in range(len(arr)):
        if arr[i] == key:  
            return i         # returning the index val
    return "Element not found"

#creating an array of integer data type
my_arr = array('i', [5, 3, 4, 8, 9])

#searching for element 4
print(search_ele(my_arr, 4))
#Output: 2

#searching for an element 15
print(search_ele(my_arr, 15))
#Output: "Element not found"

Time and space complexity to search an element

The time complexity to search for an element in an array using the linear search algorithm is O(N) and the space complexity is O(1).

Deleting an element from an Array

The remove() function deletes the first occurrence of the specified element from an array. The syntax for the remove() function is as follows.

#syntax:
array_name.remove(ele)

If the element to be removed is not found in the array, then the program raises a ValueError exception.

Example,

from array import *

#creating an array of integer data type
my_arr = array('i', [5, 3, 4, 8, 9])

#Deleting element 4 from my_arr
my_arr.remove(4)
print(my_arr)
#Output: array('i', [5, 3, 8, 9])

#Deleting element 10 form my_arr
my_arr.remove(10)
print(my_arr)
#Output: ValueError: array.remove(x): x not in array

Time and space complexity of remove()

The time complexity of the remove() function depends on the item we are removing.

For example, deleting an element at the beginning of an array i.e. at the 0th index will shift each element to the left by one index. Hence, the time complexity will be O(N) where N is the number of elements.

But, deleting an element from the end of the array will just take constant time, i.e O(1) because we are not moving any element to the right or left.

The space complexity of the remove() function is O(1) because we are not using any additional space.

Operations on a One-Dimensional Array

The array module comes with several other inbuilt functions. Some of them are described as follows.

append()

The append() functions add a new item at the end of an array. The syntax for using the append() function is as follows.

#syntax:
array_name.append(item)

Example,

from array import *
#creating an array of integer data type
my_arr = array('i', [5, 3, 4])

#Appending the element 15 using append()
my_arr.append(15)
print(my_arr)
#Output: array('i', [5, 3, 4, 15])

extend()

The extend() function takes an iterable as a parameter and adds all the items in the iterable at the end of the array. The element in the iterable must be of the same data type. The iterable can be an array, list, tuple, etc.

The syntax for the extend() function is given below.

#syntax:
array_name.extend(iterable)

Example,

from array import *
#creating an array of integer data type
my_arr = array('i', [5, 3, 4])

#Adding the items of arr_2 using extend()
arr_2 = array('i', [1, 2])
my_arr.extend(arr_2)
print(my_arr)
#Output: array('i', [5, 3, 4, 1, 2])

fromlist()

The fromlist() takes a list as a parameter and adds all the items of the list at the end of the array. The syntax for fromlist() method is given below.

#syntax:
array_name.fromlist(list)

Example,

from array import *
#creating an array of integer data type
my_arr = array('i', [5, 3, 4])

#Adding the item of a list using fromlist()
list_1 = [15, 13]
my_arr.fromlist(list_1)
print(my_arr)
#Output: array('i', [5, 3, 4, 15, 13])

pop()

The pop() function takes an index value as a parameter and removes the item at the specified index. By default, the index value = -1 i.e. if the index value is not provided the pop() function removes the last element of the array.

The syntax for the pop() function is as follows.

#syntax:
array_name.pop(index)

Example,

from array import *
#creating an array of integer data type
my_arr = array('i', [5, 3, 4])

#Popping an item using pop()
my_arr.pop() #removes last item
print(my_arr)
#Output: array('i', [5, 3])

index()

The index() function returns the index of the first occurrence of the specified item. The syntax for the index() function is as follows.

#syntax:
array_name.index(element)

Example,

from array import *
#creating an array of integer data type
my_arr = array('i', [5, 3, 4, 15])

#Getting the index of item 15
ind = my_arr.index(15)
print("Index val of element 15: ", ind)

reverse()

The reverse() method reverses the order of elements in an array. The syntax for the reverse() method is as follows.

#syntax:
array_name.reverse()

Example,

from array import *
#creating an array of integer data type
my_arr = array('i', [5, 3, 4, 15])
my_arr.reverse() #reverses my_arr
print(my_arr)
#Output: array('i', [15, 4, 3, 5])

buffer_info()

The buffer_info() returns the current memory address and the length of the array in a tuple format. The syntax for using buffer_info() is as follows.

#syntax:
array_name.buffer_info()

In the following example, we initialize my_arr = array(‘i’, [5, 3, 4, 15]). The statement my_arr.buffer_info() returns the output as (2324029538416, 4). The number 2324029538416 represents the current memory address of my_arr and the number 4 represents the length of the my_arr.

from array import *
#creating an array of integer data type
my_arr = array('i', [5, 3, 4, 15])
print(my_arr.buffer_info())
#Output: (2324029538416, 4)

count()

The count() function returns the number of occurrences of a specific element in an array. The syntax for using the count() method is given below.

#syntax:
array_name.count(val)

Example,

from array import *
#creating an array of integer data type
my_arr = array('i', [5, 3, 4, 15, 5, 5])

#Counting the occurrences of element 5
print(my_arr.count(5))
#Output: 3

tolist()

The tolist() method converts an array to a list. The syntax for tolist() is as follows.

#syntax:
array_name.tolist()

Example,

from array import *
#creating an array of integer data type
my_arr = array('i', [5, 3, 4, 15])

#Converting an array to a list
my_list = my_arr.tolist()
print(my_list)
#Output: [5, 3, 4, 15]

Slicing

We can slice an array by using the indexing syntax. For example, consider an array my_arr = array(‘i’, [7, 9, 4, 5, 6, 10, 15, 12]). Slicing the array form index 1 to index 5 will give output as array(i, [9, 4, 5, 6, 10]).

The syntax to slice in an array is given below.

#syntax:
array_name[start: stop]

Parameters:

• start: The starting index value where the slicing of an array starts. By default, the value of start is 0 if not provided.
• stop: The ending index value until where the slicing takes place. The slicing stops at index end -1. By default, the value of the end parameter is the length of the array, if not provided.

Example,

from array import *
#creating an array of integer data type
my_arr = array('i', [7, 9, 4, 5, 6, 10, 15, 12])

print(my_arr[1:6]) #start = 1, end = 6
#Output: array('i', [9, 4, 5, 6, 10])

print(my_arr[: 5]) #start = 0, end = 6
#Output: array('i', [7, 9, 4, 5, 6])

print(my_arr[2: ]) #start = 6, end = 8
#Output: array('i', [4, 5, 6, 10, 15, 12])

Creating a Two-Dimensional Array

We know that two-dimensional arrays are a combination of 1D arrays. For example, [[4, 2, 3], [8, 9, 10], [6, 7, 8]] represents a two-dimensional array.

We will use the NumPy module instead of the array module to create a 2D array, as the NumPy module provides high-performance multidimensional arrays and different tools to work with these arrays.

The syntax for creating a 2D array using the NumPy module is as follows.

#syntax:
from numpy import *
arr_name = array(list or tuple)

In the following example, we create a 2D array by passing a list of lists as a parameter to the array() function.

from numpy import *
my_arr = array([[4, 5, 6], [5, 3, 2]])
print(my_arr)

#Output: [[4 5 6]
                [5 3 2]]

Time complexity and space complexity of creating a two-dimensional array

The time complexity of creating a 2D array is O(1) as we are just assigning the values of a 2D array to a variable, and the space complexity of creating a 2D array is O(m*n), where “m” represents the number of rows, and “n” represents the number of columns.

Insertion in a Two-Dimensional Array

We can use the insert() function to add a row or column to a 2D array. There are two ways to add elements in a 2D array

• Adding a column
• Adding a row

The syntax for the insert() function is as follows.

#syntax:
insert(array, index, values, axis =None)

Parameters:

• array: The input array, where rows and columns will be inserted.
• index: The index values before which the values are to be inserted.
• values: The values to be added to the input array.
• axis: Axis along which we want to insert the values. If axis = 1, the elements will be added in a column-wise manner, and if axis = 0, the elements will be added in a row-wise manner. By default, the value of axis = None, i.e the values will be added to the flattened input array.

Adding a column to the two-dimensional array using insert()

In the following example, we create a 2D array arr_1 using the numpy module. The statement insert(arr_1, 1, [11, 12, 13], axis = 1) inserts a column with values [11, 12, 13] in the 1st column of the array arr_1. Here, axis = 1 represents that the values will be added in a column-axis.

from numpy import *
arr_1 = array([[4, 5, 6], [5, 3, 2], [7, 0, 4]])
print(arr_1)
#Output: [[4 5 6]
                [5 3 2]
                [7 0 4]]
#Insering a column before column 1
arr_2 = insert(arr_1,1, [11, 12, 13], axis = 1)
print(arr_2)
#Output: [[ 4 11  5  6]
                [ 5 12  3  2]
                [ 7 13  0  4]]

Adding a row to the two-dimensional array using insert()

In the following example, we create a 2D array arr_1 using the numpy module. The statement insert(arr_1, 1, [11, 12, 13], axis = 1) inserts a row with values [11, 12, 13] in the1st row of the array arr_1. Here, axis = 0 represents the values will be added in a row-axis.

from numpy import *
arr_1 = array([[4, 5, 6], [5, 3, 2], [7, 0, 4]])
print(arr_1)
#Output: [[4 5 6]
                [5 3 2]
                [7 0 4]]

arr_2 = insert(arr_1,1, [11, 12, 13], axis = 0)
print(arr_2)
#Output: [[ 4  5  6]
                [11 12 13]
                [ 5  3  2]
                [ 7  0  4]]

Time and space complexity of insert()

The time complexity of the insert() function depends on the position in which we insert an element.

Consider a 2D array of size m x n, inserting a column at the 0th column will shift each element of the 2D array to the right by one step. Hence, the time complexity will be O(m*n).

But, inserting a column at the end of a 2D array will just take constant time, i.e O(1) because we are not moving any element to the right or left.

The space complexity to insert a row or column using insert() function is O(1).

Adding a row or column at the end of the 2D array using append()

We can add a row or column at the end of the 2D array using the append() function. The syntax for the append() function is as follows.

#syntax:
append(array, values, axis =None)

Parameters:

• array: The input array, where rows and columns will be inserted.
• values: The values to be added to the input array.
• axis: Axis along which we want to insert the values. If axis = 1, the elements will be added after the last column, and if axis = 0, the elements will be added after the last row. By default, the value of axis = None, i.e. the values will be added to the flattened input array.

Example,

from numpy import *
arr_1 = array([[4, 5, 6], [5, 3, 2], [7, 0, 4]])
print(arr_1)
#Output: [[4 5 6]
                [5 3 2]
                [7 0 4]]

#Adding a row to the arr_1
arr_2 = append(arr_1, [[11, 12, 13]], axis = 0)
print(arr_2)
#Output: [[ 4  5  6]
                [ 5  3  2]
                [ 7  0  4]
                [11 12 13]]
#Adding a column to the arr_1
arr_3 = append(arr_1, [[11],[12], [13]], axis = 1)
print(arr_3)
#Output: [[ 4  5  6 11]
                 [ 5  3  2 12]
                 [ 7  0  4 13]]

The time complexity of the append() function is O(1) and the space complexity of the append() function is also O(1).

Accessing element from a 2D Array

We can access the element from a 2D array using double index values. The syntax for accessing an element in a two-dimensional array is,

#syntax:
array_name[i][j]
#i represents row number
#j represents column number_

The len(arr_name) gives the length of the row and len(arr_name[0]) gives the length of the column. If the index value of the row or column is greater than the last index value of the row or column, the program raises an IndexError exception.

To overcome this error, we use a conditional statement to check if the row_ind or col_ind is greater than the last index value of row and column. If the condition is True, the program gives output as “Incorrect index”. Otherwise, the program returns the element as output.

from numpy import *
def access_ele(arr, row_ind, col_ind):
    #checking if row_ind and col_ind greater than ending index
    if row_ind >= len(arr) or col_ind >= len(arr[0]): 
        return "Incorrect index"
    else:
        return arr[row_ind][col_ind]

my_arr = array([[4, 5, 6], [5, 3, 2], [7, 0, 4]])
#Accessing an element at the row_ind = 2, col_ind = 1
print(access_ele(my_arr, 2, 2))
#Output: 4

#Accessing an element at the row_ind = 3,col_ind = 2
print(access_ele(my_arr, 3, 2))
#Output: Incorrect index

Time and space complexity of accessing an element in 2D array

The time complexity to access an element in a 2D array is constant, i.e. O(1) and the space complexity is also O(1) as we are not using any additional space to access an element.

Traversing a 2D Array

We can iterate through all the elements of a 2D array using nested for loop. The first for loop iterates through each row of the 2D array, and the second nested for loop iterates through each column of the 2D array.

In the following example, we use the nested for loop that traverses each element of the 2D array and prints the data item in the 2D array.

from numpy import *
my_arr = array([[4, 5, 6], [5, 3, 2], [7, 0, 4]])
for i in range(len(my_arr)):
    for j in range(len(my_arr[0])):
        print(my_arr[i][j], end = " ")

#Output: 4 5 6 5 3 2 7 0 4

Time and space complexity of traversing a 2D array

The time complexity of the above code is O(m*n), as the for loop traverses each element of the array. Here, m is the number of rows and n is the number of columns. The space complexity is O(1) because we are not using any extra space for traversing.

Searching for an element in a 2D Array

In the following example, we use a for loop to traverse the 2D array. In each iteration, the program compares the element of the 2D array with the key element. If the element is found, the row index and column index are returned as output. Otherwise, the program returns the statement “Element not found” as output.

from numpy import *

def search_ele(arr, key):
    for i in range(len(arr)):
        for j in range(len(arr[0])):
            if arr[i][j] == key:  
                return "row = " + str(i) +" col = " + str(j)      # returning the index val
    return "Element not found"

my_arr = array([[4, 5, 6], [5, 3, 2], [7, 0, 4]])

#searching for an element 7
print(search_ele(my_arr, 7))
#Output:row = 2 col = 0

#searching for an element 15
print(search_ele(my_arr, 15))
#Output: "Element not found"

Time and space complexity to search an element in a 2D array

The time complexity to search an element in a two-dimensional array is O(m*n) as we traverse through each element of the 2D array. The space complexity is O(1) because we are not using any additional space for searching an element.

Deleting a row or column from a 2D Array

There are two ways to delete elements from a 2D array

• Deleting a row
• Deleting a column

We can use the delete() function in the NumPy module to delete a row or column from a 2D array. The syntax for the delete() function is as follows.

#syntax:
delete(array, index, axis =None)

Parameters:

• array: The input array, from which rows and columns will be deleted.
• index: The index values of rows or columns to delete.
• axis: Axis along which we want to delete the values. If axis = 1, the elements fromthe column will be deleted, and if axis = 0, the elements from the row will be deleted. By default, the value of axis = None, i.e the values will be deleted from the flattened input array.

Deleting a column from a 2D array

In the following example, we create a 2D array arr_1 using the NumPy module. The statement delete(arr_1, 1, axis = 1) deletes the 1st column of the array arr_1.

from numpy import *
arr_1 = array([[4, 5, 6], [5, 3, 2], [7, 0, 4]])
print(arr_1)
#Output: [[4 5 6]
                [5 3 2]
                [7 0 4]]

#Deleting column 1
arr_2 = delete(arr_1, 1, axis = 1)
print(arr_2)
#Output: [[4 6]
                [5 2]
                [7 4]]

Deleting a row from a 2D array

In the following example, we create a 2D array arr_1 using the NumPy module. The statement delete(arr_1, 1, axis = 0) deletes the 1st row of the array arr_1.

from numpy import *
arr_1 = array([[4, 5, 6], [5, 3, 2], [7, 0, 4]])
print(arr_1)
#Output: [[4 5 6]
                [5 3 2]
                [7 0 4]]
#Deleting row 1
arr_2 = delete(arr_1, 1, axis = 0)
print(arr_2)
#Output: [[4 5 6]
                [7 0 4]]

Time and space complexity of deleting a row or column in a 2D array

The time complexity of the delete() function depends on the position from which we delete an element.

Consider a 2D array of size m x n, deleting the 0th column will shift each element of the 2D array to the left by one step. Hence, the time complexity will be O(m*n).

But, deleting the last column of a 2D array will just take constant time, i.e O(1) because we are not moving any element to the right or left.

The space complexity to delete a row or column is constant, i.e. O(1).

Advantages and disadvantages of using Arrays

Advantages

• We can store multiple elements items of same data type.
• Random access of the element. Accessing an element from an array takes O(1) time.

Disadvantages

• We cannot use an array to store the elements of different data types.
• The size of the array is fixed to hold its content. The memory allocated cannot be increased or decreased.

FAQ on Arrays

How to add, subtract and multiply two arrays in python

To add, subtract or multiply elements in arrays, the length of the arrays should be the same. In the below code, we use a, d and p to store the sum, difference, and product of arr1 and arr2.

a = [1,2,3]
b = [4,5,6]
s = []
d = []
p = []
for i in range(len(a)):
    s.append(a[i]+b[i])
    d.append(a[i]-b[i])
    p.append(a[i]*b[i])
print(s)
print(d)
print(p)

Output –

[5, 7, 9]
[-3, -3, -3]
[4, 10, 18]

How to check if two arrays are equal in python

We can use ‘==’ operator to check the equality of arrays.

a = [1,2,3]
b = [1,2,3]
c = [1,2,4]
print(a==b)          
print(a==c)          

Output –

True
False

How to create a list of arrays in python

Elements of a list can be heterogeneous. So, we can use the following method to create a list of arrays.

list1 = [[1,2],[3,4],[5,6,7,8]]

How to slice arrays in python

Slice operator[ : ] can be used to slice arrays/lists in python.

a = [1,2,3,4,5]
print(a[0:3])
print(a[1:])
print(a[:2])

Output–

[1, 2, 3]
[2, 3, 4, 5]
[1, 2]

How to access lists of arrays in python

Lists of an array can be accessed using their indices.

list1 = [[1,2],[3,4],[5,6,7,8]]
print(list1[0], list1[1], list1[2])

Output–

[1, 2] [3, 4] [5, 6, 7, 8]

How to map two arrays in python

In the below code, we zip the lists together, and create a dictionary for zipped lists.

arr1 = [0,0,1,2,3]
arr2 = [4,4,6,8,7]
map12 = dict(zip(array_1, array_2))
print(map12)

Output–

{1: 4, 2: 5, 3: 6}

How to put multiple arrays in a list in python

We can use the append keyword to add a list to another list.

a = []
a.append([1,2,3])
a.append([4,5])
print(a)

Output–

[[1, 2, 3], [4, 5]]

How to shuffle two arrays in same fashion python

You cannot shuffle multiple arrays in a similar fashion. But you can reassign elements of your choice to similar indices.

Why python arrays are called list

There’s no definite data type for arrays in python, so we use lists for the same which serves its purpose as an array. For small data, lists can be used as arrays. But for large data, to make the manipulation of the arrays easier, NumPy is preferred over lists.

How to create an array of empty arrays python

append() keyword with empty entities can be used to create an element of an empty list/array.

a = [1,2,3]
a,append([])
print(a)

Output–

[1, 2, 3, []]

Python indices where 2 arrays match

Indices are independent of whether the arrays match or not

a = [1,2,3,4]
b=[5,6,7,4]
for i,j in a,b:
    if i==j:
        print('Similar')

How to write to 2d arrays in python

The 2D array is nothing but an array of several arrays. To access the elements in a 2D array, we use 2 variables, one for the row and another for the column.

a = [[1,2,3],[4,5,6],[5,6,7]]
for i in a:
    for j in i:
        print(j,end='')
    print()

Output–

123
456
567

How to construct large arrays python

To construct large arrays, lists can be used but NumPy is more efficient and easy to work with.

from numpy import np
a = [0,1,2,3,4,5,6,7,8,9,10,11,12]
b = np.arange(13)
print(a,b)

Output–

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] [ 0  1  2  3  4  5  6  7  8  9 10 11 12]

Python how to combine two truth arrays

Truth arrays cannot be combined as it just indicates the equivalence of arrays.

Python how to check the intersection of two arrays

In the following code, elements of a are compared with each element in b and if the element exists in both the arrays, it is stored in an array.

a = [1,2,3,4,5]
b = [4,5,6,7,8]
c = [i for i in a if i in b]
print(c)

Output–

[4, 5]

How to create arrays from user input

Elements of an array can be given as input by setting the number of elements and iterating through the range of the number as below.

a = []
n = int(input())
for i in range(n):
    a.append(int(input()))
print(a)

What is the difference between arrays and lists python

In the classical sense, lists can be used as arrays, as lists can assume both homogeneous and heterogeneous elements. The difference is, arrays consist of homogeneous elements and lists can consist of heterogeneous elements.

How to know the number of sub arrays in python

The keyword len() can be used to find the number of sub-arrays in an array.

a = [[1,2], [3,4,5]]
print(len(a))

Output–

2

How to clear lists and arrays python 3

The clear() keyword can be used to clear a list/array

a = [[1,2], [3,4,5]]
print(a)
a.clear()
print(a)

Output–

[[1, 2], [3, 4, 5]]
[]

How to read text files in python and convert into int array

If the text file contains strings that purely consist of integers, then the following method can be used.

h = open('integer.txt', 'r')
a = []
for line in h:
    a.append(line)
print(a)

How to shuffle arrays in python

shuffle() keyword can be used to shuffle an array.

import random

mylist = [1,2,3,4,5]
random.shuffle(mylist)

print(mylist)

Output–

[2,5,1,4,3]

What is sliding window in arrays in python

The window sliding algorithm is used to find the maximum sum of elements in the array taking a given number of elements as fixed in one iteration. The length of the array should be greater than the fixed length. In the following code, in each iteration, the sum can be calculated by removing the leftmost element and adding the rightmost element to w_sum.

If w_sum is greater than the previously calculated max_sum, it is updated. The process is continued until the end of the array.

def maxSum(arr, k):
    # length of the array
    n = len(arr)
    if n < k:
        print("Invalid")
        return -1
 
    # sum of first window of size k
    w_sum = sum(arr[:k])
 
    # first sum computed
    max_sum = w_sum
 
    for i in range(n - k):
        w_sum = w_sum - arr[i] + arr[i + k]
        max_sum = max(w_sum, max_sum)
 
    return max_sum

# main code
arr = [1, 4, 2, 10, 2, 3, 1, 0, 20]
k = 4
print(maxSum(arr, k))

Output–

24

Indices where arrays are not equal python

!= operator can be used to find the index where the array elements are not equal.

a = [1,2,3,4]
b = [5,2,7,4]
for i in range(len(a)):
    if a[i] != b[i]:
        print(i)

Output-

1
3

Python how to use a while loop to create arrays

In the following code, we use a while loop to append elements in an array.

a = []
n = int(input())
i = 0
while i < n:
a.append(int(input())) #input elements
print(a) #returns the array of size n

Output-

1
2
3
[1, 2, 3]

How to iterate through two arrays simultaneously python

A single variable can be used for both the arrays to iterate through them simultaneously

a = [1,2,3,4]
b = [5,6,7,8]
for i in range(len(a)):
    print(a[i], b[i])

Output–

1 5
2 6
3 7
4 8

Python what structures are faster, lists or arrays

Arrays using NumPy are faster than arrays using lists.

Multiprocessing python why does map return 2d arrays as lists of columns

In multiprocessing python, map returns 2d arrays as lists of columns to picture 2d arrays as matrices.

How to stack two arrays in python

+ operator can be used to combine 2 arrays.

a = [1,2,3,4]
b = [5,6,7,8]
c = a+b
print(c)

Output-

[1,2,3,4,5,6,7,8]

Three arrays and want to see where values are equal python

== operator can be used to index where the elements are equal in 3 arrays.

a = [1,2,3]
b = [4,5,3]
c = [2,4,3]
for i in range(len(a)):
    if a[i] == b[i] and a[i] == c[i]:
        print(i)

Output–

2

How to build parallel arrays in python

To build parallel arrays, the length of the arrays should be equal. A single variable can be used to iterate through all the arrays simultaneously.

a = ['a','b','c']
b = [1,2,3]
for i in range(len(a)):
    print(a[i],':',b[i])

Output–

a : 1
b : 2
c : 3

How to combine two arrays and remove overlapping values python

not in keywords can be used as follows.

a = [1,2,3,4]
b = [1,2,5,6]
for i in b:
    if i not in a:
        a.append(i)
print(a)

Output–

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

How to find the covariance of two arrays in python

Covariance of 2 arrays can be found by covar() function as follows.

def covar(x, y):
    # Finding the mean of the series x and y
    mean_x = sum(x)/float(len(x))
    mean_y = sum(y)/float(len(y))
    # Subtracting mean from the individual elements
    sub_x = [i - mean_x for i in x]
    sub_y = [i - mean_y for i in y]
    numerator = sum([sub_x[i]*sub_y[i] for i in range(len(sub_x))])
    denominator = len(x)-1
    cov = numerator/denominator
    return cov

x = [12,45,23,58]
y = [52,1,35,89]
cov = covar(x, y)
print("Covariance of x and y :", cov)

Output–

Covariance of x and y : 176.5

How to count intersection between two arrays in python

Common elements can be found by using the lambda function and length can be found by using len().

a = [1,2,3,4,5]
b = [4,5,6,7,8]
c = list(filter(lambda x: x in a, b))
print(len(c))

Output–

2

How to access a dictionary of arrays in python

Dictionary of arrays can be accessed by considering values as arrays and keys as key elements.

dict_ab = {'a':[1,2,3],'b':[4,5,6]}
print(dict_ab.keys())
print(dict_ab.values())

Output–

dict_keys(['a', 'b'])
dict_values([[1, 2, 3], [4, 5, 6]])

How to split an array into k number of arrays in python

split() keyword can be used in NumPy library to split an array

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6])
k =int(input())

newarr = np.array_split(arr, k)

print(newarr)

Output-

4
[array([1, 2]), array([3, 4]), array([5]), array([6])]

How to turn an array of dictionaries into dictionary of arrays in python

It cannot be done as lists are unhashable.

How to split strings to arrays in python

Strings can be split into an array by appending each element into it

a = 'Exampleofastring'
b=[]
for i in a:
    b.append(i)

Output–

['E', 'x', 'a', 'm', 'p', 'l', 'e', 'o', 'f', 'a', 's', 't', 'r', 'i', 'n', 'g']

How to apply functions in arrays python

Arrays can be sent as parameters to a function

def fun(x):
    print(x)
arr = [1,2,3,4,5]
fun(arr)

Output–

[1, 2, 3, 4, 5]

How to delete parts of arrays in python

An element in an array can be deleted by using pop(_index_)

a = ["a", "b", "c"]
a.pop(1)
print(a)

Output–

['a', 'c']

Convert all the floats in array to integers

int() can be used for each element in the float array as follows

a = [1.2,2.3,3.4,4.5]
b=[]
for i in a:
    b.append(int(a))
print(b)

Output–

[1, 2, 3, 4]

Convert all the strings in array to integers

Strings in an array cannot be converted to an integer as both are different data types

Convert all ints in array to floats

float() can be used for each element in the integer array as follows

a = [1,2,3,4]
b=[]
for i in a:
    b.append(float(a))
print(b)

Output–

[1.0, 2.0, 3.0, 4.0]

Convert all array of integers to strings

append() keyword can be used to convert an integer array into a string

a = [1,2,3,4,5]
b=''
for i  in a:
    b.append(i)

Output–

'12345'