×

Search anything:

# Defining 2D array in Python

#### Software Engineering Python

Open-Source Internship opportunity by OpenGenus for programmers. Apply now.

In this article, we have explored the different ways of defining a 2D array in Python. We have explored three approaches:

• Creating a List of Arrays
• Creating a List of Lists
• Creating 2D array using numpy

Some terminologies in Python:

Array: An array is a collection of homogeneous elements (i.e. belonging to the same data type) that are stored in contiguous memory locations. In Python, there is a module âarrayâ that needs to be imported to declare/use arrays.

List: A list in Python is collection of elements that can belong to different data types. So, a List can be an array if the user chooses to store only homogeneous elements in it. There is no need to explicitly import a module for declaration of Lists.

So, what are 2D arrays/lists?
2D arrays/lists can be defined as an array/list of arrays/lists. 2D arrays are also called 'Matrices'.

# Creating a List of Arrays:

Syntax of defining an array in python:

``````import array as arr    #imports array module
a = arr.array(âiâ,[1,2,3,4])  #defines a 1D array of integer type
``````

NOTE: You need to mention the data type of the elements and if an element of different data type is inserted, an exception âIncompatible data typesâ is thrown.

Letâs create a 3*3 matrix(i.e. 2D array)

``````import array as arr    #imports module
a = []    #defining an empty list
for i in range(0,3):    #i iterates from 0 to 3
row = arr.array(âiâ)    #defining an array
for j in range(0,4):    #j iterates from 0 to 4
row.append(i*4+j)   #row-wise position is appended
a.append(row)    #row array is from the end added to the list 'a'
print(a)
``````

Output: [array('i', [0, 1, 2, 3]), array('i', [4, 5, 6, 7]), array('i', [8, 9, 10, 11])]

# Creating a List of Lists:

Now, here is a better and easier way to create a 2D array.
There are different ways in which this can be done with Lists and here I will be showing 3 of them.

Method 1:
This is the most simple way.

``````rows = 3    #value of rows is defined 3
cols = 3    #value of columns is defined 3
mat = [[0]*cols]*rows  #2D list initialized with value 0 is defined
print(mat)    #contents of the 2D array 'mat' is displayed
``````

Output:
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

Method 2:

``````rows = 3    #value of rows is defined 3
cols = 3    #value of columns is defined 3
mat = [[0 for i in range(cols)] for j in range(rows)] #2D stored in 'mat'
print(mat)    #contents of the 2D array 'mat' is displayed
``````

Output:
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

Method 3:

``````rows = 3    #value of rows is defined 3
cols = 3    #value of columns is defined 3
mat=[]    #empty List is defined
for i in range(cols):    #i iterates from 0 to value 'cols'
col = []    #empty List is defined
for j in range(rows):    #j iterates from 0 to value 'rows'
col.append(0)    #0 is added to list 'col'
mat.append(col)    #List 'col' is added to List 'mat'
print(mat)    #contents of List 'mat' displayed
``````

Output:
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

# Creating 2D array using numpy:

Though we can use the List for the same purpose but itâs slow. Numpy is a pre-defined package in Python used for performing powerful mathematical operations. It provides an array object much faster than traditional Python lists.

• Using numpy.array()
``````import numpy as np

#initializing 3 different Lists
row1 = [1,2,3]
row2 = [4,5,6]
row3 = [7,8,9]

mat = np.array([row1,row2,row3])    #initializing array with 3 Lists

print(mat)    #display contents of List 'mat'
``````

Output:
[[1 2 3]
[4 5 6]
[7 8 9]]

• Using numpy.asarray()
``````#initializing 3 different Lists
import numpy as np

row1 = [1,2,3]
row2 = [4,5,6]
row3 = [7,8,9]

mat = np.asarray([row1,row2,row3])    #initializing array with 3 Lists

print(mat)    #display contents of List 'mat'
``````

Output:
[[1 2 3]
[4 5 6]
[7 8 9]]

In numpy arrays there are many functions that can be applied for mathematical computations.So, if you wish to explore more on numpy arrays you can refer to this link.

# Applications:

The applications of 2D arrays are:

• To represent images and manipulate them
• To represent any 2-D grid
• Used in programming techniques like Dynamic Programming

# Exercise Problem:

Write a program that takes the number of rows and the number of columns of the 2D array as input and then takes input row-wise and displays the 2D array as output.

# Solution:

``````rows = int(input("Enter the no. of rows:"))    #user input number of rows
cols = int(input("Enter the no. of columns:"))    #user input number of columns

mat = []    #defining empty List
print("Enter the elements row-wise:")

for i in range(rows):    #i iterates from 0 to value of 'rows'
row = []    #defining empty List
for j in range(cols):    #j iterates from 0 to value of 'cols'
row.append(int(input()))    #user input is added in List 'row'
mat.append(row)    #List 'row' is added in List 'mat'

for i in range(rows):    #i iterates from 0 to value of 'rows'
for j in range(cols):    #j iterates from 0 to value of 'cols'
print(mat[i][j], end = " ")    #display value at ith row and jth column
print()    #line change
``````

Output:
Enter the no. of rows: 2
Enter the no. of columns: 4
Enter the elements row-wise:
1
2
3
4
5
6
7
8

1 2 3 4
5 6 7 8

# Time Complexity:

Worst case time complexity: O(RC)
Average case time complexity: Î(R
C)
Best case time complexity: ÎŠ(RC)
Space complexity: Î(R
C)

Since we are iterating from column to column in every row hence the complexity is rows*columns.

NOTE: âRâ is the number of rows and âCâ is the number of columns.

Defining 2D array in Python