Python Programming Lab (CSA524)
Assignment 3
❖ Write a program that takes a dictionary with integer values
and returns a sorted dictionary by values. Then, create a
reversed sorted dictionary and print both versions.
o Example Input: {'a': 10, 'b': 5, 'c': 7}
o Expected Output: Sorted dictionary: {'b': 5, 'c': 7, 'a': 10},
Reversed sorted dictionary: {'a': 10, 'c': 7, 'b': 5}
Program:
def sort_dict_by_values(input_dict):
# Sort the dictionary by values in ascending order
sorted_dict = dict(sorted(input_dict.items(), key=lambda item: item[1]))
# Sort the dictionary by values in descending order
reversed_sorted_dict = dict(sorted(input_dict.items(), key=lambda
item: item[1], reverse=True))
return sorted_dict, reversed_sorted_dict
# Example input
input_dict = {'a': 10, 'b': 5, 'c': 7}
# Get sorted and reversed sorted dictionaries
sorted_dict, reversed_sorted_dict = sort_dict_by_values(input_dict)
# Print the results
print("Sorted dictionary:", sorted_dict)
print("Reversed sorted dictionary:", reversed_sorted_dict)
Output:
❖ Write a program to generate a list of numbers from 1 to 100
that are divisible by both 3 and 5 using list comprehension.
o Expected Output: [15, 30, 45, 60, 75, 90]
Program:
# Generate list of numbers from 1 to 100 that are divisible by both 3 and
5
divisible_by_3_and_5 = [num for num in range(1, 101) if num % 3 == 0
and num % 5 == 0]
# Print the result
print(divisible_by_3_and_5)
Output:
❖ Create a program to find the union, intersection, difference,
and symmetric difference of two sets. Take two lists as input
and convert them into sets for the operations.
o Example Input: List1 = [1, 2, 3, 4], List2 = [3, 4, 5, 6]
o Expected Output: Union = {1, 2, 3, 4, 5, 6}, Intersection =
{3, 4}, Difference (List1 - List2) = {1, 2}, Symmetric Difference
= {1, 2, 5, 6}
Program:
def set_operations(list1, list2):
# Convert lists to sets
set1 = set(list1)
set2 = set(list2)
# Perform set operations
union = set1 | set2
intersection = set1 & set2
difference = set1 - set2
symmetric_difference = set1 ^ set2
return union, intersection, difference, symmetric_difference
# Example input
list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]
# Perform operations and get results
union, intersection, difference, symmetric_difference =
set_operations(list1, list2)
# Print the results
print("Union =", union)
print("Intersection =", intersection)
print("Difference (List1 - List2) =", difference)
print("Symmetric Difference =", symmetric_difference)
Output:
❖ Write a program to create a nested dictionary representing a
student database. The dictionary should have student names
as keys and each value should be another dictionary containing
student details like age, grade, and city. Allow users to input
details for at least 3 students and print the dictionary.
o Example Input: {"Alice": {"age": 21, "grade": "A", "city": "New
York"}, "Bob": {"age": 22, "grade": "B", "city": "Los Angeles"}}
Program:
# Function to create the student database
def create_student_database():
# Initialize an empty dictionary
student_db = {}
# Prompt the user to input details for 3 students
for _ in range(3):
name = input("Enter student name: ")
age = int(input(f"Enter age for {name}: "))
grade = input(f"Enter grade for {name}: ")
city = input(f"Enter city for {name}: ")
# Add details to the dictionary
student_db[name] = {
"age": age,
"grade": grade,
"city": city
return student_db
# Create the student database
student_database = create_student_database()
# Print the resulting nested dictionary
print("\nStudent Database:")
print(student_database)
Output:
❖ Write a program to sort a list of tuples based on the second
element of each tuple. Allow the user to input at least 5 tuples.
o Example Input: [(1, 2), (3, 1), (5, 7), (4, 4)]
o Expected Output: [(3, 1), (1, 2), (4, 4), (5, 7)]
Program:
# Function to input tuples from the user
def input_tuples(n):
tuples_list = []
for i in range(n):
print(f"Enter tuple {i+1} (format: x,y):")
x, y = map(int, input().split(','))
tuples_list.append((x, y))
return tuples_list
# Function to sort the list of tuples based on the second element
def sort_by_second_element(tuples_list):
return sorted(tuples_list, key=lambda x: x[1])
# Input at least 5 tuples from the user
n=5
tuples_list = input_tuples(n)
# Sort the list of tuples
sorted_tuples = sort_by_second_element(tuples_list)
# Print the result
print("Sorted list of tuples:", sorted_tuples)
Output:
❖ Write a program that takes a list of integers as input and
returns a dictionary with each unique integer as the key and its
frequency as the value.
o Example Input: [1, 2, 2, 3, 3, 3, 4]
o Expected Output: {1: 1, 2: 2, 3: 3, 4: 1}
Program:
def count_frequencies(int_list):
# Initialize an empty dictionary
frequency_dict = {}
# Count the frequency of each integer
for num in int_list:
if num in frequency_dict:
frequency_dict[num] += 1
else:
frequency_dict[num] = 1
return frequency_dict
# Example input
int_list = [1, 2, 2, 3, 3, 3, 4]
# Get the frequency dictionary
frequency_dict = count_frequencies(int_list)
# Print the result
print("Frequency dictionary:", frequency_dict)
Output:
❖ Write a program that takes a list of dictionaries and converts
it to a dictionary of lists.
o Example Input: [{"name": "Alice", "age": 21}, {"name":
"Bob", "age": 22}]
o Expected Output: {"name": ["Alice", "Bob"], "age": [21, 22]}
Program:
def convert_to_dict_of_lists(dict_list):
# Initialize an empty dictionary to store the result
result = {}
# Iterate over each dictionary in the list
for item in dict_list:
for key, value in item.items():
# Add values to the corresponding key in the result dictionary
if key in result:
result[key].append(value)
else:
result[key] = [value]
return result
# Example input
dict_list = [{"name": "Alice", "age": 21}, {"name": "Bob", "age": 22}]
# Convert to dictionary of lists
result_dict = convert_to_dict_of_lists(dict_list)
# Print the result
print("Dictionary of lists:", result_dict)
Output:
❖ Write a program to zip two lists into a list of tuples and then
unpack the tuples into separate lists for keys and values.
o Example Input: List1 = ["name", "age"], List2 = ["Alice", 21]
o Expected Output: Zipped: [("name", "Alice"), ("age", 21)],
Unpacked Keys: ["name", "age"], Unpacked Values: ["Alice", 21]
Program:
def zip_and_unpack(list1, list2):
# Zip the two lists into a list of tuples
zipped_list = list(zip(list1, list2))
# Unpack the tuples into separate lists for keys and values
keys, values = zip(*zipped_list)
return zipped_list, list(keys), list(values)
# Example input
list1 = ["name", "age"]
list2 = ["Alice", 21]
# Zip and unpack the lists
zipped_list, keys, values = zip_and_unpack(list1, list2)
# Print the results
print("Zipped:", zipped_list)
print("Unpacked Keys:", keys)
print("Unpacked Values:", values)
Output:
