PROGRAM -1 : Write a python

program to print factorial of

given number.

def factorial(n):
if n == 0 or n == 1:
return 1
else:
return n * factorial(n-1)

# Input from the user

num = int(input("Enter a number: "))

# Check if the number is non-negative

if num < 0:
print("Factorial is not defined for negative
numbers.")
else:
result = factorial(num)
print(f"The factorial of {num} is: {result}")
PROGRAM -2 : Write a python
program to check if the entered
number is Armstrong number or
not.

def is_armstrong_number(number):
# Convert the number to a string to find its length
num_str = str(number)
num_digits = len(num_str)

# Calculate the sum of each digit raised to the

power of the number of digits
total = sum(int(digit) ** num_digits for digit in
num_str)

# Check if the total is equal to the original number

return total == number

# Input from the user

num = int(input("Enter a number: "))

# Check if the number is an Armstrong number

if is_armstrong_number(num):
print(f"{num} is an Armstrong number.")
else:
print(f"{num} is not an Armstrong number.")
PROGRAM -3 : Write a python
program to read a text file line
by line and display each word
separated by a # .

# Function to read a text file line by line and

display each word separated by a #
def display_words(filename):
try:
with open(filename, 'r') as file:
# Read each line in the file
for line in file:
# Split the line into words
words = line.split()

# Display each word separated by a #

formatted_line = "#".join(words)
print(formatted_line)

except FileNotFoundError:
print(f"The file '{filename}' was not found.")

# Input the filename from the user

 file_name = input("Enter the name of the text
file: ")

# Call the function to display words separated

by #
display_words(file_name)
PROGRAM -4 : Write a python
program to print Fibonacci
series upto n terms.

def fibonacci_series(n):
fib_series = [0, 1] # Initialize the series with the
first two terms

while len(fib_series) < n:

next_term = fib_series[-1] + fib_series[-2]
fib_series.append(next_term)

return fib_series

# Input from the user

n = int(input("Enter the number of terms for the
Fibonacci series: "))

# Check if n is non-negative
if n <= 0:
print("Please enter a positive integer.")
else:
result = fibonacci_series(n)
print(f"The Fibonacci series up to {n} terms is:
{result}")
PROGRAM -5 : Write a python
program to print factors of a
given number excluding 1 &
itself..

def print_factors_excluding_ends(number):
factors = []

# Loop from 2 to the square root of the

number
for i in range(2, int(number**0.5) + 1):
# Check if i is a factor of the number
if number % i == 0:
factors.append(i)
# If the factor is not equal to the
corresponding factor on the other side of the
square root
if i != number // i:
factors.append(number // i)

# Sort the factors

factors.sort()

return factors
 # Input from the user
num = int(input("Enter a number: "))

# Check if the number is positive

if num <= 0:
print("Please enter a positive integer.")
else:
result = print_factors_excluding_ends(num)
print(f"The factors of {num} (excluding 1 and
itself) are: {result}")
PROGRAM -6 : Read a text file
and display the number of
vowels/consonants/upper-
case/lower-case characters in
the file.

def count_characters(file_path):
vowels = "aeiouAEIOU"
consonants =
"bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVW
XYZ"

# Initialize counters
vowel_count = 0
consonant_count = 0
uppercase_count = 0
lowercase_count = 0

try:
with open(file_path, 'r') as file:
content = file.read()

for char in content:

if char.isalpha():
 if char in vowels:
vowel_count += 1
elif char in consonants:
consonant_count += 1

if char.isupper():
uppercase_count += 1
elif char.islower():
lowercase_count += 1

except FileNotFoundError:
print(f"The file '{file_path}' was not found.")
return

print("Character counts:")
print(f"Vowels: {vowel_count}")
print(f"Consonants: {consonant_count}")
print(f"Uppercase characters:
{uppercase_count}")
print(f"Lowercase characters:
{lowercase_count}")

# Input the filename from the user

file_path = input("Enter the path of the text file:
")

# Call the function to count characters

count_characters(file_path)
PROGRAM -7 : Write a random
number generator that
generates random numbers
between 1 and 6 (Simulates a
dice).
import random

def roll_dice():
return random.randint(1, 6)

# Input from the user (optional)

num_rolls = int(input("Enter the number of
times you want to roll the dice: "))

# Roll the dice and display the results

for _ in range(num_rolls):
result = roll_dice()
print(f"You rolled a {result}")
PROGRAM -8 : Write a python
program to check whether a
string is palindrome or not
using stack.

class Stack:
def _init_(self):
self.items = []

def is_empty(self):
return len(self.items) == 0

def push(self, item):

self.items.append(item)

def pop(self):
if not self.is_empty():
return self.items.pop()

def peek(self):
if not self.is_empty():
return self.items[-1]
 def is_palindrome(input_string):
stack = Stack()

# Push each character onto the stack

for char in input_string:
stack.push(char)

# Pop each character from the stack and

compare with the original string
reversed_string = ""
while not stack.is_empty():
reversed_string += stack.pop()

return input_string == reversed_string

# Input from the user

user_input = input("Enter a string: ")

# Check if the string is a palindrome

if is_palindrome(user_input):
print(f"{user_input} is a palindrome.")
else:
print(f"{user_input} is not a palindrome.")
PROGRAM -9 : Remove all the
lines that contain the character
'a' in a file and write it to
another file.

def remove_lines_with_a(input_file, output_file):

try:
with open(input_file, 'r') as file:
lines = file.readlines()

# Remove lines containing the character 'a'

modified_lines = [line for line in lines if 'a'
not in line]

with open(output_file, 'w') as file:

file.writelines(modified_lines)

print(f"Lines containing 'a' removed. Output

written to {output_file}

except FileNotFoundError:
print(f"The file '{input_file}' was not found.")

# Input file and output file names from the user

 input_file_name = input("Enter the name of the
input file: ")
output_file_name = input("Enter the name of
the output file: ")

# Call the function to remove lines containing 'a'

remove_lines_with_a(input_file_name,
output_file_name}
PROGRAM -10 : Write a python
program to remove all lines
that contains the character ‘a’
in a file & write it to another
file.

def remove_lines_with_a(input_file, output_file):

try:
with open(input_file, 'r') as file:
lines = file.readlines()

# Remove lines containing the character 'a'

modified_lines = [line for line in lines if 'a'
not in line]

with open(output_file, 'w') as file:

file.writelines(modified_lines)

print(f"Lines containing 'a' removed. Output

written to {output_file}")

except FileNotFoundError:
print(f"The file '{input_file}' was not found.")
 # Input file and output file names from the user
input_file_name = input("Enter the name of the
input file: ")
output_file_name = input("Enter the name of
the output file: ")

# Call the function to remove lines containing 'a'

remove_lines_with_a(input_file_name,
output_file_name)
PROGRAM -11 : Write a Python
program to implement a stack
using list.

class Stack:
def _init_(self):
self.items = []

def is_empty(self):
return len(self.items) == 0

def push(self, item):

self.items.append(item)

def pop(self):
if not self.is_empty():
return self.items.pop()

def peek(self):
if not self.is_empty():
return self.items[-1]

def size(self):
return len(self.items)
# Example usage of the stack
stack = Stack()

# Push elements onto the stack

stack.push(1)
stack.push(2)
stack.push(3)

# Display the stack

print("Stack:", stack.items)

# Pop elements from the stack

popped_item = stack.pop()
print(f"Popped item: {popped_item}")

# Display the stack after popping

print("Stack after popping:", stack.items)

# Peek at the top of the stack

top_item = stack.peek()
print(f"Top item: {top_item}")

# Check if the stack is empty

print(f"Is the stack empty? {stack.is_empty()}")

# Get the size of the stack

print(f"Size of the stack: {stack.size()}")
PROGRAM -12 : Create a binary
file with name and roll number.
Search for a given roll number
and display the name, if not
found display appropriate
message.

class Stack:
def _init_(self):
self.items = []

def is_empty(self):
return len(self.items) == 0

def push(self, item):

self.items.append(item)

def pop(self):
if not self.is_empty():
return self.items.pop()

def peek(self):
if not self.is_empty():
 return self.items[-1]

def is_palindrome(input_string):
stack = Stack()

# Push each character onto the stack

for char in input_string:
stack.push(char)

# Pop each character from the stack and

compare with the original string
reversed_string = ""
while not stack.is_empty():
reversed_string += stack.pop()

return input_string == reversed_string

# Input from the user

user_input = input("Enter a string: ")

# Check if the string is a palindrome

if is_palindrome(user_input):
print(f"{user_input} is a palindrome.")
else:
print(f"{user_input} is not a palindrome.")
PROGRAM -13 : Write a python
program to check whether a
string is palindrome or not.

def is_palindrome(input_string):
# Convert the input string to lowercase and
remove spaces
cleaned_string =
''.join(input_string.lower().split())

# Compare the cleaned string with its reverse

return cleaned_string == cleaned_string[::-1]

# Input from the user

user_input = input("Enter a string: ")

# Check if the string is a palindrome

if is_palindrome(user_input):
print(f"{user_input} is a palindrome.")
else:
print(f"{user_input} is not a palindrome.")
PROGRAM -14 : Create a CSV
file by entering user-id and
password, read and search the
password for given user-id.

import csv

def write_to_csv(file_name, data):

with open(file_name, 'w', newline='') as
csv_file:
csv_writer = csv.writer(csv_file)

# Write header
csv_writer.writerow(['user_id', 'password'])

# Write data
csv_writer.writerows(data)

print(f"CSV file '{file_name}' created

successfully.")

def search_password(file_name, target_user_id):

with open(file_name, 'r') as csv_file:
csv_reader = csv.reader(csv_file)
 # Skip header
next(csv_reader, None)

for row in csv_reader:

user_id, password = row

if user_id == target_user_id:
return password

return None # User-id not found

# Example data: (user_id, password)

user_data = [("user1", "password1"), ("user2",
"password2"), ("user3", "password3")]

# CSV file name

csv_file_name = "user_credentials.csv"

# Write data to the CSV file

write_to_csv(csv_file_name, user_data)

# Input user_id to search

search_user_id = input("Enter user_id to search:
")

# Search for the password and display the result

 result_password =
search_password(csv_file_name, search_user_id)

if result_password is not None:

print(f"Password for user_id
'{search_user_id}': {result_password}")
else:
print(f"User_id '{search_user_id}' not found.")
PROGRAM -15 : Create a binary
file with roll number, name and
marks. Input a roll number and
update the marks.

import struct

def write_binary_file(file_name, data):

with open(file_name, 'wb') as file:
for roll_number, name, marks in data:
packed_data = struct.pack('I20s f',
roll_number, name.encode('utf-8'), marks)
file.write(packed_data)

def update_marks(file_name,
target_roll_number, new_marks):
with open(file_name, 'rb+') as file:
record_size = struct.calcsize('I20s f')

while True:
data = file.read(record_size)

if not data:
break # End of file reached
 current_roll_number, current_name,
current_marks = struct.unpack('I20s f', data)
decoded_name =
current_name.decode('utf-8').rstrip('\x00') #
Decode and remove null characters

if current_roll_number ==
target_roll_number:
# Move the file pointer back to update
the marks
file.seek(-record_size, 1)
updated_data = struct.pack('I20s f',
current_roll_number, current_name, new_marks)
file.write(updated_data)
break # Exit the loop after updating

print(f"Marks updated for Roll Number

{target_roll_number}.")

# Example data: (roll_number, name, marks)

student_data = [(101, "Alice", 85.5), (102, "Bob",
92.0), (103, "Charlie", 78.5)]

# Create a binary file

file_name = "student_records.bin"
write_binary_file(file_name, student_data)
 # Input roll number and new marks to update
target_roll = int(input("Enter roll number to
update marks: "))
new_marks = float(input("Enter new marks: "))

# Update marks for the specified roll number

update_marks(file_name, target_roll,
new_marks)
PROGRAM -16 : Create a
database UNIVERSITY & create
table within it.

-- Create the "UNIVERSITY" database (SQLite

syntax)
CREATE DATABASE IF NOT EXISTS UNIVERSITY;

-- Use the "UNIVERSITY" database (SQLite syntax)

USE UNIVERSITY;

-- Create a table named "students" within the

"UNIVERSITY" database (SQLite syntax)
CREATE TABLE IF NOT EXISTS students (
student_id INTEGER PRIMARY KEY,
first_name TEXT,
last_name TEXT,
age INTEGER,
major TEXT
);

-- Create the "UNIVERSITY" database (MySQL

syntax)
CREATE DATABASE IF NOT EXISTS UNIVERSITY;
 -- Use the "UNIVERSITY" database (MySQL
syntax)
USE UNIVERSITY;

-- Create a table named "students" within the

"UNIVERSITY" database (MySQL syntax)
CREATE TABLE IF NOT EXISTS students (
student_id INT PRIMARY KEY,
first_name VARCHAR(255),
last_name VARCHAR(255),
age INT,
major VARCHAR(255)
);
PROGRAM -17 : Create a
student table and insert data.
Implement the following SQL
commands on the STUDENT
table: ALTER table to add new
attributes / modify data type /
drop attribute UPDATE table to
modify data.

-- Display data in ascending order of 'age'

SELECT * FROM student ORDER BY age ASC;

-- Display data in descending order of 'major'

SELECT * FROM student ORDER BY major DESC;

-- DELETE to remove a tuple with student_id = 3

DELETE FROM student WHERE student_id = 3;

-- Display data after deletion

SELECT * FROM student;
 -- GROUP BY major and find MIN, MAX, SUM,
COUNT, AVG of age
SELECT
major,
MIN(age) AS min_age,
MAX(age) AS max_age,
SUM(age) AS total_age,
COUNT(*) AS total_students,
AVG(age) AS avg_age
FROM student
GROUP BY major;
PROGRAM -18 : ORDER By to
display data in ascending /
descending order DELETE to
remove tuple(s) GROUP BY and
find the min, max, sum, count
and average.

-- Display data in ascending order of 'age'

SELECT * FROM student ORDER BY age ASC;

-- Display data in descending order of 'major'

SELECT * FROM student ORDER BY major DESC;

-- DELETE to remove a tuple with student_id = 3

DELETE FROM student WHERE student_id = 3;

-- Display data after deletion

SELECT * FROM student;

-- GROUP BY major and find MIN, MAX, SUM,

COUNT, AVG of age
SELECT
major,
 MIN(age) AS min_age,
MAX(age) AS max_age,
SUM(age) AS total_age,
COUNT(*) AS total_students,
AVG(age) AS avg_age
FROM student
GROUP BY major;
PROGRAM -19 :DELETE
database & remove all tables
from Database.

-- Drop all tables in the database

DROP TABLE IF EXISTS student;

-- Drop the "student" table (if exists)

DROP TABLE IF EXISTS student;

-- Drop the "UNIVERSITY" database (if exists)

-- Note: Some database systems may not support
dropping a database using SQL directly.
-- You might need to use database-specific
commands outside SQL, or use a database
management tool.
DROP DATABASE IF EXISTS UNIVERSITY;
PROGRAM -20 :Write a
program to create a database
named SCHOOL through
MySQL-Python
Connectivity.

import pymysql

# Connect to MySQL database

connection = pymysql.connect(
host='your_mysql_host',
user='your_username',
password='your_password',
database='your_database_name'
)

# Create a cursor object

cursor = connection.cursor()

# Execute SQL queries

cursor.execute('CREATE TABLE IF NOT EXISTS
users (id INT PRIMARY KEY, name VARCHAR(255),
age INT)')
 cursor.execute('INSERT INTO users (name, age)
VALUES (%s, %s)', ('John Doe', 30))

# Commit the changes

connection.commit()

# Query data
cursor.execute('SELECT * FROM users')
rows = cursor.fetchall()
for row in rows:
print(row)

# Close the connection

connection.close()
PROGRAM -21 :Write a program
to insert data given below in
STUDENT table with MySQL-
Python connectivity.

import pymysql

# Replace these values with your MySQL

connection details
host = 'your_mysql_host'
user = 'your_username'
password = 'your_password'
database = 'your_database_name'

# Sample data to insert into the STUDENT table

data_to_insert = [
(1, 'Alice', 'Johnson', 20, 'Computer Science'),
(2, 'Bob', 'Smith', 22, 'Physics'),
(3, 'Charlie', 'Brown', 21, 'Mathematics'),
(4, 'David', 'Lee', 25, 'Physics'),
(5, 'Eva', 'Miller', 23, 'Mathematics')
]

try:
# Connect to MySQL database
connection = pymysql.connect(
 host=host,
user=user,
password=password,
database=database
)

# Create a cursor object

cursor = connection.cursor()

# Insert data into the STUDENT table

insert_query = 'INSERT INTO STUDENT
(student_id, first_name, last_name, age, major)
VALUES (%s, %s, %s, %s, %s)'
cursor.executemany(insert_query,
data_to_insert)

# Commit the changes

connection.commit()

print("Data inserted successfully.")

except Exception as e:
print(f"Error: {e}")

finally:
# Close the connection
if connection:
connection.close()
PROGRAM -22 :Write a
program to insert data given
below in TEACHER table with
MySQL-Python
connectivity.

import pymysql

# Replace these values with your MySQL

connection details
host = 'your_mysql_host'
user = 'your_username'
password = 'your_password'
database = 'your_database_name'

# Sample data to insert into the TEACHER table

data_to_insert = [
(101, 'John', 'Math', 'Associate Professor'),
(102, 'Alice', 'Physics', 'Assistant Professor'),
(103, 'Bob', 'Chemistry', 'Professor'),
(104, 'Charlie', 'Biology', 'Lecturer'),
(105, 'David', 'Computer Science', 'Professor')
]

try:
 # Connect to MySQL database
connection = pymysql.connect(
host=host,
user=user,
password=password,
database=database
)

# Create a cursor object

cursor = connection.cursor()

# Insert data into the TEACHER table

insert_query = 'INSERT INTO TEACHER
(teacher_id, name, subject, designation) VALUES
(%s, %s, %s, %s)'
cursor.executemany(insert_query,
data_to_insert)

# Commit the changes

connection.commit()

print("Data inserted successfully.")

except Exception as e:
print(f"Error: {e}")

finally:
# Close the connection
if connection:
connection.close()
PROGRAM -23 :Write a
program to fetch all the records
from STUDENT table &
TEACHER table with
MySQL-Python connectivity

import pymysql

# Replace these values with your MySQL

connection details
host = 'your_mysql_host'
user = 'your_username'
password = 'your_password'
database = 'your_database_name'

try:
# Connect to MySQL database
connection = pymysql.connect(
host=host,
user=user,
password=password,
database=database
)

# Create a cursor object

 cursor = connection.cursor()

# Fetch all records from the STUDENT table

cursor.execute('SELECT * FROM STUDENT')
student_records = cursor.fetchall()

# Print STUDENT records

print("STUDENT Table:")
for record in student_records:
print(record)

print("\n---------------------------\n")

# Fetch all records from the TEACHER table

cursor.execute('SELECT * FROM TEACHER')
teacher_records = cursor.fetchall()

# Print TEACHER records

print("TEACHER Table:")
for record in teacher_records:
print(record)

except Exception as e:
print(f"Error: {e}")

finally:
# Close the connection
if connection:
connection.close()
PROGRAM -24 :Write a
program to fetch all the records
from STUDENT table who are
reading either XI or XII with
MySQL-Python connectivity.

import pymysql

# Replace these values with your MySQL

connection details
host = 'your_mysql_host'
user = 'your_username'
password = 'your_password'
database = 'your_database_name'

try:
# Connect to MySQL database
connection = pymysql.connect(
host=host,
user=user,
password=password,
database=database
)
 # Create a cursor object
cursor = connection.cursor()

# Fetch records from the STUDENT table for

students in XI or XII
cursor.execute('SELECT * FROM STUDENT
WHERE class IN ("XI", "XII")')
student_records = cursor.fetchall()

# Print STUDENT records for XI or XII

print("STUDENT Table - XI or XII:")
for record in student_records:
print(record)

except Exception as e:
print(f"Error: {e}")

finally:
# Close the connection
if connection:
connection.close()
PROGRAM -25 :Write a
program to fetch all the records
from TEACHER table who are
teaching either XI or XII with
MySQL-Python connectivity..

import pymysql

# Replace these values with your MySQL

connection details
host = 'your_mysql_host'
user = 'your_username'
password = 'your_password'
database = 'your_database_name'

try:
# Connect to MySQL database
connection = pymysql.connect(
host=host,
user=user,
password=password,
database=database
)
 # Create a cursor object
cursor = connection.cursor()

# Fetch records from the TEACHER table for

teachers teaching in XI or XII
cursor.execute('SELECT * FROM TEACHER
WHERE class IN ("XI", "XII")')
teacher_records = cursor.fetchall()

# Print TEACHER records for XI or XII

print("TEACHER Table - XI or XII:")
for record in teacher_records:
print(record)

except Exception as e:
print(f"Error: {e}")

finally:
# Close the connection
if connection:
connection.close()