1.

Create a Python program to define a class `MyClass` with attributes `name` and `age`, instantiate the class, and use the instance to access these
attributes. (Difficulty: Easy)

class MyClass:
def __init__(self, name, age):
self.name = name
self.age = age

# Instantiate the class

my_object = MyClass("Alice", 25)

# Access attributes
print(f"Name: {my_object.name}, Age: {my_object.age}")

2. Write a Python program to define a class `Car` with a default constructor that initializes attributes for `brand` and `year`. Include a method
`display_info` to print the car's details. Create an object of the class and call the method to display the information. (Difficulty: Easy)

class Car:
def __init__(self):
self.brand = "Toyota"
self.year = 2020

def display_info(self):
print(f"Brand: {self.brand}, Year: {self.year}")

# Create an object and call the method

my_car = Car()
my_car.display_info()
3. Develop a Python program that defines a class `Animal` with a constructor accepting `name` and `age` as parameters, along with a method
`display_info` to print these details. Create an instance of the class and call the method to display the animal's information. (Difficulty: Easy)

class Animal:
def __init__(self, name, age):
self.name = name
self.age = age

def display_info(self):
print(f"Name: {self.name}, Age: {self.age}")

# Create an instance and call the method

my_animal = Animal("Dog", 5)
my_animal.display_info()

4. Write a Python program to demonstrate the functionality of the `Bank` class by creating an instance with attributes `name`, `accno`, and `phno`.
Showcase how to access its public, private, and protected attributes. (Difficulty: Easy)

class Bank:
def __init__(self, name, accno, phno):
self.name = name # Public attribute
self._accno = accno # Protected attribute
self.__phno = phno # Private attribute

def get_private_phno(self):
return self.__phno

@property
def private_phno(self):
return self.__phno

@private_phno.setter
def private_phno(self, value):
 if len(str(value))==10 and str(value).isdigit(): # Example condition to control setting
self.__phno = value
else:
raise ValueError("Phno to contain 10 digit")

# Instantiate the class

bank_account = Bank("John Doe", "123456", "9876543210")
# Access attributes
print(f"Name: {bank_account.name}") # Public
print(f"Account Number: {bank_account._accno}") # Protected
#Method 1 - Access the private attribute using the instance method
print(f"Phone Number(using instance method): {bank_account.get_private_phno()}") # Private (via method)

#Method 2 - Access the private attribute using the mangled name

print(f"Phone Number(Using mangled name): {bank_account._Bank__phno}") # Private (via name mangling)

#Method 3 - Access the private attribute using the decorator @property and @attributename.setter
# Access private attribute via property (getter)
print(f"Phone Number(Using decorator property): {bank_account.private_phno}")

# Set private attribute via property (setter)

bank_account.private_phno = "9000290001"
print(f"Updated Phone Number(Using decorator property setter): {bank_account.private_phno}")

5. Create a Python program to define a class `Student` with private attributes `name` and `regno`. Instantiate an object of the class, access its
private attributes, and update the `name` attribute. (Difficulty: Medium)

class Student:
def __init__(self, name, regno):
self.__name = name # Private attribute
self.__regno = regno

def get_name(self):
 return self.__name

def set_name(self, new_name):

self.__name = new_name

# Create an instance
student = Student("Amir", "12345")

#Method1 - Using get and set instance methods

# Access and update private attribute
print(f"Original Name: {student.get_name()}")
student.set_name("Ali")
print(f"Updated Name: {student.get_name()}")

#Method2 - Using Name mangling

print(f"Original Name: {student._Student_name}")
student._Student__name = "Ali"
print(f"Updated Name: {student._Student_name}")

6. Write a Python program to define a class `Car` with attributes `make`, `model`, `mileage`, and `price`. Include methods to display the car's details,
start and stop the car, and update its price. Create two car objects and demonstrate the functionality by calling their methods. (Difficulty: Easy)

class Car:
def __init__(self, make, model, mileage, price):
self.make = make
self.model = model
self.mileage = mileage
self.price = price

def display_details(self):
print(f"Make: {self.make}, Model: {self.model}, Mileage: {self.mileage}, Price: {self.price}")

def start(self):
print(f"The {self.make} {self.model} is starting.")
 def stop(self):
print(f"The {self.make} {self.model} is stopping.")

def update_price(self, new_price):

self.price = new_price
print(f"The price of the car has been updated to {self.price}.")

# Create car objects

car1 = Car("Toyota", "Corolla", 30000, 20000)
car2 = Car("Honda", "Civic", 25000, 22000)

# Demonstrate functionality
car1.display_details()
car1.start()
car1.update_price(18000)
car1.stop()

car2.display_details()

7. Create a Python program to define a class `Movie` with attributes `Heroname` and `year`. Instantiate the class and use the instance to access
these attributes. (Difficulty: Easy)

class Movie:
def __init__(self, heroname, year):
self.heroname = heroname
self.year = year

# Instantiate and access attributes

movie = Movie("John Wick", 2014)
print(f"Hero Name: {movie.heroname}, Year: {movie.year}")
8. Write a Python program to create a class `Student` with a protected attribute `_name` initialized to `"Amir"` in the constructor. Create an object of
the class and print the protected attribute. (Difficulty: Easy)

class Student:
def __init__(self):
self._name = "Amir" # Protected attribute

# Create an object and print the protected attribute

student = Student()
print(f"Protected Name: {student._name}")

9. Develop a Python program to define a class `College` with a private attribute `__name`, initialized through the constructor. Instantiate an object of
the class with the name `"Presidency"` and access the private attribute using an instance method. (Difficulty: Easy)

class College:
def __init__(self, name):
self.__name = name # Private attribute

def get_name(self):
return self.__name

# Instantiate and access private attribute using method

college1 = College("Presidency")
#Method 1 - Access the private attribute using the instance method
print(f"College Name: {college1.get_name()}")

#Method 2 - Access the private attribute using the mangled name

print(f"College Name(Using mangled name): {college1._College__name}") # Private (via name mangling)

10. Write a Python program to create a class `Sms` with three attributes (`source1`, `source2`, and `source3`) representing different social media
sources. These should be public, protected, and private, respectively. Initialize them to `"Whatsapp"`, `"Instagram"`, and `"Facebook"`. Create an
instance of the class and print the values of each attribute. (Difficulty: Medium)
class Sms:
def __init__(self):
self.source1 = "Whatsapp" # Public attribute
self._source2 = "Instagram" # Protected attribute
self.__source3 = "Facebook" # Private attribute

def get_private_source(self):
return self.__source3

# Create an instance and print attribute values

sms1 = Sms()
print(f"Public Source: {sms1.source1}")
print(f"Protected Source: {sms1._source2}")
#Method 1 - Access the private attribute using the instance method
print(f"Private Source: {sms1.get_private_source()}")

#Method 2 - Access the private attribute using the mangled name

print(f"Phone Number(Using mangled name): {sms1._Sms__source3}") # Private (via name mangling)

11. Create a Python program defining a class `Person` with private attributes `__name` and `__age`. Implement getter and setter methods for both,
with validation to ensure `age` is positive. Instantiate the class with `name = "John"` and `age = 25`, print the values using getters, update `age` to
30 using the setter, and print the updated age. (Difficulty: Easy)

class Person:
def __init__(self, name, age):
self.__name = name
self.__age = age

def get_name(self):
return self.__name

def get_age(self):
 return self.__age

def set_name(self, name):

self.__name = name

def set_age(self, age):

if age > 0:
self.__age = age
else:
print("Age must be positive.")

# Instantiate the class and use getters and setters

person1 = Person("John", 25)
print(f"Name: {person1.get_name()}, Age: {person1.get_age()}")

# Update age
person1.set_age(30)
print(f"Updated Age: {person1.get_age()}")

