ST.

ANDREWS INSTITUTE
OF TECHNOLOGY & MANAGEMENT

Gurgaon Delhi (NCR)

Approved by AICTE, Govt. of India, New Delhi affiliated to
Maharshi Dayanand University
‘A’ Grade State University, accredited by NAAC

Session: 2024 – 2025

Bachelor of Technology

Computer Science & Technology

A Practical File

Python Programming Lab

Subject Code-LC-CSE-215G

Submitted To: Submitted

by: NAME:
(Assistant Professor) SEM:

ROLL

NO.:
 St. Andrews Institute of Technology &
Management, Gurugram
Department of……………………………
Practical Lab Evaluation Sheet

Practical Viva- Remarks

Attendanc Practica Overal
S.No Program Date CO Performe Voce &
e (05) l File l (25)
d (10) (05) (05) Signatur
e
1 Compute the GCD of CO
two numbers. 1
2 Find the square root CO
of a number (Newton 1
‘s method)
3 Exponentiation CO
(power of a number) 4
4 Find the maximum of CO
a list of numbers 4
5 Linear search and CO
Binary search 2
6 Selection sort, CO
Insertion sort 2
7 Merge sort CO
2
8 First n prime CO
numbers 4
9 Multiply matrices CO
3
10 Programs that take CO
command line 4
arguments (word
count)
11 Find the most CO
frequent words in a 1
text read
from a file
12 Simulate elliptical CO
orbits in Pygame 3
13 Simulate bouncing CO
ball using Pygame 3

Average Marks

Approved & Verified by (Faculty Name) (Faculty Sign.)

 ⮚ Program 1: Compute the GCD of two numbers.

SOURCE CODE
import math
def compute_gcd(a, b):
gcd_value = math.gcd(a, b)
return gcd_value
# Example numbers
num1 = 60
num2 = 48
gcd_result = compute_gcd(num1, num2)
print(f"The GCD of {num1} and {num2} is: {gcd_result}")

OUTPUT
Program 2: Find the square root of a number Newton‘s method)

SOURCE CODE

def sqrt_newton(N, tolerance=1e-6, max_iterations=1000):

x = N / 2 if N > 1 else N

for _ in range(max_iterations):

x_next = (x + N / x) / 2

if abs(x_next - x) < tolerance:

return x_next

x = x_next

return x

N = 25

result = sqrt_newton(N)

print(f"The square root of {N} is approximately: {result}")

OUTPUT
⮚ Program 3: Exponentiation (power of a number)

SOURCE CODE

base = 8

exponent = 3

result = pow(base, exponent)

print(result) # Output: 512

OUTPUT
 ⮚ Program 4: Find the maximum of a list of numbers

SOURCE CODE

numbers = [15,78,89,58,45]

numbers.sort()

max_value = numbers[-1]

print("The maximum value is:", max_value)

OUTPUT
 ⮚ Program 5: Linear search and Binary search

LINEAR SEARCH
SOURCE CODE

def linear_search(arr, target):

for i in range(len(arr)):

if arr[i] == target:

return i

return -1

arr = [37, 89, 45, 78, 25, 14]

target = 78

result = linear_search(arr, target)

if result != -1:

print(f"Element is present at index {result}")

else:

print("Target not found")

OUTPUT
BINARY SEARCH
SOURCE CODE
def binary_search(arr, target):

left, right = 0, len(arr) - 1

while left <= right:

mid = left + (right - left) // 2

if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1

return -1

arr = [14,69,56,15,69,69]
target = 69

result = binary_search(arr, target)

if result != -1:
print(f"Target found at index: {result}")
else:
print("Target not found")

OUTPUT
 ⮚ Program 6: Selection sort, Insertion sort

SELECTION SORT
SOURCE CODE

def selection_sort(arr):
for i in range(len(arr)):
min_index = i
for j in range(i + 1, len(arr)):
if arr[j] < arr[min_index]:
min_index = j

arr[i], arr[min_index] = arr[min_index], arr[i]

arr = [64, 15, 5, 89, 8]

selection_sort(arr)
print("Sorted array:", arr)

OUTPUT
 INSERTION SORT
SOURCE CODE
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j=i-1
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1

