Python List

A list in Python is used to store the sequence of various types of data. Python lists are mutable
type its mean we can modify its element after it created. However, Python consists of six data-
types that are capable to store the sequences, but the most common and reliable type is the list.

A list can be defined as a collection of values or items of different types. The items in the list are
separated with the comma (,) and enclosed with the square brackets [].

A list can be define as below

1. L1 = ["John", 102, "USA"]    
2. L2 = [1, 2, 3, 4, 5, 6]   

IIf we try to print the type of L1, L2, and L3 using type() function then it will come out to be a
list.

1. print(type(L1))  
2. print(type(L2))  

Output:

<class 'list'>
<class 'list'>

Characteristics of Lists

The list has the following characteristics:

 The lists are ordered.

 The element of the list can access by index.
 The lists are the mutable type.
 The lists are mutable types.
 A list can store the number of various elements.

Let's check the first statement that lists are the ordered.

1. a = [1,2,"Peter",4.50,"Ricky",5,6]  
2. b = [1,2,5,"Peter",4.50,"Ricky",6]  
3. a ==b  

Output:

False
Both lists have consisted of the same elements, but the second list changed the index position of
the 5th element that violates the order of lists. When compare both lists it returns the false.

Lists maintain the order of the element for the lifetime. That's why it is the ordered collection of
objects.

1. a = [1, 2,"Peter", 4.50,"Ricky",5, 6]  
2. b = [1, 2,"Peter", 4.50,"Ricky",5, 6]  
3. a == b  

Output:

True

Let's have a look at the list example in detail.

1. emp = ["John", 102, "USA"]     
2. Dep1 = ["CS",10]  
3. Dep2 = ["IT",11]    
4. HOD_CS = [10,"Mr. Holding"]    
5. HOD_IT = [11, "Mr. Bewon"]    
6. print("printing employee data...")    
7. print("Name : %s, ID: %d, Country: %s"%(emp[0],emp[1],emp[2]))    
8. print("printing departments...")   
9. print("Department 1:\nName: %s, ID: %d\nDepartment 2:\nName: %s, ID: %s"%
(Dep1[0],Dep2[1],Dep2[0],Dep2[1]))    
10. print("HOD Details ....")    
11. print("CS HOD Name: %s, Id: %d"%(HOD_CS[1],HOD_CS[0]))    
12. print("IT HOD Name: %s, Id: %d"%(HOD_IT[1],HOD_IT[0]))    
13. print(type(emp),type(Dep1),type(Dep2),type(HOD_CS),type(HOD_IT))  

Output:

printing employee data...

Name : John, ID: 102, Country: USA
printing departments...
Department 1:
Name: CS, ID: 11
Department 2:
Name: IT, ID: 11
HOD Details ....
CS HOD Name: Mr. Holding, Id: 10
IT HOD Name: Mr. Bewon, Id: 11
<class 'list'> <class 'list'> <class 'list'> <class 'list'> <class 'list'>

In the above example, we have created the lists which consist of the employee and department
details and printed the corresponding details. Observe the above code to understand the concept
of the list better.
List indexing and splitting
The indexing is processed in the same way as it happens with the strings. The elements of the list
can be accessed by using the slice operator [].

The index starts from 0 and goes to length - 1. The first element of the list is stored at the 0th
index, the second element of the list is stored at the 1st index, and so on.

We can get the sub-list of the list using the following syntax.

1. list_varible(start:stop:step)  

 The start denotes the starting index position of the list.

 The stop denotes the last index position of the list.
 The step is used to skip the nth element within a start:stop

Consider the following example:

1. list = [1,2,3,4,5,6,7]  
2. print(list[0])  
3. print(list[1])  
4. print(list[2])  
 5. print(list[3])  
6. # Slicing the elements  
7. print(list[0:6])  
8. # By default the index value is 0 so its starts from the 0th element and go for index -1.  
9. print(list[:])  
10. print(list[2:5])  
11. print(list[1:6:2])  

Output:

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

Unlike other languages, Python provides the flexibility to use the negative indexing also. The
negative indices are counted from the right. The last element (rightmost) of the list has the index
-1; its adjacent left element is present at the index -2 and so on until the left-most elements are
encountered.

Let's have a look at the following example where we will use negative indexing to access the
elements of the list.

1. list = [1,2,3,4,5]  
2. print(list[-1])  
3. print(list[-3:])  
4. print(list[:-1])  
5. print(list[-3:-1])  

Output:

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

