17YCS514-Python Programming Laboratory

S.No Title of Experiment Date of Remarks

Conductio
n
1 Implement a Python program to
Calculate GCD of two numbers.
2 Implement a Python Program to
calculate the square root of a
number by Newton's Method.
3 Implement a Python Program to
find the largest number from a list
of numbers.
4 Implement a Python Program to
perform Liner search
5 Implement a Python Program to
perform Binary search
6 Implement a Python Program to
perform insertion sort.
7 Implement a Python Program to
perform selection sort.
8 Implement a Python program to
multiply matrices.
9 Implement a Python program to
calculate the most frequent words
in a text from a file.
10 Implement function
overloading with different
function signatures.
11 Implement concept of class,
instances and inheritance.
12 Implement internal and external
library.
13 Solve algorithmic problems by
program using different problem-
solving strategies.
14 Search content using regular
expression library in python.
17YCS514-Python Programming Laboratory
 17YCS514-Python Programming Laboratory

15 Implement Matrix multiplication

using multi-threading in python.
16 Perform Linux administration task
using python
 17YCS514-Python Programming Laboratory

EXPERIMENT 1

TITLE: Implement a Python program to Calculate GCD of two numbers.

THEORY: Greatest Common Divisor (GCD) is a mathematical term to find the

greatest common factor that can perfectly divide the two numbers. A GCD

is also known as the

Highest Common Factor (HCF). For example, the HCF/ GCD of two numbers 54

and 24 is 6. Because 6 is the largest common divisor that completely divides 54

and 24.

GCD Using gcd() Function

In python, a gcd() is an inbuilt function offered by the math module to find

the greatest common divisor of two numbers.

Syntax: gcd(a, b)

Where a and b are the two integer number passes as an argument to the function gcd().

Let's create a program to print the GCD of two number using the inbuilt function of

math.gcd() in python.

PROCEDURE / ALGORITHM / CODE:

 17YCS514-Python Programming Laboratory

RESULT / OUTPUT:

Explanation

In the above result, math.gcd() function generates the GCD of two given numbers. In

the gcd() function, a and b pass as an argument that returns the greatest common

divisor of two integer numbers, completely dividing the numbers.

 17YCS514-Python Programming Laboratory

EXPERIMENT 2

TITLE: Implement a Python Program to find the largest number from a list of numbers

THEORY: In this program, we need to find out the largest element present in the array
and display it. This can be accomplished by looping through the array from start to end
by
comparing max with all the elements of an array. If any of element is greater than max,
then store a value of the element in max. Initially, max will hold the value of the first
element. At the end of the loop, max represents the largest element in the array.

In the above array, initially, max will hold the value 25. In the 1st iteration, max will be
compared with 11, since 11 is less than max. Max will retain its value. In the next
iteration, it will be compared to 7, 7 is also less than max, no change will be made to the
max. Now, max will be compared to 75. 75 is greater than max so that max will hold the
value of 75. Continue this process until the end of the array is reached. At the end of the

loop, max will hold the largest element in the array.

ALGORITHM:

● STEP 1: Declare and initialize an array.

● STEP 2: Store first element in variable max.

● STEP 3: Loop through the array from 0 to length of the array and compare the
value of max with elements of the array.

● STEP 4: If any element is greater than max, max will hold the value of that element.

● STEP 5: At last, max will hold the largest element in the array.
 17YCS514-Python Programming Laboratory

PROCEDURE / CODE:

RESULT/OUTPUT:

Conclusion:
This program demonstrates a simple algorithm for finding the largest element in an array. By
initializing with the first element and then iterating through the array to compare each
subsequent element, the program efficiently determines the maximum value. The key
operations are the initialization of the comparison variable (max_element), the iteration
through the array, and the conditional update based on comparisons. This approach ensures
that the program runs in linear time, O(n), where n is the number of elements in the array,
making it both straightforward and efficient for finding the maximum value.
 17YCS514-Python Programming Laboratory

EXPERIMENT 3

TITLE: Implement a Python Program to perform Linear search.

THEORY: Python is one of the most popular and powerful languages. It takes a few lines to
execute the code, which makes it much user-friendly language. In this tutorial, we will learn
the linear search in Python. Searching is a technique to find the particular element is present
or not in the given list.

There are two types of searching –

● Linear Search
● Binary Search

Both techniques are widely used to search an element in the given list.

What is a Linear Search

Linear search is a method of finding elements within a list. It is also called a sequential
search. It is the simplest searching algorithm because it searches the desired element in a
sequential manner. It compares each and every element with the value that we are
searching for. If both are matched, the element is found, and the algorithm returns the key's
index position.