person2 = Person("Wick", 55)

#Method 2 - Access the private attribute using the mangled name
print(f"Name: {person2.get_name()}, Age: {person2._Person__age}")
# Update age
person2._Person__age=60
print(f"Updated Age(Using mangled name): {person2._Person__age}") # Private (via name mangling)

12. Demonstrate the functionality of the `Bank` class by creating an instance with attributes `name`, `accno`, and `phno`. Show how to access
public, protected, and private attributes, including a method to retrieve the private attribute. (Difficulty: Easy)

class Bank:
def __init__(self, name, accno, phno):
self.name = name # Public attribute
self._accno = accno # Protected attribute
 self.__phno = phno # Private attribute

def get_private_phno(self):
return self.__phno

@property
def private_phno(self):
return self.__phno

# Instantiate and access attributes

bank1 = Bank("John Doe", "123456", "9876543210")
print(f"Name: {bank1.name}") # Public
print(f"Account Number: {bank1._accno}") # Protected
#Method 1 - Access the private attribute using the instance method
print(f"Phone Number: {bank1.get_private_phno()}") # Private (via method)

#Method 2 - Access the private attribute using the mangled name

print(f"Phone Number(Using mangled name): {bank1._Bank__phno}") # Private (via name mangling)

#Method 3 - Access the private attribute using the decorator @property and @attributename.setter
# Access private attribute via property (getter)
print(f"Phone Number(Using decorator property): {bank1.private_phno}")

13.Write a Python program to define an `Employee` class with the following:

● 1. A non-parameterized constructor that initializes attributes (`employee_id`, `name`, `department`, and `salary`) to `None` or default values.
● 2. A public method `set_employee_details()` to set the attribute values using the provided parameters.
● 3. A public method `display_employee_details()` to display the employee's details.

Create two objects of the `Employee` class. Use `display_employee_details()` to check the initial attribute values. Then, use
`set_employee_details()` to update the attribute values and call `display_employee_details()` again to verify the updated values. (Difficulty: Easy)

class Person:
 def __init__(self, name, age):
self.__name = name
self.__age = age

def get_name(self):
return self.__name

def get_age(self):
return self.__age

def set_name(self, name):

self.__name = name

def set_age(self, age):

if age > 0:
self.__age = age
else:
print("Age must be positive.")

# Instantiate the class and use getters and setters

person1 = Person("John", 25)
print(f"Name: {person1.get_name()}, Age: {person1.get_age()}")

# Update age
person1.set_age(30)
print(f"Updated Age: {person1.get_age()}")

person2 = Person("Wick", 55)

#Method 2 - Access the private attribute using the mangled name
print(f"Name: {person2.get_name()}, Age: {person2._Person__age}")
# Update age
person2._Person__age=60
print(f"Updated Age(Using mangled name): {person2._Person__age}") # Private (via name mangling)
14. Develop a Python program to define a `Student` class with the following:
● 1. A non-parameterized constructor that initializes attributes (`student_id`, `name`, and `grade`) to `None` or default values.
● 2. A public method `set_student_details()` to set the attribute values using the provided parameters.
● 3. A public method `display_student_details()` to display the student's details.

Create two objects of the `Student` class. Call `display_student_details()` to check the initial values. Use `set_student_details()` to update the
attributes, then call `display_student_details()` again to verify the updates. (Difficulty: Easy)

class Student:
def __init__(self):
self.student_id = None
self.name = None
self.grade = None

def set_student_details(self, student_id, name, grade):

self.student_id = student_id
self.name = name
self.grade = grade

def display_student_details(self):
print(f"ID: {self.student_id}, Name: {self.name}, Grade: {self.grade}")

# Create objects and demonstrate functionality

student1 = Student()
student2 = Student()

# Initial values
student1.display_student_details()
student2.display_student_details()

# Set and display updated details

student1.set_student_details(1, "Charlie", "A")
student2.set_student_details(2, "Diana", "B")

student1.display_student_details()
student2.display_student_details()