As we discussed above, we can get an element by using negative indexing. In the above code, the
first print statement returned the rightmost element of the list. The second print statement
returned the sub-list, and so on.

Updating List values

Lists are the most versatile data structures in Python since they are mutable, and their values can
be updated by using the slice and assignment operator.

Python also provides append() and insert() methods, which can be used to add values to the list.

Consider the following example to update the values inside the list.

1. list = [1, 2, 3, 4, 5, 6]     
2. print(list)     
3. # It will assign value to the value to the second index   
4. list[2] = 10   
5. print(list)    
6. # Adding multiple-element   
7. list[1:3] = [89, 78]     
8. print(list)   
9. # It will add value at the end of the list  
10. list[-1] = 25  
11. print(list)  

Output:

[1, 2, 3, 4, 5, 6]
[1, 2, 10, 4, 5, 6]
[1, 89, 78, 4, 5, 6]
[1, 89, 78, 4, 5, 25]

The list elements can also be deleted by using the del keyword. Python also provides us the
remove() method if we do not know which element is to be deleted from the list.

Consider the following example to delete the list elements.

1. list = [1, 2, 3, 4, 5, 6]     
2. print(list)     
3. # It will assign value to the value to second index   
4. list[2] = 10   
5. print(list)    
6. # Adding multiple element   
 7. list[1:3] = [89, 78]     
8. print(list)   
9. # It will add value at the end of the list  
10. list[-1] = 25  
11. print(list)  

Output:

[1, 2, 3, 4, 5, 6]
[1, 2, 10, 4, 5, 6]
[1, 89, 78, 4, 5, 6]
[1, 89, 78, 4, 5, 25]

Python List Operations

The concatenation (+) and repetition (*) operators work in the same way as they were working
with the strings.

Let's see how the list responds to various operators.

1. Consider a Lists l1 = [1, 2, 3, 4], and l2 = [5, 6, 7, 8] to perform operation.  

Operator Description Example

The repetition operator enables the list elements to L1*2 = [1, 2, 3, 4, 1,
Repetition 2, 3, 4]
be repeated multiple times.
It concatenates the list mentioned on either side of l1+l2 = [1, 2, 3, 4,
Concatenation 5, 6, 7, 8]
the operator.
It returns true if a particular item exists in a print(2 in l1) prints
Membership True.
particular list otherwise false.
for i in l1:
print(i)
Output
Iteration The for loop is used to iterate over the list elements. 1
2
3
4
Length It is used to get the length of the list len(l1) = 4

Iterating a List
A list can be iterated by using a for - in loop. A simple list containing four strings, which can be
iterated as follows.

1. list = ["John", "David", "James", "Jonathan"]    
2. for i in list:   
 3.     # The i variable will iterate over the elements of the List and contains each element in 
each iteration.     
4.     print(i)  

Output:

John
David
James
Jonathan

Adding elements to the list

Python provides append() function which is used to add an element to the list. However, the
append() function can only add value to the end of the list.

Consider the following example in which, we are taking the elements of the list from the user
and printing the list on the console.

1. #Declaring the empty list  
2. l =[]  
3. #Number of elements will be entered by the user    
4. n = int(input("Enter the number of elements in the list:"))  
5. # for loop to take the input  
6. for i in range(0,n):     
7.     # The input is taken from the user and added to the list as the item  
8.     l.append(input("Enter the item:"))     
9. print("printing the list items..")   
10. # traversal loop to print the list items    
11. for i in l:   
12.     print(i, end = "  ")     

Output:

Enter the number of elements in the list:5

Enter the item:25
Enter the item:46
Enter the item:12
Enter the item:75
Enter the item:42
printing the list items
25 46 12 75 42

Removing elements from the list

Python provides the remove() function which is used to remove the element from the list.
Consider the following example to understand this concept.
Example -

1. list = [0,1,2,3,4]     
2. print("printing original list: ");    
3. for i in list:    
4.     print(i,end=" ")    
5. list.remove(2)    
6. print("\nprinting the list after the removal of first element...")    
7. for i in list:    
8.     print(i,end=" ")  

Output:

printing original list:

0 1 2 3 4
printing the list after the removal of first element...
0 1 3 4

Python List Built-in functions

Python provides the following built-in functions, which can be used with the lists.

S Function Description Example

N
1 cmp(list1, It compares the elements of This method is not used in the Python 3
list2) both the lists. and the above versions.
2 len(list) It is used to calculate the L1 = [1,2,3,4,5,6,7,8]
print(len(L1))
length of the list.
8
3 max(list) It returns the maximum L1 = [12,34,26,48,72]
print(max(L1))
element of the list. 72
4 min(list) It returns the minimum L1 = [12,34,26,48,72]
print(min(L1))
element of the list.
12
5 list(seq) It converts any sequence to str = "Johnson"
s = list(str)
the list. print(type(s))
<class list>

