1.
Functions (5 to 6 programs)
Program 1: Calculate Factorial
python
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
print(factorial(5)) # Output: 120
*Output:*
120
Program 2: Check Prime Number
python
def is_prime(n):
if n <= 1:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
print(is_prime(11)) # Output: True
print(is_prime(4)) # Output: False
*Output:*
True
False
Program 3: Fibonacci Series
python
def fibonacci(n):
fib_series = [0, 1]
while len(fib_series) < n:
fib_series.append(fib_series[-1] + fib_series[-2])
return fib_series
print(fibonacci(10)) # Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
*Output:*
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Program 4: Sum of List Elements
python
def sum_of_list(lst):
return sum(lst)
print(sum_of_list([1, 2, 3, 4, 5])) # Output: 15
*Output:*
15
Program 5: Reverse a String
python
def reverse_string(s):
return s[::-1]
print(reverse_string("Hello")) # Output: "olleH"
*Output:*
olleH
Program 6: Find Maximum Number in a List
python
def find_max(lst):
return max(lst)
print(find_max([1, 2, 3, 4, 5])) # Output: 5
*Output:*
2. File Handling (10 programs)
Program 1: Write to a File
python
def write_to_file(filename, content):
with open(filename, 'w') as file:
file.write(content)
write_to_file('example.txt', 'Hello, World!')
*Output:*
Content written to example.txt (Check the file "example.txt")
Program 2: Read from a File
python
def read_from_file(filename):
with open(filename, 'r') as file:
return file.read()
print(read_from_file('example.txt')) # Output: "Hello, World!"
*Output:*
Hello, World!
Program 3: Append to a File
python
def append_to_file(filename, content):
with open(filename, 'a') as file:
file.write(content)
append_to_file('example.txt', '\nAppend this text.')
*Output:*
Content appended to example.txt (Check the file "example.txt")
Program 4: Count Words in a File
python
def count_words(filename):
with open(filename, 'r') as file:
content = file.read()
words = content.split()
return len(words)
print(count_words('example.txt')) # Output will vary based on the file content
*Output:*
Output will vary (Count of words in "example.txt")
Program 5: Copy File Content
python
def copy_file(source, destination):
with open(source, 'r') as src:
content = src.read()
with open(destination, 'w') as dest:
dest.write(content)
copy_file('example.txt', 'example_copy.txt')
*Output:*
Content copied to example_copy.txt (Check the file "example_copy.txt")
Program 6: Count Lines in a File
python
def count_lines(filename):
with open(filename, 'r') as file:
return len(file.readlines())
print(count_lines('example.txt')) # Output will vary based on the file content
*Output:*
Output will vary (Count of lines in "example.txt")
Program 7: Read File Line by Line
python
def read_file_line_by_line(filename):
with open(filename, 'r') as file:
for line in file:
print(line.strip())
read_file_line_by_line('example.txt')
*Output:*
Hello, World!
Append this text.
Program 8: Write List to File
python
def write_list_to_file(filename, lst):
with open(filename, 'w') as file:
for item in lst:
file.write(f"{item}\n")
write_list_to_file('list.txt', [1, 2, 3, 4, 5])
*Output:*
List written to list.txt (Check the file "list.txt")
Program 9: Read List from File
python
def read_list_from_file(filename):
with open(filename, 'r') as file:
return [line.strip() for line in file]
print(read_list_from_file('list.txt')) # Output: [1, 2, 3, 4, 5]
*Output:*
['1', '2', '3', '4', '5']
Program 10: Find Longest Line in a File
python
def find_longest_line(filename):
with open(filename, 'r') as file:
longest = ''
for line in file:
if len(line) > len(longest):
longest = line
return longest.strip()
print(find_longest_line('example.txt')) # Output will vary based on the file
content
*Output:*
Append this text.
3. Data Structures (9 to 15 programs)
Program 1: Stack Implementation
python
class Stack:
def __init__(self):
self.items = []
def push(self, item):
self.items.append(item)
def pop(self):
if not self.is_empty():
return self.items.pop()
def is_empty(self):
return len(self.items) == 0
def peek(self):
if not self.is_empty():
return self.items[-1]
def size(self):
return len(self.items)
stack = Stack()
stack.push(1)
stack.push(2)
print(stack.pop()) # Output: 2
print(stack.peek()) # Output: 1
print(stack.size()) # Output: 1
*Output:*
2
1
1
Program 2: Queue Implementation
python
class Queue:
def __init__(self):
self.items = []
def enqueue(self, item):
self.items.insert(0, item)
def dequeue(self):
if not self.is_empty():
return self.items.pop()
def is_empty(self):
return len(self.items) == 0
def size(self):
return len(self.items)
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
print(queue.dequeue()) # Output: 1
print(queue.size()) # Output: 1
*Output:*
1
1
Program 3: Linked List Implementation
python
class Node:
def __init__(self, data=None):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = None
def insert(self, data):
new_node = Node(data)
new_node.next = self.head
self.head = new_node
def print_list(self):
current = self.head
while current:
print(current.data, end=' ')
current = current.next
ll = LinkedList()
ll.insert(1)
ll.insert(2)
ll.insert(3)
ll.print_list() # Output: 3 2 1
*Output:*
3 2 1
Program 4: Binary Search Tree Implementation
python
class TreeNode:
def __init__(self, key):
self.left = None
self.right = None
self.val = key
def insert(root, key):
if root is None:
return TreeNode(key)
else:
if root.val < key:
root.right = insert(root.right, key)
else:
root.left = insert(root.left, key)
return root
def inorder(root):
if root:
inorder(root.left)
print(root.val, end=' ')
inorder(root.right)
root = TreeNode(50)
root = insert(root, 30)
root = insert(root, 20)
root = insert(root, 40)
root = insert(root, 70)
root = insert(root, 60)
root = insert(root, 80)
inorder(root) # Output: 20 30 40 50 60 70 80
*Output:*
20 30 40 50 60 70 80
Program 5: Hash Table Implementation
python
class HashTable:
def __init__(self):
self.size = 10
self.table = [[] for _ in range(self.size)]
def hash_function(self, key):
return key % self.size
def insert(self, key, value):
hash_key = self.hash_function(key)
key_exists = False
bucket = self.table[hash_key]
for i, kv in enumerate(bucket):
k, v = kv
if key == k:
key_exists = True
break
if key_exists:
bucket[i] = (key, value)
else:
bucket.append((key, value))
def search(self, key):
hash_key = self.hash_function(key)
bucket = self.table[hash_key]
for k, v in bucket:
if key == k:
return v
return None
hash_table = HashTable()
hash_table.insert(1, 'One')
hash_table.insert(2, 'Two')
hash_table.insert(12, 'Twelve')
print(hash_table.search(1)) # Output: One
print(hash_table.search(12)) # Output: Twelve
print(hash_table.search(5)) # Output: None
*Output:*
One
Twelve
None
Program 6: Graph Representation (Adjacency List)
python
class Graph:
def __init__(self):
self.graph = {}
def add_edge(self, node, neighbor):
if node not in self.graph:
self.graph[node] = []
self.graph[node].append(neighbor)
def display(self):
for node in self.graph:
print(node, '->', ' -> '.join([str(neighbor) for neighbor in
self.graph[node]]))
graph = Graph()
graph.add_edge(0, 1)
graph.add_edge(0, 2)
graph.add_edge(1, 2)
graph.add_edge(2, 0)
graph.add_edge(2, 3)
graph.add_edge(3, 3)
graph.display()
*Output:*
0 -> 1 -> 2
1 -> 2
2 -> 0 -> 3
3 -> 3
Program 7: Breadth-First Search (BFS)
python
from collections import deque
def bfs(graph, start):
visited = set()
queue = deque([start])
while queue:
vertex = queue.popleft()
if vertex not in visited:
print(vertex, end=' ')
visited.add(vertex)
queue.extend(set(graph[vertex]) - visited)
graph = {
0: [1, 2],
1: [2],
2: [0, 3],
3: [3]
}
bfs(graph, 2) # Output: 2 0 3 1
*Output:*
2 0 3 1
Program 8: Depth-First Search (DFS)
python
def dfs(graph, start, visited=None):
if visited is None:
visited = set()
visited.add(start)
print(start, end=' ')
for next in set(graph[start]) - visited:
dfs(graph, next, visited)
graph = {
0: [1, 2],
1: [2],
2: [0, 3],
3: [3]
}
dfs(graph, 2) # Output: 2 0 1 3
*Output:*
2 0 1 3
Program 9: Insertion Sort
python
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr
print(insertion_sort([12, 11, 13, 5, 6])) # Output: [5, 6, 11, 12, 13]
*Output:*
[5, 6, 11, 12, 13]
4. Python-MySQL Connectivity (Airlines Context)
Program 1: Connect to MySQL Database
python
import mysql.connector
def connect_db():
return mysql.connector.connect(
host='localhost',
user='yourusername',
password='yourpassword',
database='yourdatabase'
)
db = connect_db()
if db.is_connected():
print('Connected to MySQL database')
*Output:*
Connected to MySQL database
Program 2: Create Tables
python
def create_tables():
db = connect_db()
cursor = db.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS Staff (
staff_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(255) NOT NULL,
position VARCHAR(255) NOT NULL,
salary DECIMAL(10, 2)
)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS Flights (
flight_id INT AUTO_INCREMENT PRIMARY KEY,
airline VARCHAR(255) NOT NULL,
destination VARCHAR(255) NOT NULL,
departure_time TIME NOT NULL
)
''')
db.close()
create_tables()
*Output:*
No output (Tables are created in the database)
Program 3: Insert Data into Tables
python
def insert_staff(name, position, salary):
db = connect_db()
cursor = db.cursor()
sql = 'INSERT INTO Staff (name, position, salary) VALUES (%s, %s, %s)'
val = (name, position, salary)
cursor.execute(sql, val)
db.commit()
db.close()
def insert_flight(airline, destination, departure_time):
db = connect_db()
cursor = db.cursor()
sql = 'INSERT INTO Flights (airline, destination, departure_time) VALUES (%s,
%s, %s)'
val = (airline, destination, departure_time)
cursor.execute(sql, val)
db.commit()
db.close()
insert_staff('Alice Brown', 'Pilot', 95000)
insert_staff('Bob Smith', 'Flight Attendant', 45000)
insert_flight('Air India', 'New York', '10:30:00')
insert_flight('Lufthansa', 'Berlin', '14:00:00')
*Output:*
No output (Data is inserted into the database)
Program 4: Fetch Data from Tables
python
def fetch_staff():
db = connect_db()
cursor = db.cursor()
cursor.execute('SELECT * FROM Staff')
result = cursor.fetchall()
for row in result:
print(row)
db.close()
def fetch_flights():
db = connect_db()
cursor = db.cursor()
cursor.execute('SELECT * FROM Flights')
result = cursor.fetchall()
for row in result:
print(row)
db.close()
fetch_staff()
fetch_flights()
*Output:*
(1, 'Alice Brown', 'Pilot', 95000.00)
(2, 'Bob Smith', 'Flight Attendant', 45000.00)
(1, 'Air India', 'New York', '10:30:00')
(2, 'Lufthansa', 'Berlin', '14:00:00')
Program 5: Update Data in Tables
python
def update_staff_salary(name, new_salary):
db = connect_db()
cursor = db.cursor()
sql = 'UPDATE Staff SET salary = %s WHERE name = %s'
val = (new_salary, name)
cursor.execute(sql, val)
db.commit()
db.close()
def update_flight_time(flight_id, new_time):
db = connect_db()
cursor = db.cursor()
sql = 'UPDATE Flights SET departure_time = %s WHERE flight_id = %s'
val = (new_time, flight_id)
cursor.execute(sql, val)
db.commit()
db.close()
update_staff_salary('Alice Brown', 100000)
update_flight_time(1, '11:00:00')
*Output:*
No output (Data is updated in the database)
Program 6: Delete Data from Tables
python
def delete_staff(name):
db = connect_db()
cursor = db.cursor()
sql = 'DELETE FROM Staff WHERE name = %s'
val = (name,)
cursor.execute(sql, val)
db.commit()
db.close()
def delete_flight(flight_id):
db = connect_db()
cursor = db.cursor()
sql = 'DELETE FROM Flights WHERE flight_id = %s'
val = (flight_id,)
cursor.execute(sql, val)
db.commit()
db.close()
delete_staff('Bob Smith')
delete_flight(2)
*Output:*
No output (Data is deleted from the database)
5. SQL Queries (Airlines Context)
Table 1: Staff
sql
CREATE TABLE Staff (
staff_id INT PRIMARY KEY,
name VARCHAR(255),
position VARCHAR(255),
salary DECIMAL(10, 2)
);
INSERT INTO Staff (staff_id, name, position, salary) VALUES
(1, 'Alice Brown', 'Pilot', 95000.00),
(2, 'Bob Smith', 'Flight Attendant', 45000.00),
(3, 'Charlie Davis', 'Co-pilot', 70000.00);
##### Queries
1. *Select all staff members:*
sql
SELECT * FROM Staff;
*Output:*
+----------+--------------+------------------+----------+
| staff_id | name | position | salary |
+----------+--------------+------------------+----------+
| 1 | Alice Brown | Pilot | 95000.00 |
| 2 | Bob Smith | Flight Attendant | 45000.00 |
| 3 | Charlie Davis| Co-pilot | 70000.00 |
+----------+--------------+------------------+----------+
2. *Find staff with salary greater than 60,000:*
sql
SELECT * FROM Staff WHERE salary > 60000;
*Output:*
+----------+--------------+------------------+----------+
| staff_id | name | position | salary |
+----------+--------------+------------------+----------+
| 1 | Alice Brown | Pilot | 95000.00 |
| 3 | Charlie Davis| Co-pilot | 70000.00 |
+----------+--------------+------------------+----------+
3. *Count total number of staff:*
sql
SELECT COUNT(*) FROM Staff;
*Output:*
+----------+
| COUNT(*) |
+----------+
| 3 |
+----------+
4. *Find the average salary of staff:*
sql
SELECT AVG(salary) FROM Staff;
*Output:*
+-------------+
| AVG(salary) |
+-------------+
| 70000.0000 |
+-------------+
5. *Find staff by position:*
sql
SELECT * FROM Staff WHERE position = 'Pilot';
*Output:*
+----------+--------------+----------+----------+
| staff_id | name | position | salary |
+----------+--------------+----------+----------+
| 1 | Alice Brown | Pilot | 95000.00 |
+----------+--------------+----------+----------+
Table 2: Flights
sql
CREATE TABLE Flights (
flight_id INT PRIMARY KEY,
airline VARCHAR(255),
destination VARCHAR(255),
departure_time TIME
);
INSERT INTO Flights (flight_id, airline, destination, departure_time) VALUES
(1, 'Air India', 'New York', '10:30:00'),
(2, 'Lufthansa', 'Berlin', '14:00:00'),
(3, 'Emirates', 'Dubai', '09:00:00');
##### Queries
1. *Select all flights:*
sql
SELECT * FROM Flights;
*Output:*
+----------+-----------+-------------+----------------+
| flight_id| airline | destination | departure_time |
+----------+-----------+-------------+----------------+
| 1 | Air India | New York | 10:30:00 |
| 2 | Lufthansa | Berlin | 14:00:00 |
| 3 | Emirates | Dubai | 09:00:00 |
+----------+-----------+-------------+----------------+
2. *Find flights to a specific destination:*
sql
SELECT * FROM Flights WHERE destination = 'Berlin';
*Output:*
+----------+-----------+-------------+----------------+
| flight_id| airline | destination | departure_time |
+----------+-----------+-------------+----------------+
| 2 | Lufthansa | Berlin | 14:00:00 |
+----------+-----------+-------------+----------------+
3. *Count total number of flights:*
sql
SELECT COUNT(*) FROM Flights;
*Output:*
+----------+
| COUNT(*) |
+----------+
| 3 |
+----------+
4. *Find the earliest departure time:*
sql
SELECT MIN(departure_time) FROM Flights;
*Output:*
+--------------------+
| MIN(departure_time)|
+--------------------+
| 09:00:00 |
+--------------------+
5. *Find flights by airline:*
sql
SELECT * FROM Flights WHERE airline = 'Emirates';
*Output:*
+----------+-----------+-------------+----------------+
| flight_id| airline | destination | departure_time |
+----------+-----------+-------------+----------------+
| 3 | Emirates | Dubai | 09:00:00 |
+----------+-----------+-------------+----------------+