15. Create a Python program that defines a `Person` class with:

● 1. A non-parameterized constructor to initialize attributes (`name`, `age`, `address`, and `phone_number`) to `None` or default values.
● 2. A public method `set_person_details()` to set the attribute values using provided parameters.
● 3. A public method `display_person_details()` to display the person's details.

Instantiate two objects of the `Person` class. Use `display_person_details()` to check the initial values, then use `set_person_details()` to update the
attributes and verify the updates using `display_person_details()`. (Difficulty: Easy)

class Person:
def __init__(self):
self.name = None
self.age = None
self.address = None
self.phone_number = None

def set_person_details(self, name, age, address, phone_number):

self.name = name
self.age = age
self.address = address
self.phone_number = phone_number

def display_person_details(self):
print(f"Name: {self.name}, Age: {self.age}, Address: {self.address}, Phone: {self.phone_number}")

# Create objects and demonstrate functionality

person1 = Person()
person2 = Person()
# Initial values
person1.display_person_details()
person2.display_person_details()

# Set and display updated details

person1.set_person_details("Eve", 30, "123 Main St", "123-456-7890")
person2.set_person_details("Frank", 40, "456 Elm St", "987-654-3210")

person1.display_person_details()
person2.display_person_details()

16. Write a Python program to define a `Book` class with the following:
● 1. Attributes: `title` (public), `author` (protected), and `publisher` (private).
● 2. Use a parameterized constructor to initialize these attributes.
● 3. Access and display each attribute, demonstrating how public, protected, and private attributes can be accessed.(Difficulty: Hard)

class Book:
def __init__(self, title, author, publisher):
self.title = title # Public attribute
self._author = author # Protected attribute
self.__publisher = publisher # Private attribute

def get_publisher(self):
return self.__publisher

@property
def private_publisher(self):
return self.__publisher

@private_publisher.setter
def private_publisher(self, value):
if len(str(value))>0 or str(value).isalpha(): # Example condition to control setting
self.__publisher = value
 else:
raise ValueError("Publisher to contain only alphabets no special characters and numbers allowed")

# Instantiate and access attributes

book1 = Book("1984", "George Orwell", "Secker & Warburg")
print(f"Title: {book1.title}") # Public
print(f"Author: {book1._author}") # Protected
#Method 1 - Access the private attribute using the instance method
print(f"Publisher: {book1.get_publisher()}") # Private (via method)

#Method 2 - Access the private attribute using the mangled name

print(f"Publisher(Using mangled name): {book1._Book__publisher}") # Private (via name mangling)

#Method 3 - Access the private attribute using the decorator @property and @attributename.setter
# Access private attribute via property (getter)
print(f"Publisher(Using decorator property): {book1.private_publisher}")

# Set private attribute via property (setter)

book1.private_publisher = "Penguin"
print(f"Updated Publisher(Using decorator property setter): {book1.private_publisher}")

17. Create a Python program to define an `Employee` class with the following:
● 1. Attributes: `employee_id`, `name`, `department`, and `salary`.
● 2. A method `calculate_salary()` that calculates the total salary based on:
○ - Required input: basic salary.
○ - Optional inputs: bonus and overtime hours.
○ - Overtime pay is calculated at a rate of INR 750 per hour.
○ - If only the basic salary is provided, the total salary equals the basic salary. If bonus and/or overtime are provided, include them in
the total salary.(Difficulty: Medium)

class Employee:
def __init__(self, employee_id, name, department, salary):
self.employee_id = employee_id
self.name = name
 self.department = department
self.salary = salary

def calculate_salary(self, basic_salary, bonus=0, overtime_hours=0):

overtime_pay = overtime_hours * 750
total_salary = basic_salary + bonus + overtime_pay
return total_salary

# Create an employee object and calculate salaries

employee = Employee(101, "Alice", "IT", 50000)
print(f"Total Salary (Basic only): {employee.calculate_salary(50000)}")
print(f"Total Salary (With Bonus and Overtime): {employee.calculate_salary(50000, 10000, 5)}")