Concept of Linear Search

Let's understand the following steps to find the element key = 7 in the given list.

Step - 1: Start the search from the first element and Check key = 7 with each element of list x.

Step - 2: If element is found, return the index position of the key.

 17YCS514-Python Programming Laboratory

Step - 3: If element is not found, return element is not present.

Linear Search Algorithm

There is list of n elements and key value to be searched.
Below is the linear search algorithm.

1. LinearSearch(list, key)
2. for each item in the list
3. if item == value
4. return its index position
5. return -1

PROGRAM / CODE:
 17YCS514-Python Programming Laboratory

Result/Output:

Explanation:
In the above code, we have created a function linear_Search(), which takes three
arguments- list1, length of the list, and number to search. We defined for loop and
iterate each element and compare to the key value. If element is found, return the index
else return -1 which means element is not present in the list.
 17YCS514-Python Programming Laboratory

EXPERIMENT 4

TITLE: Implement a Python Program to perform Binary search

THEORY: A binary search is an algorithm to find a particular element in the

list. Suppose we have a list of thousand elements, and we need to get an
index position of a particular element. We can find the element's index
position very fast using the binary search
algorithm.

There are many searching algorithms but the binary search is most popular among them.

The elements in the list must be sorted to apply the binary search
algorithm. If elements are not sorted then sort them first.
Concept of Binary Search
In the binary search algorithm, we can find the element position using the following
methods.

● Recursive Method
● Iterative Method

The divide and conquer approach technique is followed by the recursive

method. In this method, a function is called itself again and again until it found
an element in the list.
A set of statements is repeated multiple times to find an element's index
position in the iterative method. The while loop is used for accomplish this task.
Binary search is more effective than the linear search because we don't
need to search each list index. The list must be sorted to achieve the binary
search algorithm.
Let's have a step by step implementation of binary search.

We have a sorted list of elements, and we are looking for the index position of 45.

[12, 24, 32, 39, 45, 50, 54]

So, we are setting two pointers in our list. One pointer is used to denote
the smaller value called low and the second pointer is used to denote the
highest value called high.

Next, we calculate the value of the middle element in the array.

 17YCS514-Python Programming Laboratory

1. mid = (low+high)/2
2. Here, the low is 0 and the high is 7.
3. mid = (0+7)/2
4. mid = 3 (Integer)

 Now, we will compare the searched element to the mid index value. In
this case, 32 is not equal to 45. So we need to do further comparison to
find the element.
 If the number we are searching equal to the mid. Then return mid
otherwise move to the further comparison.
 The number to be search is greater than the middle number, we
compare the n with the middle element of the elements on the
right side of mid and set low to low = mid + 1.
 Otherwise, compare the n with the middle element of the
elements on the left side of mid and set high to high = mid - 1.

LAB MANUAL : PYTHON

Repeat until the number that we are searching for is found.

PROCEDURE/CODE:
FOR ITERATIVE BINARY SEARCH METHOD:
 17YCS514-Python Programming Laboratory

Result/Output :

Explanation/Conclusion :
The binary search algorithm efficiently finds an element in a sorted list by continuously
narrowing down the search range by half. This method significantly reduces the number of
comparisons needed, making it much faster than a linear search, especially for large datasets,
with a time complexity of O(log n).

RECURSIVE BINARY SEARCH:

 17YCS514-Python Programming Laboratory

Result/Output :

Conclusion/Explanation :
This recursive binary search program efficiently locates an element in a sorted list by repeatedly
dividing the search interval in half. It checks the middle element, and if it matches the target, it
returns the index. If the target is smaller or larger, the function recursively searches the left or
right sublist, respectively. If the element is not found after all divisions, it returns `-1`. This
method is efficient, with a time complexity of O(log n), making it ideal for searching large sorted
datasets.
 17YCS514-Python Programming Laboratory

SOCSE, Sandip University, Nashik

EXPERIMENT 5
TITLE: Implement a Python Program to perform insertion sort

THEORY: The Insertion sort is a straightforward and more efficient algorithm than the
previous bubble sort algorithm. The insertion sort algorithm concept is based on the deck of
the card where we sort the playing card according to a particular card. It has many
advantages, but there are many efficient algorithms available in the data structure.

While the card-playing, we compare the hands of cards with each other. Most of the player
likes to sort the card in the ascending order so they can quickly see which combinations they
have at their disposal.

The insertion sort implementation is easy and simple because it's generally taught in the
beginning programming lesson. It is an in-place and stable algorithm that is more beneficial
for nearly-sorted or fewer elements.