arr[j + 1] = key

arr = [65,78,98,91,12,8]
insertion_sort(arr)
print("Sorted array:", arr)

OUTPUT
 ⮚ Program 7: Merge sort
SOURCE CODE
def merge_sort(arr):
if len(arr) <= 1:
return arr

mid = len(arr) // 2

left_half = merge_sort(arr[:mid])
right_half = merge_sort(arr[mid:])

return merge(left_half, right_half)

def merge(left, right):

result = []
i=j=0

while i < len(left) and j < len(right):

if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1

result.extend(left[i:])
result.extend(right[j:])

return result

# Example usage:
arr = [38, 27, 43, 3, 9, 82, 10]
sorted_arr = merge_sort(arr)
print("Sorted array:", sorted_arr)

OUTPUT
⮚ Program 8: First n prime numbers

SOURCE CODE

def is_prime(num):

if num <= 1:

return False

for i in range(2, int(num**0.5) + 1):

if num % i == 0:

return False

return True

def first_n_primes(n):

primes = []

num = 2

while len(primes) < n:

if is_prime(num):

primes.append(num)

num += 1

return primes

n = 10

print(first_n_primes(n))

OUTPUT
⮚ Program 9: Multiply matrices

SOURCE CODE

def multiply_matrices(A, B):

m = len(A)

n = len(A[0])

p = len(B[0])

C = [[0] * p for _ in range(m)]

for i in range(m):

for j in range(p):

for k in range(n):

C[i][j] += A[i][k] * B[k][j]

return C

A = [[1, 2, 3],

[4, 5, 6]]

B = [[7, 8],

[9, 10],

[11, 12]]

C = multiply_matrices(A, B)

for row in C:

print(row)

OUTPUT
⮚ Program 10: Programs that take command line arguments (word
count)
SOURCE CODE

import sys

from collections import Counter

import string

# Function to count the frequency of words in command line arguments

def word_count_from_args():

# Check if we have at least one argument (besides the script name)

if len(sys.argv) < 2:

print("Please provide some text as command line arguments.")

return

# Combine all the command line arguments into a single string (excluding the script
name)

input_text = " ".join(sys.argv[1:]).lower() # Join all arguments and convert to

lowercase

# Remove punctuation from the text

translator = str.maketrans('', '', string.punctuation)

cleaned_text = input_text.translate(translator)

# Split the cleaned text into words

words = cleaned_text.split()

# Count the frequency of each word using Counter

word_counts = Counter(words)

# Display the word counts

print("Word counts:")
 for word, count in word_counts.items():

print(f"{word}: {count}")

# Run the program

if __name__ == "__main__":

word_count_from_args()

AND Save the Python code in this file word_count.py.

OUTPUT
⮚ Program 11: Find the most frequent words in a text read from a
file
SOURCE CODE

import string

from collections import Counter

# Function to read the text from the file and find the most frequent words

def find_most_frequent_words(filename, top_n=10):

try:

# Step 1: Read the file

with open(filename, 'r') as file:

text = file.read().lower() # Read and convert the text to lowercase

except FileNotFoundError:

print(f"The file {filename} was not found.")

return

# Step 2: Remove punctuation using translate

translator = str.maketrans('', '', string.punctuation)

text_cleaned = text.translate(translator)

# Step 3: Split the cleaned text into words

words = text_cleaned.split()

# Step 4: Count the frequency of each word using Counter

word_counts = Counter(words)

# Step 5: Get the most common words

most_common = word_counts.most_common(top_n)

# Step 6: Display the results

 print(f"The {top_n} most frequent words in the text are:")

for word, count in most_common:

print(f"{word}: {count}")

# Example usage

filename = 'sample_text.txt' # Change this to your text file path

find_most_frequent_words(filename, top_n=10)

AND text file (sample_text.txt)

Python is a great programming language. Python is easy to learn, and Python has a
rich ecosystem.

Python is used for web development, data analysis, artificial intelligence, and more.

OUTPUT
⮚ Program 12: Simulate elliptical orbits in Pygame

SOURCE CODE

import pygame

import math

import sys

# Initialize Pygame

pygame.init()

# Constants

WIDTH, HEIGHT = 800, 600 # Screen dimensions