Let's have a look at the few list examples.

Example: 1- Write the program to remove the duplicate element of the list.

1. list1 = [1,2,2,3,55,98,65,65,13,29]  
2. # Declare an empty list that will store unique values  
3. list2 = []  
4. for i in list1:  
5.     if i not in list2:  
 6.         list2.append(i)  
7. print(list2)  

Output:

[1, 2, 3, 55, 98, 65, 13, 29]

Example:2- Write a program to find the sum of the element in the list.

1. list1 = [3,4,5,9,10,12,24]  
2. sum = 0  
3. for i in list1:  
4.     sum = sum+i      
5. print("The sum is:",sum)  

Output:

The sum is: 67

Example: 3- Write the program to find the lists consist of at least one common element.

1. list1 = [1,2,3,4,5,6]  
2. list2 = [7,8,9,2,10]  
3. for x in list1:  
4.     for y in list2:  
5.         if x == y:  
6.             print("The common element is:",x)  

Python Tuple
Python Tuple is used to store the sequence of immutable Python objects. The tuple is similar to
lists since the value of the items stored in the list can be changed, whereas the tuple is
immutable, and the value of the items stored in the tuple cannot be changed.

Creating a tuple
A tuple can be written as the collection of comma-separated (,) values enclosed with the small ()
brackets. The parentheses are optional but it is good practice to use. A tuple can be defined as
follows.

1. T1 = (101, "Peter", 22)    
2. T2 = ("Apple", "Banana", "Orange")     
3. T3 = 10,20,30,40,50  
4.   
5. print(type(T1))  
 6. print(type(T2))  
7. print(type(T3))  

Output:

<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
Note: The tuple which is created without using parentheses is also known as tuple packing.

An empty tuple can be created as follows.

T4 = ()

Creating a tuple with single element is slightly different. We will need to put comma after the
element to declare the tuple.

1. tup1 = ("JavaTpoint")  
2. print(type(tup1))  
3. #Creating a tuple with single element   
4. tup2 = ("JavaTpoint",)  
5. print(type(tup2))  

Output:

<class 'str'>
<class 'tuple'>

A tuple is indexed in the same way as the lists. The items in the tuple can be accessed by using
their specific index value.

Consider the following example of tuple:

Example - 1

1. tuple1 = (10, 20, 30, 40, 50, 60)    
2. print(tuple1)    
3. count = 0    
4. for i in tuple1:    
5.     print("tuple1[%d] = %d"%(count, i))   
6.     count = count+1  

Output:

(10, 20, 30, 40, 50, 60)

tuple1[0] = 10
tuple1[1] = 20
tuple1[2] = 30
tuple1[3] = 40
tuple1[4] = 50
tuple1[5] = 60

Basic Tuple operations

The operators like concatenation (+), repetition (*), Membership (in) works in the same way as
they work with the list.

Where use tuple?

Using tuple instead of list is used in the following scenario.

1. Using tuple instead of list gives us a clear idea that tuple data is constant and must not be
changed.

2. Tuple can simulate a dictionary without keys. Consider the following nested structure, which
can be used as a dictionary.

Python Dictionary
Python Dictionary is used to store the data in a key-value pair format. The dictionary is the data
type in Python, which can simulate the real-life data arrangement where some specific value
exists for some particular key. It is the mutable data-structure. The dictionary is defined into
element Keys and values.

 Keys must be a single element

 Value can be any type such as list, tuple, integer, etc.

In other words, we can say that a dictionary is the collection of key-value pairs where the value
can be any Python object. In contrast, the keys are the immutable Python object, i.e., Numbers,
string, or tuple.

Creating the dictionary

The dictionary can be created by using multiple key-value pairs enclosed with the curly brackets
{}, and each key is separated from its value by the colon (:).The syntax to define the dictionary is
given below.

Syntax:

1. Dict = {"Name": "Tom", "Age": 22}    
In the above dictionary Dict, The keys Name and Age are the string that is an immutable object.

Let's see an example to create a dictionary and print its content.

1. Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}    
2. print(type(Employee))    
3. print("printing Employee data .... ")    
4. print(Employee)    

Output

<class 'dict'>
Printing Employee data ....
{'Name': 'John', 'Age': 29, 'salary': 25000, 'Company': 'GOOGLE'}