The insertion sort algorithm is not so fast because of it uses nested loop for sort the

elements. Let's understand the following terms.

What is the meaning of in-place and stable?

● In-place: The in-place algorithm requires additional space without caring for the
input size of the collection. After performing the sorting, it rewrites the original
memory locations of the elements in the collection.
● Stable: The stable is a term that manages the relative order of equal objects from the
initial array.

The more important thing, the insertion sort doesn't require to know the array size in
advance and it receives the one element at a time.

The great thing about the insertion sort is if we insert the more elements to be sorted - the
algorithm arranges the in its proper place without performing the complete sort.

It is more efficient for the small (less than 10) size array. Now, let's understand the concepts
of insertion sort.

Concept Of Insertion Sort :

The array spilled virtually in the two parts in the insertion sort - An unsorted part and sorted
part.
 17YCS514-Python Programming Laboratory

The sorted part contains the first element of the array and other unsorted subpart contains
the rest of the array. The first element in the unsorted array is compared to the sorted array
so that we can place it into a proper sub-array.

It focuses on inserting the elements by moving all elements if the right-side value is smaller
than the left side.

It will repeatedly happen until the all element is inserted at correct place.

To sort the array using insertion sort below is the algorithm of insertion sort.

● Spilt a list in two parts - sorted and unsorted.

● Iterate from arr[1] to arr[n] over the given array.
● Compare the current element to the next element.
● If the current element is smaller than the next element, compare to the element
before, Move to the greater elements one position up to make space for the
swapped element.

Let's understand the following example.

We will consider the first element in the sorted array in the following array.

[10, 4, 25, 1, 5]

The first step to add 10 to the sorted subarray

[10, 4, 25, 1, 5]

Now we take the first element from the unsorted array - 4. We store this value in a new
variable temp. Now, we can see that the 10>4 then we move the 10 to the right and that
overwrite the 4 that was previously stored.

[10, 10, 25, 1, 5] (temp = 4)

Here the 4 is lesser than all elements in sorted subarray, so we insert it at the first index
position.

[4, 10, 25, 1, 5]

We have two elements in the sorted subarray.
 17YCS514-Python Programming Laboratory

SOCSE, Sandip University, Nashik

Now check the number 25. We have saved it into the temp variable. 25> 10 and also
25> 4then we put it in the third position and add it to the sorted sub array.

[4, 10, 25, 1, 5]

Again we check the number 1. We save it in temp. 1 is less than the 25. It

overwrites the 25.[4, 10, 25, 25, 5] 10>1 then it overwrites again

[4, 25, 10, 25, 5]

[25, 4, 10, 25, 5] 4>1 now put the value of temp = 1

[1, 4, 10, 25, 5]

Now, we have 4 elements in the sorted subarray. 5<25 then shift 25 to the right side and
pass
temp = 5 to the left side.

[1, 4, 10, 25, 25] put temp = 5

Now, we get the sorted array by simply putting the temp value.

[1, 4, 5, 10, 25]

The given array is sorted.

PROCEDURE/CODE:
Explanation/Conclusion :

The insertion sort algorithm sorts an array by building a sorted section from left to right.
It repeatedly takes the next element and inserts it into its correct position within the
sorted part of the array, shifting larger elements to the right as needed. This method is
simple and efficient for small or nearly sorted arrays, with a time complexity of O(n²) in
the worst case. The algorithm is stable and performs well for datasets that are already
partially sorted.
17YCS514-Python Programming Laboratory
 17YCS514-Python Programming Laboratory

Result/Output :
 17YCS514-Python Programming Laboratory

SOCSE, Sandip University, Nashik

EXPERIMENT 6
TITLE: Implement a Python Program to perform selection sort

THEORY: The selection sort algorithm sorts an array by repeatedly finding the
minimum element (considering ascending order) from unsorted part and
putting it at thebeginning. The algorithm maintains two subarrays in a given
array.
1. The subarray which is already sorted.
2. Remaining subarray which is unsorted. In every iteration of selection
sort, the minimum element (considering ascending order) from the
unsorted subarray is picked and moved to the sorted subarray.

In this algorithm, we select the smallest element from an unsorted array in each
pass and swap with the beginning of the unsorted array. This process will
continue until all the elements are placed at right place. It is simple and an in-place
comparison sorting algorithm.

Working of Selection Sort

1. The following are the steps to explain the working of thSelection

sort in Python.Let's take an unsorted array to apply the selection

sort algorithm.

[30, 10, 12, 8, 15, 1]

Step - 1: Get the length of the array.

