Submitted By :

NAME : ANKAN CHATTOPADHYAY

ROLL NO. :

REG. NO. :

SUBJECT : COMPUTER SCIENCE (083)

SESSION : 2024 – 25

Submit To :
Falguni Mondal
TGT Computer Science
 Certificate
This is to certify that Ankan Chattopadhyay , a student of
Class 12, of Gitanjali Public School, Daikota, Sainthia,
Birbhum has successfully completed and submitted the
practical file of Computer Science (083) as per the guidelines
provided by CBSE in the prescribed curriculum for academic
year 2024-25 for accomplishment of Senior School
Certificate Examination - 2025.
The practical file has been evaluated and found correct in
accordance with the guidelines provided by the board- for
Academic year 2024-25. The work has been completed and
presented in a satisfactory manner.
No. of practical certified are: 24

Internal Examiner External Examiner

School Stamp Principal

Page |2
 Acknowledgement
I wish to express my heartfelt thanks to
everyone involved in preparing my class
12 computer science practical file.

First and foremost, I am grateful to my

computer lab instructor Mr. Falguni
Mondal for providing the necessary
resources and guidance for undertaking
this project.

I would also like to thank our Principal Dr.

Joydeep Mukherjee for advocating
technology education at our school.

The computer lab facilities provided me

with the opportunity to learn new skills
through hands-on practice.

Page |3
Additionally, I must extend my gratitude
to my parents, whose unwavering support
was evident at every step.

Page |4
 Index
Sno. Assignment Page Date Sign.
Part A – Python Programs
Python Revision Tour
1 List Menu Driven Program 5 07-04-2024
2 Dictionary Menu Driven Program 6 22-04-2024
Working with Functions
3 Using a function to display prime numbers between m & n. 7 13-06-2024
Using a function calculate interest using various
4 8 18-06-2024
arguments.
Using a function find a largest element in a list. Pass list
5 9 26-06-2024
object as argument.
Using a function count the number of vowels in passed
6 10 04-07-2024
string.
Exception Handling
Take two integers and perform addition of two numbers
7 11 15-07-2024
handle exception when non-integers entered by user
Find the square root of a positive number, raise a custom
8 12 18-07-2024
exception when user enters a negative number
File handling
9 Find and replace a word in a text file 13 23-07-2024
Menu driven program for binary file to insert, update,
10 14 06-08-2024
delete and display records
Menu driven program for csv file to insert, update and
11 19 23-08-2024
delete records
12 Search record in binary file using user defined condition 21 28-08-2024
13 Search record in csv file using user defined condition 22 29-08-2024
Data Structure – Stack
14 Menu driven program for stack operations 26 07-09-2024
Searching data from dictionary and transfer keys into
15 29 10-09-2024
stack then performing push operations
Part B – MySQL Queries
16 Set 1 – Based on Database Basic Commands 31 01-10-2024
17 Set 2 – Based on DDL Commands 32 04-10-2024
18 Set 3 – Select Queries including order by 35 09-10-2024
19 Set 4 – Group by, having and Aggregate Functions 37 14-10-2024
20 Set 5 – Join Queries 39 17-10-2024
Part C – Python Database Connectivity
21 Insert record in a database table 41 12-11-2024
22 Update a record in a database table 42 14-11-2024
23 Delete a record in a database table 43 18-11-2024
24 Display records using queries from database table 44 20-11-2024

Page |5
 Part A – Python Programs
Python Revision Tour
1. Write a program to find the sum and average of list in python.

Code:
#Creating list with user defined list
l=[] #Declare an empty list
while True:
n=int(input("Enter no. to add into the list:"))
l.append(n)
ch=input("Press 'X' to stop:")
if ch in 'xX':
break
s=0
n=len(l)
for i in l:
s+=i
avg=s/n
print("The list is:",l)
print("Sum is:",s)
print(f"Average is:{avg:.2f}")

Output:

Page |6
 2. Write a program to remove duplicates from the dictionary

Code:
#Creating empty dictionary
d={}
#Ask user to enter number of key:value pairs
n=int(input("Enter no. of elements:"))
for i in range(n):
k=input("Enter Key:")
v=input("Enter value:")
d[k]=v
#Declare empty dictionary to store unique key-value pairs
uni_dict={}
#Traverse dictionary to remove duplicates and store into unique
dictionary
for k in d:
val=d[k]
if val not in uni_dict.values():
uni_dict[k]=val
#Output
print("Dictionary After removing duplicates:",uni_dict)

Output:

Page |7
 Working with functions