18. Write a Python program to define a `Book` class with the following:
● 1. A non-parameterized constructor that initializes attributes to `None`.
● 2. A public method `set_book_details()` to set attribute values using the provided parameters.
● 3. A public method `display_book_details()` to display the book's details.
Create two objects of the `Book` class. Call `display_book_details()` to check the initial values, then use `set_book_details()` to update the attributes
and call `display_book_details()` again to verify the updates. (Difficulty: Easy)
class Book:
def __init__(self):
self.title = None
self.author = None
self.publisher = None

def set_book_details(self, title, author, publisher):

self.title = title
self.author = author
self.publisher = publisher

def display_book_details(self):
print(f"Title: {self.title}, Author: {self.author}, Publisher: {self.publisher}")
# Create two book objects
book1 = Book()
book2 = Book()

# Initial values
book1.display_book_details()
book2.display_book_details()

# Update and display details

book1.set_book_details("1984", "George Orwell", "Secker & Warburg")
book2.set_book_details("To Kill a Mockingbird", "Harper Lee", "J.B. Lippincott & Co.")
book1.display_book_details()
book2.display_book_details()

19. Write a Python program to define a `Book` class with:

● 1. An constructor method to initialize the `title`, `author`, and `price` attributes.
● 2. An instance method `display_book_details()` to display the book's attributes.
● 3. A class variable `no_of_books` to track the number of book objects created.
● 4. A class method `get_no_of_books_created()` to return the count of book objects created.

Create multiple book objects and demonstrate the functionality of class and instance methods. (Difficulty: Medium)
class Book:
no_of_books = 0 # Class variable

def __init__(self, title, author, price):

self.title = title
self.author = author
self.price = price
Book.no_of_books += 1

def display_book_details(self):
print(f"Title: {self.title}, Author: {self.author}, Price: {self.price}")

@classmethod
 def get_no_of_books_created(cls):
return cls.no_of_books

# Create book objects and demonstrate functionality

book1 = Book("1984", "George Orwell", 500)
book2 = Book("To Kill a Mockingbird", "Harper Lee", 600)

book1.display_book_details()
book2.display_book_details()

print(f"Number of books created: {Book.get_no_of_books_created()}")

20. Develop a Python program to define a `Book` class with:

● 1. An constructor method to initialize the `title`, `author`, and `price` attributes.
● 2. An instance method `display_book_details()` to display the book's attributes.
● 3. A static method `validate_price()` to ensure the price is valid (non-negative and greater than zero).
● 4. An instance method `check_if_discount_available()` to return `True` if a discount is available (price > 999), otherwise `False`.
Create multiple book objects and demonstrate the functionality of instance, static, and class methods. (Difficulty: Hard)

class Book:
no_of_books = 0 # Class variable

def __init__(self, title, author, price):

self.title = title
self.author = author
self.price = price
Book.no_of_books += 1

def display_book_details(self):
print(f"Title: {self.title}, Author: {self.author}, Price: {self.price}")

@staticmethod
def validate_price(price):
return price > 0
 def check_if_discount_available(self):
return self.price > 999

@classmethod
def get_no_of_books_created(cls):
return cls.no_of_books

# Create book objects and demonstrate functionality

book1 = Book("1984", "George Orwell", 1200)
book2 = Book("To Kill a Mockingbird", "Harper Lee", 800)

book1.display_book_details()
book2.display_book_details()

# Validate prices
print(f"Is the price of book1 valid? {Book.validate_price(book1.price)}")
print(f"Is the price of book2 valid? {Book.validate_price(book2.price)}")

# Check for discounts

print(f"Does book1 have a discount? {book1.check_if_discount_available()}")
print(f"Does book2 have a discount? {book2.check_if_discount_available()}")

# Get the number of books created

print(f"Number of books created: {Book.get_no_of_books_created()}")