length = len(array) → 6

Step - 2: First, we set the first element as minimum element.

Step - 3: Now compare the minimum with the second element. If the second
element is smaller than the first, we assign it as a minimum.

Again we compare the second element to the third and if the third element is smaller
than second, assign it as minimum. This process goes on until we find the last element.
 17YCS514-Python Programming Laboratory

Step - 4: After each iteration, minimum element is swapped in front of the unsorted array.

Step - 5: The second to third steps are repeated until we get the sorted array
2. Here's how the Selection Sort algorithm works step by step:

1. Initial State: The list is divided into two parts: the sorted part (initially
empty) and the unsorted part (contains all elements).
2. Find Minimum: The algorithm scans the unsorted part of the list to find the
minimum (or maximum) element.
3. Swap: Once the minimum (or maximum) element is found, it is swapped with the first
element of the unsorted portion.
4. Expand Sorted Part: The element that was swapped to the beginning of the
unsorted portion is now considered as part of the sorted portion.
5. Repeat: Steps 2-4 are repeated for the remaining unsorted portion, gradually
expanding the sorted portion and shrinking the unsorted portion.
6. Termination: The algorithm continues until the entire list is sorted, with the sorted
portion spanning the entire list and the unsorted portion becoming empty.

Selection Sort has a time complexity of O(n^2), where n is the number of elements in the
list. This makes it inefficient for large lists, and it's generally not recommended for large-
scale sorting tasks.
However, it has the advantage of requiring only a small number of swaps, making it useful in
situations where minimizing the number of swaps is important (e.g., when writing data
to flash memory).

ALGORITHM:
1. selection_sort(array)
2. repeat (0, length - 1) times
3. set the first unsorted element as the minimum
4. for each of the unsorted elements
5. if element < currentMinimum
6. set element as new minimum
7. swap minimum with first unsorted position
8. end selection_sort
9.
Explanation/Conclusion :

The selection sort algorithm sorts an array by repeatedly finding the smallest (or largest)
element from the unsorted portion and moving it to the sorted portion. It involves selecting the
minimum element and swapping it with the first unsorted element in each iteration. This

process continues until the entire array is sorted. While simple and easy to implement,
selection sort has a time complexity of O(n²), making it less efficient for large datasets
 17YCS514-Python Programming Laboratory

compared to more advanced sorting algorithms like quicksort or mergesort.

PROCEDURE/CODE :

Result/Output :
 17YCS514-Python Programming Laboratory

SOCSE, Sandip University, Nashik

EXPERIMENT 7
TITLE: Implement a Python Program to calculate the square root of a number by
Newton's Method

THEORY: Given an integer N and a tolerance level L, the task is to find the
square root of that number using Newton’s Method.
Examples:
Input: N = 16, L = 0.0001
Output: 4
42 = 16
Input: N = 327, L = 0.00001
Output: 18.0831
Newton’s Method:
Let N be any number then the square root of N can be given by the
formula: root = 0.5 * (X + (N / X)) where X is any guess which can be
assumed to be N or 1.
● In the above formula, X is any assumed square root of N and
root is the correct square root of N.
● Tolerance limit is the maximum difference between X and root allowed.

Approach: The following steps can be followed to compute the answer:

1. Assign X to the N itself.
2. Now, start a loop and keep calculating the root which will
surely move towards the correct square root of N.
3. Check for the difference between the assumed X and calculated
root, if not yet inside tolerance then update root and continue.
4. If the calculated root comes inside the tolerance allowed then
break out of the loop.
5. Print the root.

PROCEDURE/CODE :
 17YCS514-Python Programming Laboratory

Result/Output :
 17YCS514-Python Programming Laboratory

SOCSE, Sandip University, Nashik

EXPERIMENT 8

TITLE: Implement a Python program to multiply matrices

THEORY: Matrix multiplication is a binary operation that uses a pair of matrices to

produce another matrix. The elements within the matrix are multiplied according to
elementary arithmetic.
In the multiplication of two matrices, the row elements of the first matrix are
multiplied to the column elements of the second matrix.

Example: Suppose we have given following two A and B

matrices: A = [[5, 4, 3]

[2, 4, 6]
[4, 7, 9]]
And,
B = [[3, 2, 4]
[4, 3, 6]
[2, 7, 5]]

C would be the addition of above given two matrices, i.e., C = A+B, and therefore C
should be: C = [[37, 43, 59]
[34, 58, 62]
[58, 92, 103]]