FPS = 60 # Frames per second

WHITE = (255, 255, 255)

SUN_COLOR = (255, 255, 0)

PLANET_COLOR = (0, 0, 255)

ORBIT_COLOR = (200, 200, 200)

# Ellipse parameters

a = 300 # Semi-major axis (horizontal)

b = 200 # Semi-minor axis (vertical)

# Sun parameters (focus)

sun_pos = (WIDTH // 2, HEIGHT // 2) # Sun at the center

# Planet parameters

planet_radius = 10 # Radius of the planet

planet_angle = 0 # Starting angle

# Create the Pygame window

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Elliptical Orbit Simulation")

# Simulation loop

clock = pygame.time.Clock()

while True:

for event in pygame.event.get():

if event.type == pygame.QUIT:

pygame.quit()

sys.exit()

# Calculate the position of the planet

planet_x = sun_pos[0] + a * math.cos(planet_angle) # Elliptical X position

planet_y = sun_pos[1] + b * math.sin(planet_angle) # Elliptical Y position

# Update the angle for the next frame (simulate constant angular velocity)

planet_angle += 0.01 # This value controls the speed of the orbit

# Clear the screen

screen.fill(WHITE)

# Draw the orbit (ellipse)

pygame.draw.ellipse(screen, ORBIT_COLOR, (sun_pos[0] - a, sun_pos[1] - b,

2 * a, 2 * b), 1)
 # Draw the sun (focus of the ellipse)

pygame.draw.circle(screen, SUN_COLOR, sun_pos, 20)

# Draw the planet

pygame.draw.circle(screen, PLANET_COLOR, (int(planet_x), int(planet_y)),

planet_radius)

# Update the display

pygame.display.flip()

# Maintain the framerate

clock.tick(FPS)

OUTPUT
⮚ Program 13: Simulate bouncing ball using Pygame

SOURCE CODE

import pygame

import sys

# Initialize Pygame

pygame.init()

# Constants

WIDTH, HEIGHT = 800, 600 # Screen dimensions

BALL_RADIUS = 20 # Radius of the ball

BALL_COLOR = (255, 0, 0) # Color of the ball (Red)

BACKGROUND_COLOR = (255, 255, 255) # Background color (White)

FPS = 60 # Frames per second

# Gravity constant

GRAVITY = 0.5 # Affects the ball's downward acceleration

# Create the Pygame window

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Bouncing Ball Simulation")

# Ball initial parameters

ball_x = WIDTH // 2 # Start at the center of the screen

ball_y = HEIGHT // 2

ball_velocity_x = 4 # Horizontal velocity (px per frame)

ball_velocity_y = 0 # Initial vertical velocity (starts at 0)

bounce_damping = 0.8 # Reduces velocity when bouncing to simulate

energy loss

# Simulation loop

clock = pygame.time.Clock()

while True:

for event in pygame.event.get():

if event.type == pygame.QUIT:

pygame.quit()

sys.exit()

# Update ball's vertical velocity with gravity

ball_velocity_y += GRAVITY

# Update the ball's position based on its velocity

ball_x += ball_velocity_x

ball_y += ball_velocity_y

# Ball collision with the left and right walls (horizontal boundaries)

if ball_x - BALL_RADIUS < 0 or ball_x + BALL_RADIUS > WIDTH:

ball_velocity_x = -ball_velocity_x # Reverse the horizontal velocity

# Ball collision with the top wall

if ball_y - BALL_RADIUS < 0:

ball_velocity_y = -ball_velocity_y # Reverse the vertical velocity

 # Ball collision with the floor (bottom of the screen)

if ball_y + BALL_RADIUS > HEIGHT:

ball_y = HEIGHT - BALL_RADIUS # Keep the ball on the floor

ball_velocity_y = -ball_velocity_y * bounce_damping # Reverse the

velocity and apply damping

# Fill the screen with the background color

screen.fill(BACKGROUND_COLOR)

# Draw the ball (circle)

pygame.draw.circle(screen, BALL_COLOR, (ball_x, ball_y),

BALL_RADIUS)

# Update the display

pygame.display.flip()

# Maintain the framerate

clock.tick(FPS)

OUTPUT