3. Write a program to define a function to accept two integers m and
n respectively as argument and display prime numbers between them.
Code:
# Function to check and display prime in the range
def prime_m_to_n(m,n):
for i in range(m, n + 1):
# all prime numbers are greater than 1
if i > 1:
for j in range(2, i):
if (i % j) == 0:
break
else:
print(i, end=' ')
# Taking input for m and n
m = int(input("Enter the value of m: "))
n = int(input("Enter the value of n: "))
# Calling the function
prime_m_to_n(m, n)

Output:

Page |8
 4. Write a program to compute interest based on different arguments
given in the function.
Code:
# Function to calculate interest
def compute_int(pri, r=5, t=1, comp=False):
if comp:
amt = pri * (1 + r / 100) ** t
i = amt - pri
else:
i = (pri * r * t) / 100
return i
# Testing the function with various argument combinations
p=int(input("Enter Principle:"))
r=float(input("Enter custom rate:"))
t=float(input("Enter time:"))
# Case 1: Only principal provided, default rate and time
print("Interest (Simple, default):", compute_int(1000))
# Case 2: Principal and rate provided, default time
print("Interest (Simple, custom rate):", compute_int(p, r))
# Case 3: Principal, rate, and time provided
print("Interest (Simple, custom rate and time):", compute_int(p,
r,t))
# Case 4: Compound interest, with custom rate and time
print(f"Interest (Compound, custom rate and time):
{compute_int(p,r, t,True):.2f}")

Output:

Page |9
 5. Write a program to largest element in a list using a function. Pass list
object as argument.
Code:
# Function to find the largest element in a list
def find_largest(l):
if not l: # Check the list is empty or not
return None # Return None if the list is empty
large = l[0] # Assume the first element is the large
for i in l:
# Check if other element than first is large
if i > large:
# Update the largest if a bigger number is
found
large = i
return large
# Taking input as a list
lst = eval(input("Enter list as input:"))
# Calling the function and printing the result
large_ele = find_largest(lst)
if large_ele is not None:
print(f"The largest element in the list is: {large_ele}")
else:
print("The list is empty.")

Output:

P a g e | 10
 6. Write a program to count the number of vowels in passed string to the
function.
Code:
def count_vowels(s):
# Define a set of vowels (both lowercase and uppercase)
vowels = "aeiouAEIOU"
# Initialize a counter variable
count = 0
# Loop through each character in the string
for char in s:
if char in vowels:
count += 1
return count
# Passing string and calling function
input_string = input("Enter a string: ")
print("Number of vowels:", count_vowels(input_string))

Output:

P a g e | 11
 Exception Handling
7. Write a program to take two positive integers and perform addition
among them handle exception when negative integers entered by user.
Code:
def add(n1,n2): # Define a function to add and return
error
if n1<0 or n2<0: #Checking for error
raise ValueError("Negative number entered!")
else:
return n1 + n2 #Performing Addition
try: #Handling exception using try
no1 = int(input("Enter number1: "))
no2 = int(input("Enter number2: "))
print(f"The result is: {add(no1,no2)}")
except ValueError as e:
print(f"Error: {e}")

Output:

P a g e | 12
 8. Write a program to find the square root of a positive number, raise a
custom exception when user enters a non-integer number.
Code:
import math # Importing math module
def find_square_root(): #Define a function
try: # Handling exception
# Input a number
num = float(input("Enter a number: "))
# Condition to check positive integer
if num <= 0 or num % 1 != 0:
raise ValueError("Input must be a positive
integer")
# Calculating Square root
square_root = math.sqrt(num)
# Output
print(f"The square root of {num} is {square_root}")
#Generating Error message
except ValueError as e:
print(f"Custom Error: {e}")
find_square_root()

Output:

P a g e | 13
 File Handling
9. Write a program to replace entered word from a text file india.txt.

Code:
def replace_word(f, old_word, new_word):
with open(f, 'r') as file: # Open a file to read
dt = file.read() # Store data read from file in dt
object
if old_word not in dt: # Checking the presence of old
word
print(f"The word '{old_word}' was not found in the
file.")
return
new_dt = dt.replace(old_word, new_word) # Replace old
word
with open(f, 'w') as file: # Writing new data in the file
file.write(new_dt)
print(f"The word '{old_word}' has been replaced with
'{new_word}' successfully.")
print(new_dt)
f = 'india.txt' # Main Code
old_word = input("Enter the word to be replaced: ")
new_word = input("Enter the new word: ")
replace_word(f, old_word, new_word)

Output:

P a g e | 14
P a g e | 15
 10. Write a menu driven program to store and manipulate data in binary
file to insert, update, delete and display records. The data has following
structure:
Data Represents Patient Information
Dictionary {‘P_ID’:101,’P_Name’:’Shiv’,’Charges’:25000}
File Name patient.dat
Menu:
1. Add Patient
2. Display Patient
3. Search Patient
4. Update Patient
5. Delete Patient
6. Exit
Code:
import pickle # import module to handle binary files data
flag = False

# Accepting data for Dictionary and dumping into binary file

def add_pat():
# Enter data as Input to add in dictionary
P_ID = int(input('Enter patient_id:'))
pname = input('Enter Patient Name:')
charges = int(input('Enter Charges:'))
# Creating the dictionary
rec = {'P_ID':P_ID,'P_Name':pname,'Charges':charges}
# Opens a file and Writing the Dictionary
f = open('patient.dat','ab')
pickle.dump(rec,f)
f.close()
print("Record Addedd successfully.")

# Reading and displaying the records

def display_pat():
f = open('patient.dat','rb')
while True:
try:
rec = pickle.load(f)
print('*'*40)
print('Patient ID:',rec['P_ID'])
print('Name:',rec['P_Name'])
print('charges:',rec['Charges'])
P a g e | 16
 print('*'*40)
except EOFError:
break
f.close()

#Searching a record based on patient name

def search_pat(pname):
# Open file to search patient record
f = open('patient.dat','rb')
# Iterating records using while loop
while True:
# Hnalding exception Ran out of Input and EOFError
try:
# Load records into a python object
rec = pickle.load(f)
# Matching and displaying records
if rec['P_Name'] == pname:
print('Patient ID:',rec['P_ID'])
print('Name:',rec['P_Name'])
print('Charges:',rec['Charges'])
flag = True
except EOFError:
break
if flag == False:
print('No Record found...')
f.close()

# charges modification for a P_ID

def update_pat():
# Prompt P_ID and charges to modify record
pid = int(input('Enter a P_ID:'))
flag=False
# Open a file to verify record exists or not
f = open('patient.dat','rb')
# An empty list to store the record found for the update
reclst = []
while True:
try:
rec = pickle.load(f)
reclst.append(rec)
flag=True
except EOFError:
break
f.close()
P a g e | 17
 c = int(input('Enter new Charges:'))
for i in range (len(reclst)):
if reclst[i]['P_ID']==pid:
reclst[i]['Charges'] = c
f = open('patient.dat','wb')
for i in reclst:
pickle.dump(i,f)
f.close()
print("Record modified successfully...")

# Deleting a record based on P_ID

def deleteRec():
flag=False
f = open('patient.dat','rb')
pid = int(input('Enter a P_ID:'))
reclst = []
while True:
try:
rec = pickle.load(f)
reclst.append(rec)
except EOFError:
break
f.close()
f = open('patient.dat','wb')
for i in reclst:
if i['P_ID']==pid:
continue
pickle.dump(i,f)
print("Record Deleted...")
f.close()

while True:
print('''
1. Add Patient
2. Display Patient
3. Search Patient
4. Update Patient
5. Delete Patient
6. Exit
''')
ch = int(input('Enter your choice:'))
if ch == 1:
add_pat()
elif ch == 2:
P a g e | 18
 display_pat()
elif ch == 3:
pn = input('Enter a patient name to search:')
search_pat(pn)
elif ch == 4:
update_pat()
elif ch == 5:
deleteRec()
elif ch==6:
print("Bye Bye, Thank you for Interactions")
break
else:
print("Invalid Choice")

Output:
Main Menu

Add Patient

P a g e | 19
Display Patient

Search Patient

Update Patient

Delete Patient

Exit

P a g e | 20
 11. Create a CSV file by entering user-id and password, read and search the
password for given userid.
Code:
import csv # importing csv file
users=[] # creating a list to add record
def add_user(): # define function to add user
un=input("Enter Username:")
pwd=input("Enter Password:")
f=open("user.csv","a",newline='')
w=csv.writer(f)
w.writerow([un,pwd])
f.close()
print("User added...")

def search(): # Defining a search function

f=open("user.csv","r")
r=csv.reader(f)
un=input("Enter Username to search:")
for i in r:
if i[0]==un:
print("Your password for ", i[0], " is:",i[1])
f.close()

# Creating main menu

while True:
print('''
1. Add user
2. Search Password
3. Exit
''')
ch=int(input("Enter Your Choice:"))
if ch==1:
add_user()
elif ch==2:
P a g e | 21
 search()
elif ch==3:
break
else:
print("Invalid Choice")

Output:
Main menu

Add user

Search password

P a g e | 22
 12. Write a program to create a binary file candidates.dat which stores the
following information in list as follows:
Structure of Data
Field Data Type
Candidate_id Integer
Candidate_Name String
Designation String
Experience Float
(i)Write a function append() to write data into binary file.
(ii) Write a function display() to display data from binary file for all
candidates whose experience is more than 10.
Code:
import pickle # Module to work with binary files
def append():
with open("Candidates.dat",'ab') as f:
C_id=int(input("Enter Candidate ID: "))
C_nm=input("Enter Candidate name: ")
C_dg=input("Enter Designation: ")
C_ex=float(input("Enter Experience: "))
rec=[C_id,C_nm,C_dg,C_ex]
pickle.dump(rec,f)
def display(): # Display data after reading file contents
with open("Candidates.dat",'rb') as f:
while True:
try:
rec=pickle.load(f)
if rec[-1]>10:
print(rec)
except EOFError:
break
append() # Calling functions
display() # Calling functions

Output:

P a g e | 23
 13. Write a program to generate a CSV file named happiness.csv.
Each record of CSV contains these data:
Name of the country String
Population of country Integer
No. people participated in survey Integer
No. of people who are Happy Integer
Write user defined functions to do the following:
(i) Insert records into CSV
(ii) Display records from CSV
(iii)Update records
(iv)Delete record
Code:
import csv # Import a module to work with csv
h=[] # a list object to store records
def header_row(): # A function to create header row, run only
once
f=open("happiness.csv",'w',newline='')
wo=csv.writer(f)
wo.writerow(['Country','Population','Participants', 'Happy
People'])
print("A CSV file with header is created...")
f.close()

def insert_rec(): # A function to insert a record

with open('happiness.csv','a',newline='') as f:
country=input("Enter name of country:")
population=float(input("Enter Population (In
Billion):"))
participants=float(input("Enter no. of participants (In
Million):"))
happy=float(input("Enter no. of people who are happy (In
Million):"))
h=[country, population, participants, happy]
wo=csv.writer(f)

P a g e | 24
 wo.writerow([country,population,participants,happy])
print("Record inserted...")

def display_rec(): # A function to display records

with open('happiness.csv','r',newline='') as f:
ro=csv.reader(f)
for i in ro:
print(i)

def update_rec(): # Update a record

c=input("Enter country to update records:")
updated_row=[]
flg=False
with open('happiness.csv','r') as f:
ro=csv.reader(f)
for i in ro:
if i[0]==c:
flg=True
population=float(input("Enter Population (In
Billion):"))
participants=float(input("Enter no. of
participants (In Million):"))
happy=float(input("Enter no. of people who are
happy (In Million):"))
i[1]=population
i[2]=participants
i[3]=happy
updated_row.append(i)
if flg==True:
with open('happiness.csv','w',newline='') as f:
wo=csv.writer(f)
wo.writerows(updated_row)
print('Record Updated...')
else:
P a g e | 25
 print('Record not found...')

def delete_rec(): # Delete Record

c=input("Enter country to delete records:")
deleted_row=[]
flg=False
with open('happiness.csv','r') as f:
ro=csv.reader(f)
for i in ro:
if i[0] != c:
flg=True
deleted_row.append(i)
if flg==True:
with open('happiness.csv','w',newline='') as f:
wo=csv.writer(f)
wo.writerows(deleted_row)
print('Record Deleted...')
else:
print('Record not found...')

while True: # Main Menu

print('''
1. Create header row (Excute at once)
2. Insert country record
3. Display happiness record
4. Update Record
5. Delete Record
6. Exit
''')
ch = int(input('Enter your choice:'))
if ch==1:
header_row()
elif ch == 2:
insert_rec()
P a g e | 26
 elif ch == 3:
display_rec()
elif ch == 4:
update_rec()
elif ch == 5:
delete_rec()
elif ch == 6:
print("Bye Bye, Thank you for Interactions")
break
else:
print("Invalid Choice")

Output:

P a g e | 27
 Data Structure - Stack
14. Write a menu drive program for stack operations.

Code:
s=[] # An empty list to store stack elements, initially its
empty
top = None # This is top pointer for push and pop operation
def check_stack_isEmpty(stk):
if stk==[]:
return True
else:
return False

def push(stk,e):
stk.append(e)
top = len(stk)-1

def display(stk):
if check_stack_isEmpty(stk):
print("Stack is Empty")
else:
top = len(stk)-1
print(stk[top],"-Top")
for i in range(top-1,-1,-1):
print(stk[i])

def pop_stack(stk):
if check_stack_isEmpty(stk):
return "UnderFlow"
else:
e = stk.pop()
if len(stk)==0:
top = None
else:

P a g e | 28
 top = len(stk)-1
return e

def peek(stk):
if check_stack_isEmpty(stk):
return "UnderFlow"
else:
top = len(stk)-1
return stk[top]

def main_menu():
while True:
print("Stack Implementation")
print("1 - Push")
print("2 - Pop")
print("3 - Peek")
print("4 - Display")
print("5 - Exit")
ch = int(input("Enter the your choice:"))
if ch==1:
el = int(input("Enter the value to push an
element:"))
push(s,el)
elif ch==2:
e=pop_stack(s)
if e=="UnderFlow":
print("Stack is underflow!")
else:
print("Element popped:",e)
elif ch==3:
e=pop_stack(s)
if e=="UnderFlow":
print("Stack is underflow!")
else:
P a g e | 29
 print("The element on top is:",e)
elif ch==4:
display(s)
elif ch==5:
break
else:
print("Sorry, You have entered invalid option")

main_menu()

Output:

P a g e | 30
 15. Write a program to Push an item into stack where a dictionary contains
the details of stationary items as follows:
stn = {“Shirt”:700,”T-Shirt”:750, ”Jeans”:1150,”Trouser”:400}
(a) Write a function to push an element into stack for those items names
whose price is more than 450. Also display the count of elements pushed
into the stack.
(b) Write a function to pop an element to remove the element and
display appropriate message when the stack is empty.
Code:
stn = {}
while True:
item=input("Enter itemname:")
price=float(input("Enter Price:"))
stn[item]=price
ch=input("Press X to stop:")
if ch in 'xX':
break
def Push(stk,ele):
stk.append(ele)
return stk

def Pop(stk):
if stk==[]:
return "underflow"
else:
return stk.pop()

stak=[]
c=0
for i in stn:
if stn[i]>450:
Push(stak,i)
c+=1
print("Total Stack elements are:",c)

P a g e | 31
while True:
if stak!=[]:
print(Pop(stak))
else:
print("Stack is Empty")
break

Output:

P a g e | 32
 Part B – MySQL Queries
Simple Queries in SQL
16. Based on Database Basic Commands write SQL for following:

1. Create a database named practical_2025

Ans.: mysql> CREATE DATABASE practical_2025;
2. Check database is present or not in the list of databases
Ans.: mysql> show databases;
3. Open a database
Ans.: mysql>use practical_2025;
4. Create a database temp
Ans.: mysql> create database temp;
5. Delete a database temp
Ans.: mysql> drop database temp;

mysql> CREATE DATABASE practical_2025;

Query OK, 1 row affected (0.007 sec)

mysql > show databases;

+--------------------+
| Database |
+--------------------+
| computer |
| information_schema |
| mysql |
| performance_schema |
| phpmyadmin |
| practical_2025 |
| test |
+--------------------+
7 rows in set (0.074 sec)

mysql > use practical_2025;

Database changed
mysql > create database temp;
Query OK, 1 row affected (0.001 sec)

mysql > drop database temp;

Query OK, 0 rows affected (0.088 sec)

P a g e | 33
 17. Based on DDL Commands consider the following MOVIES table and
write the SQL commands based on it.
Movie_ Producti Business
MovieName Type ReleaseDate
ID onCost Cost
M001 Dahek Action 2022/01/26 1245000 1300000
M002 Attack Action 2022/01/28 1120000 1250000
M003 Looop Lapeta Thriller 2022/02/01 250000 300000
M004 Badhai Do Drama 2022/02/04 720000 68000
M005 Shabaash Mithu Biography 2022/02/04 1000000 800000
M006 Gehraiyaan Romance 2022/02/11 150000 120000
M007 Border 2 Action null 3211400 2500000

1. Create above table, assign Movie_ID as a primary key and insert records as
above.

mysql> CREATE TABLE Movies ( Movie_ID VARCHAR(5) PRIMARY KEY,

-> MovieName VARCHAR(50),
-> Type VARCHAR(20),
-> ReleaseDate DATE,
-> ProductionCost INT,
-> BusinessCost INT );
Query OK, 0 rows affected (0.044 sec)

mysql> INSERT INTO Movies (Movie_ID, MName, Type, ReleaseDate,

-> ProductionCost, BusinessCost) VALUES
-> ('M001', 'Dahek', 'Action', '2022-01-26', 1245000, 1300000),
-> ('M002', 'Attack', 'Action', '2022-01-28', 1120000, 1250000),
-> ('M003', 'Looop Lapeta', 'Thriller', '2022-02-01', 250000, 300000),
-> ('M004', 'Badhai Do', 'Drama', '2022-02-04', 720000, 68000),
-> ('M005', 'Shabaash Mithu', 'Biography', '2022-02-04', 1000000, 800000),
-> ('M006', 'Gehraiyaan', 'Romance', '2022-02-11', 150000, 120000),
-> ('M007', 'Border 2', 'Action', null, 3211400, 2500000);
Query OK, 6 rows affected (0.006 sec)

mysql> select * from movies;

+----------+----------------+-----------+-------------+----------------
+--------------+
| Movie_ID | MovieName | Type | ReleaseDate | ProductionCost |
BusinessCost |
+----------+----------------+-----------+-------------+----------------
+--------------+
| M001 | Dahek | Action | 2022-01-26 | 1245000 |
1300000 |
| M002 | Attack | Action | 2022-01-28 | 1120000 |
1250000 |
| M003 | Looop Lapeta | Thriller | 2022-02-01 | 250000 |
300000 |
| M004 | Badhai Do | Drama | 2022-02-04 | 720000 |
68000 |

P a g e | 34
2. Show the structure of table
mysql> desc movies;
+----------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------------+-------------+------+-----+---------+-------+
| Movie_ID | varchar(5) | NO | PRI | NULL | |
| MovieName | varchar(50) | YES | | NULL | |
| Type | varchar(20) | YES | | NULL | |
| ReleaseDate | date | YES | | NULL | |
| ProductionCost | int(11) | YES | | NULL | |
| BusinessCost | int(11) | YES | | NULL | |
+----------------+-------------+------+-----+---------+-------+
6 rows in set (0.023 sec)

3. Add a column named collection with decimal data type with structure 12, 2

mysql> alter table movies add column collection decimal(12,2);

Query OK, 0 rows affected (0.009 sec)
Records: 0 Duplicates: 0 Warnings: 0

mysql> desc movies;

+----------------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------------+---------------+------+-----+---------+-------+
| Movie_ID | varchar(5) | NO | PRI | NULL | |
| MovieName | varchar(50) | YES | | NULL | |
| Type | varchar(20) | YES | | NULL | |
| ReleaseDate | date | YES | | NULL | |
| ProductionCost | int(11) | YES | | NULL | |
| BusinessCost | int(11) | YES | | NULL | |
| collection | decimal(12,2) | YES | | NULL | |
+----------------+---------------+------+-----+---------+-------+
7 rows in set (0.018 sec)

4. Change the data type of movie_id to varchar

mysql> alter table movies modify column movie_id varchar(4);
Query OK, 6 rows affected (0.070 sec)
Records: 6 Duplicates: 0 Warnings: 0

mysql> desc movies;

+----------------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------------+---------------+------+-----+---------+-------+
| movie_id | varchar(4) | NO | PRI | NULL | |
| MovieName | varchar(50) | YES | | NULL | |
| Type | varchar(20) | YES | | NULL | |
| ReleaseDate | date | YES | | NULL | |
| ProductionCost | int(11) | YES | | NULL | |
| BusinessCost | int(11) | YES | | NULL | |
| collection | decimal(12,2) | YES | | NULL | |
+----------------+---------------+------+-----+---------+-------+
7 rows in set (0.025 sec)

P a g e | 35
5. Rename a column MovieName to MName
mysql> alter table movies change column moviename mname varchar(50);
Query OK, 0 rows affected (0.010 sec)
Records: 0 Duplicates: 0 Warnings: 0

mysql> desc movies;

+----------------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------------+---------------+------+-----+---------+-------+
| movie_id | varchar(4) | NO | PRI | NULL | |
| mname | varchar(50) | YES | | NULL | |
| Type | varchar(20) | YES | | NULL | |
| ReleaseDate | date | YES | | NULL | |
| ProductionCost | int(11) | YES | | NULL | |
| BusinessCost | int(11) | YES | | NULL | |
| collection | decimal(12,2) | YES | | NULL | |
+----------------+---------------+------+-----+---------+-------+
7 rows in set (0.031 sec)

6. Delete a column collection

mysql> alter table movies drop column collection;
Query OK, 0 rows affected (0.008 sec)
Records: 0 Duplicates: 0 Warnings: 0

mysql> desc movies;

+----------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------------+-------------+------+-----+---------+-------+
| movie_id | varchar(4) | NO | PRI | NULL | |
| mname | varchar(50) | YES | | NULL | |
| Type | varchar(20) | YES | | NULL | |
| ReleaseDate | date | YES | | NULL | |
| ProductionCost | int(11) | YES | | NULL | |
| BusinessCost | int(11) | YES | | NULL | |
+----------------+-------------+------+-----+---------+-------+
6 rows in set (0.027 sec)

P a g e | 36
 18. Select queries including order by based on the previous table.

1. Display the movie name, type, releasedate and total cost of all movies

mysql> select mname, type, releasedate,

-> productioncost + businesscost as
-> 'total cost' from movies;
+----------------+-----------+-------------+------------+
| mname | type | releasedate | total cost |
+----------------+-----------+-------------+------------+
| Dahek | Action | 2022-01-26 | 2545000 |
| Attack | Action | 2022-01-28 | 2370000 |
| Looop Lapeta | Thriller | 2022-02-01 | 550000 |
| Badhai Do | Drama | 2022-02-04 | 788000 |
| Shabaash Mithu | Biography | 2022-02-04 | 1800000 |
| Gehraiyaan | Romance | 2022-02-11 | 270000 |
| Border 2 | Action | NULL | 5711400 |
+----------------+-----------+-------------+------------+
7 rows in set (0.001 sec)

2. Display all details of action and thriller movies

mysql> select * from movies where type in ('action','thriller');

+----------+--------------+----------+-------------+----------------
+--------------+
| movie_id | mname | Type | ReleaseDate | ProductionCost | BusinessCost
|
+----------+--------------+----------+-------------+----------------
+--------------+
| M001 | Dahek | Action | 2022-01-26 | 1245000 | 1300000
|
| M002 | Attack | Action | 2022-01-28 | 1120000 | 1250000

3. Display movie name, types and releasedate of all movies released in the
month of February, 2022

mysql> select mname, type, releasedate from movies where releasedate

-> between '2022-02-01' and '2022-02-28';
+----------------+-----------+-------------+
| mname | type | releasedate |
+----------------+-----------+-------------+
| Looop Lapeta | Thriller | 2022-02-01 |
| Badhai Do | Drama | 2022-02-04 |
| Shabaash Mithu | Biography | 2022-02-04 |
| Gehraiyaan | Romance | 2022-02-11 |
+----------------+-----------+-------------+
4 rows in set (0.000 sec)

P a g e | 37
4. Display the details of movies whose name ends with letter k.

mysql> select * from movies where mname like '%k';

+----------+--------+--------+-------------+----------------+--------------+
| movie_id | mname | Type | ReleaseDate | ProductionCost | BusinessCost |
+----------+--------+--------+-------------+----------------+--------------+
| M001 | Dahek | Action | 2022-01-26 | 1245000 | 1300000 |
| M002 | Attack | Action | 2022-01-28 | 1120000 | 1250000 |
+----------+--------+--------+-------------+----------------+--------------+
2 rows in set (0.001 sec)

5. Display the details of movies which is not released yet.

mysql> select * from movies where releasedate is null;

+----------+----------+--------+-------------+----------------+--------------+
| movie_id | mname | Type | ReleaseDate | ProductionCost | BusinessCost |
+----------+----------+--------+-------------+----------------+--------------+
| M007 | Border 2 | Action | NULL | 3211400 | 2500000 |
+----------+----------+--------+-------------+----------------+--------------+
1 row in set (0.000 sec)

6. Display the movie name type release date and production cost in the
descending order of production cost.

mysql> select mname, type, releasedate, productioncost from movies order by

-> productioncost desc;
+----------------+-----------+-------------+----------------+
| mname | type | releasedate | productioncost |
+----------------+-----------+-------------+----------------+
| Border 2 | Action | NULL | 3211400 |
| Dahek | Action | 2022-01-26 | 1245000 |
| Attack | Action | 2022-01-28 | 1120000 |
| Shabaash Mithu | Biography | 2022-02-04 | 1000000 |
| Badhai Do | Drama | 2022-02-04 | 720000 |
| Looop Lapeta | Thriller | 2022-02-01 | 250000 |
| Gehraiyaan | Romance | 2022-02-11 | 150000 |
+----------------+-----------+-------------+----------------+
7 rows in set (0.001 sec)

P a g e | 38
 19. Applying Group by, having and aggregate functions on previous table.

1. Display the number of movies for each type.

mysql> select type, count(*) from movies group by type;

+-----------+----------+
| type | count(*) |
+-----------+----------+
| Action | 3 |
| Biography | 1 |
| Drama | 1 |
| Romance | 1 |
| Thriller | 1 |
+-----------+----------+
5 rows in set (0.001 sec)

2. Display the number of unique movies.

mysql> select count( distinct type) from movies;

+-----------------------+
| count( distinct type) |
+-----------------------+
| 5 |
+-----------------------+
1 row in set (0.001 sec)

3. Display the maximum production cost for each movie type.

mysql> select type, max(productioncost) from movies group by type;

+-----------+---------------------+
| type | max(productioncost) |
+-----------+---------------------+
| Action | 3211400 |
| Biography | 1000000 |
| Drama | 720000 |
| Romance | 150000 |
| Thriller | 250000 |
+-----------+---------------------+
5 rows in set (0.001 sec)

4. Display the date of movies released latest.

mysql> select max(releasedate) from movies;

+------------------+
| max(releasedate) |
+------------------+
| 2022-02-11 |
+------------------+
1 row in set (0.000 sec)

P a g e | 39
5. Display the average business cost of movies for each type.

mysql> select type, avg(businesscost) from movies group by type;

+-----------+-------------------+
| type | avg(businesscost) |
+-----------+-------------------+
| Action | 1683333.3333 |
| Biography | 800000.0000 |
| Drama | 68000.0000 |
| Romance | 120000.0000 |
| Thriller | 300000.0000 |
+-----------+-------------------+
5 rows in set (0.001 sec)

6. Display the type and number of movies for each type where movie type is
more than two.

mysql> select type, count(*) from movies group by type having count(*)>2;
+--------+----------+
| type | count(*) |
+--------+----------+
| Action | 3 |
+--------+----------+
1 row in set (0.001 sec)

P a g e | 40
 20. Join Queries – Create two tables as follows and write given queries
below:
Table: artist
artist_id artist_name label_owner
101 Vishal Shekhar Sony Music
120 Vishal Mishra Zee Music
125 Udit Narayan T-Series
Table: song
song_id artist_id song_name
1111 101 Jhume Jo Pathan
1112 120 Khubsoorat
1113 125 Papa Kehte hai
1114 101 Swag Se Swagat
1115 120 Narazagi
1116 125 Phir Bhi Dil Hai Hindustani
1117 125 Mei Nikal Gaddi Leke
1118 120 Pehle Bhi Mein
1119 101 Jai Jai Shiv Shankar

1. Display the cartesian product of artist and song tables.

mysql> select * from artist, song;

P a g e | 41
2. Display the records of artist and song using equijoin.

mysql> select * from artist, song where artist.artist_id=song.artist_id;

3. Display the records of artist and song tables using natural join.

mysql> select * from artist natural join song;

4. Display artist name, label and songs of sony music company.

mysql> select artist_name, label_owner, song_name from artist, song where
-> artist.artist_id=song.artist_id and label_owner='sony music';

5. Display artist name, song name from artist and song which song starts with ‘p’.

mysql> select artist_name, song_name from artist a, song s where a.artist_id =

-> s.artist_id and s.song_name like 'p%';

P a g e | 42
 Part C – Python & MySQL Connectivity Programs
Interface Python with MySQL
21. Write a program to connect with mysql database and insert a record
into database.
database name : practical_2025, username: root, password: root, table: artist
Code:
import mysql.connector as my
cn=my.connect(host='localhost',user='root',passwd='root',databas
e='practical_2025')
cur=cn.cursor()
aid=int(input("Enter Artist ID:"))
aname=input("Enter Artist Name:")
lbl=input("Enter Label:")
cur.execute("insert into artist
values({},'{}','{}')".format(aid,aname,lbl))
cn.commit()
print("Record Inserted...")
cn.close()

Output:

P a g e | 43
 22. Write a program to connect with mysql database and update a record
into database.
database name : practical_2025, username: root, password: root, table: artist
Code:
import mysql.connector as my
cn=my.connect(host='localhost',user='root',passwd='root',databas
e='practical_2025')
cur=cn.cursor()
aid=int(input("Enter Artist ID:"))
aname=input("Enter Artist Name:")
lbl=input("Enter Label:")
cur.execute("update artist set artist_name='{}',label_owner='{}'
where artist_id={}".format(aname,lbl,aid))
cn.commit()
print("Record Updated...")
cn.close()

Output:

P a g e | 44
 23. Write a program to connect with mysql database and delete a record
into database.
database name : practical_2025, username: root, password: root, table: artist
Code:
import mysql.connector as my
cn=my.connect(host='localhost',user='root',passwd='root',databas
e='practical_2025')
cur=cn.cursor()
aid=int(input("Enter Artist ID to delete:"))
cur.execute("delete from artist where artist_id
={}".format(aname,lbl,aid))
cn.commit()
print("Record Deleted...")
cn.close()

Output:

P a g e | 45
 24. Write a program to connect with mysql database display record of
particular label under the artist is working.
database name : practical_2025, username: root, password: root, table: artist
Code:
import mysql.connector as my
cn=my.connect(host='localhost',user='root',passwd='root',databas
e ='practical_2025')
cur=cn.cursor()
lbl=input("Enter Label:")
cur.execute("select * from artist where
label_owner='{}'".format(lbl))
dt=cur.fetchall()
for i in dt:
print(i)
cn.close()

Output:

P a g e | 46
 Bibliography
1. www.wikipedia.com

2. www.w3schools.com

3. www.geeksforgeeks.org

4. www.stackoverflow.com

5. www.google.com

6. Computer Science with Python by Sumita Arora Class XII (Book)

P a g e | 47