Two dimensional array is an array within an array. It is an array of arrays. In this type of array the position of an data element is referred by two indices instead of one. So it represents a table with rows an dcolumns of data.
In the below example of a two dimensional array, observer that each array element itself is also an array.
Consider the example of recording temperatures 4 times a day, every day. Some times the recording instrument may be faulty and we fail to record data. Such data for 4 days can be presented as a two dimensional array as below.
Day 1 - 11 12 5 2 Day 2 - 15 6 10 Day 3 - 10 8 12 5 Day 4 - 12 15 8 6The above data can be represented as a two dimensional array as below.
T = [[11, 12, 5, 2], [15, 6,10], [10, 8, 12, 5], [12,15,8,6]]Accessing Values
The data elements in two dimesnional arrays can be accessed using two indices. One index referring to the main or parent array and another index referring to the position of the data element in the inner array.If we mention only one index then the entire inner array is printed for that index position.
Example
The example below illustrates how it works.
from array import * T = [[11, 12, 5, 2], [15, 6,10], [10, 8, 12, 5], [12,15,8,6]] print(T[0]) print(T[1][2])Output
When the above code is executed, it produces the following result −
[11, 12, 5, 2] 10To print out the entire two dimensional array we can use python for loop as shown below. We use end of line to print out the values in different rows.
Example
from array import * T = [[11, 12, 5, 2], [15, 6,10], [10, 8, 12, 5], [12,15,8,6]] for r in T: for c in r: print(c,end = " ") print()Output
When the above code is executed, it produces the following result −
11 12 5 2 15 6 10 10 8 12 5 12 15 8 6Inserting Values
We can insert new data elements at specific position by using the insert() method and specifying the index.
Example
In the below example a new data element is inserted at index position 2.
from array import * T = [[11, 12, 5, 2], [15, 6,10], [10, 8, 12, 5], [12,15,8,6]] T.insert(2, [0,5,11,13,6]) for r in T: for c in r: print(c,end = " ") print()Output
When the above code is executed, it produces the following result −
11 12 5 2 15 6 10 0 5 11 13 6 10 8 12 5 12 15 8 6Updating Values
We can update the entire inner array or some specific data elements of the inner array by reassigning the values using the array index.
Example
from array import * T = [[11, 12, 5, 2], [15, 6,10], [10, 8, 12, 5], [12,15,8,6]] T[2] = [11,9] T[0][3] = 7 for r in T: for c in r: print(c,end = " ") print()Output
When the above code is executed, it produces the following result −
11 12 5 7 15 6 10 11 9 12 15 8 6Deleting the Values
We can delete the entire inner array or some specific data elements of the inner array by reassigning the values using the del() method with index. But in case you need to remove specific data elements in one of the inner arrays, then use the update process described above.
Example
from array import * T = [[11, 12, 5, 2], [15, 6,10], [10, 8, 12, 5], [12,15,8,6]] del T[3] for r in T: for c in r: print(c,end = " ") print()Output
When the above code is executed, it produces the following result −
11 12 5 2 15 6 10 10 8 12 5Python provides many ways to create 2-dimensional lists/arrays. However one must know the differences between these ways because they can create complications in code that can be very difficult to trace out. Let’s start by looking at common ways of creating 1d array of size N initialized with 0s.
Using 2D arrays/lists the right way
Method 1: Creating a 1-D list
Example 1: Creating 1d list Using Naive methods
Python3
Example 2: creating 1d list using List Comprehension
Python3
N = 5
arr = [0 for i in range(N)]
print(arr)
Explanation:
Here we are multiplying the number of rows to the empty list and hence a entire list is created with every element is zero.
Method 2 Creating a 2-D list
Example 1: Naive Method
Python3
rows, cols = (5, 5)
arr = [[0]*cols]*rows
print(arr)
Output
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]Explanation:
Here we are multiplying the number of columns and hence we are getting the 1-D list of size equal to number of columns and then multiplying it with the number of rows which results in the creation of a 2-D list.
Example 2: Using List Comprehension
Python3
rows, cols = (5, 5)
arr = [[0 for i in range(cols)] for j in range(rows)]
print(arr)
Output
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]Explanation:
Here we are basically using the concept of list comprehension and applying loop for list inside a list and hence creating a 2-D list.
Example 3: Using empty list
Python3
arr=[]
rows, cols=5,5
for i in range(rows):
col = []
for j in range(cols):
col.append(0)
arr.append(col)
print(arr)
Output
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]Explanation:
Here we are appending zeros as elements for number of columns times and then appending this 1-D list into the empty row list and hence creating the 2-D list.
Python3
rows, cols = (5, 5)
arr = [[0]*cols]*rows
arr[0][0] = 1
for row in arr:
print(row)
arr = [[0 for i in range(cols)] for j in range(rows)]
arr[0][0] = 1
for row in arr:
print(row)
Output
[1, 0, 0, 0, 0] [1, 0, 0, 0, 0] [1, 0, 0, 0, 0] [1, 0, 0, 0, 0] [1, 0, 0, 0, 0] [1, 0, 0, 0, 0] [0, 0, 0, 0, 0] [0, 0, 0, 0, 0] [0, 0, 0, 0, 0] [0, 0, 0, 0, 0]Explanation:
We expect only the first element of first row to change to 1 but the first element of every row gets changed to 1 in method 2a. This peculiar functioning is because Python uses shallow lists which we will try to understand.
In method 1a, Python doesn’t create 5 integer objects but creates only one integer object and all the indices of the array arr point to
the same int object as shown.
If we assign the 0th index to a another integer say 1, then a new integer object is created with the value of 1 and then the 0th index now points to this new int object as shown below
Similarly, when we create a 2d array as “arr = [[0]*cols]*rows” we are essentially the extending the above analogy.
- Only one integer object is created.
- A single 1d list is created and all its indices point to the same int object in point 1.
- Now, arr[0], arr[1], arr[2] …. arr[n-1] all point to the same list object above in point 2.
The above setup can be visualized in the image below.
Now lets change the first element in first row of “arr” as arr[0][0] = 1
- arr[0] points to the single list object we created we above.(Remember arr[1], arr[2] …arr[n-1] all point to the same list object too).
- The assignment of arr[0][0] will create a new int object with the value 1 and arr[0][0] will now point to this new int object.(and so will arr[1][0], arr[2][0] … arr[n-1][0])
This can be clearly seen in the below image.
So when 2d arrays are created like this, changing values at a certain row will effect all the rows since there is essentially only one integer object and only one list object being referenced by the all the rows of the array.
As you would expect, tracing out errors caused by such usage of shallow lists is difficult. Hence the better way to declare a 2d array is
Python3
rows, cols = (5, 5)
print([[0 for i in range(cols)] for j in range(rows)])
Output
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]This method creates 5 separate list objects unlike method 2a. One way to check this is using the ‘is’ operator which checks if the two operands refer to the same object.
Python3
rows, cols = (5, 5)
arr = [[0 for i in range(cols)] for j in range(rows)]
print(arr[0] is arr[1])
arr = [[0]*cols]*rows
print(arr[0] is arr[1])