As we can see that the resulting matrix C, which is also known as matrix product,
has the same number of rows as the first matrix (A matrix) and the same number of
columns as the second matrix (B matrix). We also know this type of multiplication of
matrices as dot product of matrices.
Multiplication of two matrices
Now, we will write a Python program for the multiplication of two matrices where
we perform the multiplication as we have performed in the above-given example.
We can use various methods to write a Python program like this, but in this tutorial,
we will only use the following two methods:

1. Using nested for loop method

 17YCS514-Python Programming Laboratory

2. Using nested list comprehension method

In both methods, we will write an example program to understand their
implementation for multiplying two matrices.
Method 1: Using nested for loop method:
In this method, we are going to use nested for loop on two matrices and perform
multiplication on them and store multiplication result in the third matrix as the
result value.
Method 2: Using nested list comprehension method:
In this method, we will use nested list comprehension to get the multiplication
result of two input matrices. While using the list comprehension method in the
program, we will also use 'zip in Python' on the nested list.

PROCEDURE/CODE:
USING NESTED FOR LOOP METHOD:
 17YCS514-Python Programming Laboratory

Result/Output :

USING NESTED LIST COMPREHENSION METHOD:

 17YCS514-Python Programming Laboratory

Result/Output.

SOCSE, Sandip University, Nashik

EXPERIMENT 9

TITLE: Implement a Python program to calculate the most frequent words in a text from a file.
THEORY: Data is often stored in text files, which is organized. There are many
kinds of files. Text files, music files, videos, and various word processor and
presentation documents are those we are familiar with.

Text files only contain characters whereas, all the other file formats include formatting
information that is specific to that file format. Operations performed on the data in files
include the read and write operations. To perform any operation the program
 17YCS514-Python Programming Laboratory

must open the file. The syntax to open a file is given below:

with open(«filename», «mode») as «variable»:

«block»

Though there are several ways of opening a file I prefer this way because we need
not specify the close statement at the end.

For more understanding on files go through this link

handling files Reading a file:

There are several techniques for reading files. One way is reading the overall contents of
the file into a string and we also have iterative techniques in which in each iteration
one line of text is read. We, can also read each line of text and store them all in a
list. The syntax for each technique is given below

#to read the entire contents of text into a single string

with open('file1.txt', 'r') as f:
contents = f.read()
#to read each line and store them as list
with open('file1.txt', 'r') as f:
lines = f.readlines()
#for iterative method of reading text in files
with open('planets.txt', 'r') as
f:for line in print(len(line))

As our job is to just read the contents of the file and then finding the most frequent
word in a text read from a file we have no space for the write operation. In case you
want to learn it go through this link text file in Python

finding the most frequent words from a text read from a file.
First, you have to create a text file and save the text file in the same directory where
you will save your python program. Because once you specify the file name for
opening it the
interpreter searches the file in the same directory of the program. Make sure
you have created and saved the file in proper directory.
 17YCS514-Python Programming Laboratory

The algorithm we are going to follow is quite simple first we open the file then we
read the contents we will see how many times each word is repeated and store
them in a variable called count. Then we check it with the maximum count which is
initialized as zero in the beginning. If count is less than maximum count we ignore
the word if it is equal we will
place it in a list. Otherwise, if it is greater then we clear the list and place this
word in the list.

Let us start with initializing variables and opening file

fname=input("enter file name")

count=0 #count of a specific word

maxcount=0 #maximum among the count of each words

l=[] #list to store the words with maximum count

with open(fname,'r') as f:

we have opened the file as f and we will be using f whenever we have to specify the file.

Now we have to read the contents. We have many techniques for that as we have
previously discussed. But, the thing is that we should take the most reliable one
for our task. As we are concerned with the words of the file, it would be better if
we read the entire contents. And, then we split the string into a list with the
words in the string using split method.

Reading contents:

with open(fname,'r') as f:

contents=f.read()

words=content.split()

Finding the most frequent word:

Now, we have all the words in a list we will implement the algorithm discussed early
 17YCS514-Python Programming Laboratory

count =
0; word
= "";
maxCount
= 0;
words =
[];

#Opens a file in read mode

file = open("/content/data.txt", "r")

#Gets each line till end of file is

reached for line in file:

#Splits each line into words

string =
line.lower().replace(',','').replace('.','').split(" ");
#Adding all words generated in previous step into words

for s in
string:
words.appen
d(s);

#Determine the most repeated word in a

file for i in range(0, len(words)):

count = 1;
#Count each word in the file and store it in variable

Now, we have the most frequent words in the list ‘l’ that will be printed at last.

Output:

Most repeated word: else

17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory
17YCS514-Python Programming Laboratory