Python provides the built-in function dict() method which is also used to create dictionary. The
empty curly braces {} is used to create empty dictionary.

1. # Creating an empty Dictionary   
2. Dict = {}   
3. print("Empty Dictionary: ")   
4. print(Dict)   
5.   
6. # Creating a Dictionary   
7. # with dict() method   
8. Dict = dict({1: 'Java', 2: 'T', 3:'Point'})   
9. print("\nCreate Dictionary by using  dict(): ")   
10. print(Dict)   
11.   
12. # Creating a Dictionary   
13. # with each item as a Pair   
14. Dict = dict([(1, 'Devansh'), (2, 'Sharma')])   
15. print("\nDictionary with each item as a pair: ")   
16. print(Dict)  

Output:

Empty Dictionary:
{}

Create Dictionary by using dict():

{1: 'Java', 2: 'T', 3: 'Point'}

Dictionary with each item as a pair:

{1: 'Devansh', 2: 'Sharma'}

Accessing the dictionary values

We have discussed how the data can be accessed in the list and tuple by using the indexing.

However, the values can be accessed in the dictionary by using the keys as keys are unique in the
dictionary.

The dictionary values can be accessed in the following way.

1. Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}  
2. print(type(Employee))  
3. print("printing Employee data .... ")  
4. print("Name : %s" %Employee["Name"])  
5. print("Age : %d" %Employee["Age"])  
6. print("Salary : %d" %Employee["salary"])  
7. print("Company : %s" %Employee["Company"])  

Output:

<class 'dict'>
printing Employee data ....
Name : John
Age : 29
Salary : 25000
Company : GOOGLE

Python provides us with an alternative to use the get() method to access the dictionary values. It
would give the same result as given by the indexing.

Adding dictionary values

The dictionary is a mutable data type, and its values can be updated by using the specific keys.
The value can be updated along with key Dict[key] = value. The update() method is also used to
update an existing value.

Note: If the key-value already present in the dictionary, the value gets updated. Otherwise, the
new keys added in the dictionary.

Let's see an example to update the dictionary values.

Example - 1:

1. # Creating an empty Dictionary   
2. Dict = {}   
3. print("Empty Dictionary: ")   
4. print(Dict)   
5.     
6. # Adding elements to dictionary one at a time   
7. Dict[0] = 'Peter'  
 8. Dict[2] = 'Joseph'  
9. Dict[3] = 'Ricky'  
10. print("\nDictionary after adding 3 elements: ")   
11. print(Dict)   
12.     
13. # Adding set of values    
14. # with a single Key   
15. # The Emp_ages doesn't exist to dictionary  
16. Dict['Emp_ages'] = 20, 33, 24  
17. print("\nDictionary after adding 3 elements: ")   
18. print(Dict)   
19.     
20. # Updating existing Key's Value   
21. Dict[3] = 'JavaTpoint'  
22. print("\nUpdated key value: ")   
23. print(Dict)    

Output:

Empty Dictionary:
{}

Dictionary after adding 3 elements:

{0: 'Peter', 2: 'Joseph', 3: 'Ricky'}

Dictionary after adding 3 elements:

{0: 'Peter', 2: 'Joseph', 3: 'Ricky', 'Emp_ages': (20, 33, 24)}

Updated key value:

{0: 'Peter', 2: 'Joseph', 3: 'JavaTpoint', 'Emp_ages': (20, 33, 24)}

Example - 2:

1. Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}    
2. print(type(Employee))    
3. print("printing Employee data .... ")    
4. print(Employee)    
5. print("Enter the details of the new employee....");    
6. Employee["Name"] = input("Name: ");    
7. Employee["Age"] = int(input("Age: "));    
8. Employee["salary"] = int(input("Salary: "));    
9. Employee["Company"] = input("Company:");    
10. print("printing the new data");    
11. print(Employee)    

Output:

Empty Dictionary:
{}
Dictionary after adding 3 elements:
{0: 'Peter', 2: 'Joseph', 3: 'Ricky'}

Dictionary after adding 3 elements:

{0: 'Peter', 2: 'Joseph', 3: 'Ricky', 'Emp_ages': (20, 33, 24)}

Updated key value:

{0: 'Peter', 2: 'Joseph', 3: 'JavaTpoint', 'Emp_ages': (20, 33, 24)}

Deleting elements using del keyword

The items of the dictionary can be deleted by using the del keyword as given below.

1. Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}    
2. print(type(Employee))    
3. print("printing Employee data .... ")    
4. print(Employee)    
5. print("Deleting some of the employee data")     
6. del Employee["Name"]    
7. del Employee["Company"]    
8. print("printing the modified information ")    
9. print(Employee)    
10. print("Deleting the dictionary: Employee");    
11. del Employee    
12. print("Lets try to print it again ");    
13. print(Employee)    

Output:

<class 'dict'>
printing Employee data ....
{'Name': 'John', 'Age': 29, 'salary': 25000, 'Company': 'GOOGLE'}
Deleting some of the employee data
printing the modified information
{'Age': 29, 'salary': 25000}
Deleting the dictionary: Employee
Lets try to print it again
NameError: name 'Employee' is not defined

The last print statement in the above code, it raised an error because we tried to print the
Employee dictionary that already deleted.

 Using pop() method

The pop() method accepts the key as an argument and remove the associated value. Consider the
following example.

1. # Creating a Dictionary   
 2. Dict = {1: 'JavaTpoint', 2: 'Peter', 3: 'Thomas'}   
3. # Deleting a key    
4. # using pop() method   
5. pop_ele = Dict.pop(3)   
6. print(Dict)  

Output:

{1: 'JavaTpoint', 2: 'Peter'}

Python also provides a built-in methods popitem() and clear() method for remove elements from
the dictionary. The popitem() removes the arbitrary element from a dictionary, whereas the
clear() method removes all elements to the whole dictionary.

Iterating Dictionary
A dictionary can be iterated using for loop as given below.

Example 1

# for loop to print all the keys of a dictionary

1. Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}    
2. for x in Employee:    
3.     print(x)  

Output:

Name
Age
salary
Company

Example 2

#for loop to print all the values of the dictionary

1. Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}    
2. for x in Employee:    
3.     print(Employee[x])  

Output:

John
29
25000
GOOGLE
Example - 3

#for loop to print the values of the dictionary by using values() method.

1. Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}    
2. for x in Employee.values():    
3.     print(x)  

Output:

John
29
25000
GOOGLE

Example 4

#for loop to print the items of the dictionary by using items() method.

1. Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}    
2. for x in Employee.items():    
3.     print(x)  

Output:

('Name', 'John')
('Age', 29)
('salary', 25000)
('Company', 'GOOGLE')

Properties of Dictionary keys

1. In the dictionary, we cannot store multiple values for the same keys. If we pass more than one
value for a single key, then the value which is last assigned is considered as the value of the key.

Consider the following example.

1. Employee={"Name":"John","Age":29,"Salary":25000,"Company":"GOOGLE","Name":"
John"}    
2. for x,y in Employee.items():    
3.     print(x,y)    

Output:

Name John
Age 29
Salary 25000
Company GOOGLE
2. In python, the key cannot be any mutable object. We can use numbers, strings, or tuples as the
key, but we cannot use any mutable object like the list as the key in the dictionary.

Consider the following example.

1. Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE",
[100,201,301]:"Department ID"}    
2. for x,y in Employee.items():    
3.     print(x,y)    

Output:

Traceback (most recent call last):

File "dictionary.py", line 1, in
Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE",
[100,201,301]:"Department ID"}
TypeError: unhashable type: 'list'

Built-in Dictionary functions

The built-in python dictionary methods along with the description are given below.

S Function Description
N
1 cmp(dict1, It compares the items of both the dictionary and returns true if the first
dict2) dictionary values are greater than the second dictionary, otherwise it
returns false.
2 len(dict) It is used to calculate the length of the dictionary.
3 str(dict) It converts the dictionary into the printable string representation.
4 type(variable) It is used to print the type of the passed variable.

Built-in Dictionary methods

The built-in python dictionary methods along with the description are given below.

S Method Description
N
1 dic.clear() It is used to delete all the items of the dictionary.
2 dict.copy() It returns a shallow copy of the dictionary.
3 dict.fromkeys(iterable, value = Create a new dictionary from the iterable with the
None, /) values equal to value.
4 dict.get(key, default = "None") It is used to get the value specified for the passed
key.
5 dict.has_key(key) It returns true if the dictionary contains the specified
key.
6 dict.items() It returns all the key-value pairs as a tuple.
7 dict.keys() It returns all the keys of the dictionary.
8 dict.setdefault(key,default= It is used to set the key to the default value if the key
"None") is not specified in the dictionary
9 dict.update(dict2) It updates the dictionary by adding the key-value
pair of dict2 to this dictionary.
10 dict.values() It returns all the values of the dictionary.
11 len()
12 popItem()
13 pop()
14 count()
15 index()