Python Programs for Oops

Python programs for Object-Oriented Programming (OOP) concepts that are
commonly covered in labs:
### 1. **Class and Object**
```python
# Define a class
class Student:
def __init__(self, name, age, grade):
self.name = name
self.age = age
self.grade = grade
def display_info(self):
print(f"Name: {self.name}, Age: {self.age}, Grade: {self.grade}")
# Create an object of the class

student1 = Student("John", 20, "A")
student1.display_info()
```
### 2. **Encapsulation**
```python
class Employee:
def __init__(self, name, salary):
self.__name = name # Private attribute
self.__salary = salary # Private attribute
def get_info(self):
return f"Employee: {self.__name}, Salary: {self.__salary}"
def set_salary(self, new_salary):

if new_salary > 0:
self.__salary = new_salary
else:
print("Invalid salary!")
emp = Employee("Alice", 50000)

print(emp.get_info())
emp.set_salary(55000)
print(emp.get_info())
```
### 3. **Inheritance**
```python
# Parent class
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
print(f"{self.name} makes a sound.")
# Child class
class Dog(Animal):
def speak(self):
print(f"{self.name} barks.")
# Child class
class Cat(Animal):
def speak(self):
print(f"{self.name} meows.")
# Create instances
dog = Dog("Buddy")
cat = Cat("Kitty")
dog.speak()
cat.speak()
```
### 4. **Polymorphism**
```python
class Bird:
def sound(self):
print("Birds make sound")
class Sparrow(Bird):
def sound(self):
print("Sparrow chirps")
class Pigeon(Bird):
def sound(self):
print("Pigeon coos")
def make_sound(bird):
bird.sound()
sparrow = Sparrow()
pigeon = Pigeon()
make_sound(sparrow)
make_sound(pigeon)
```
### 5. **Abstraction (Using Abstract Base Classes)**
```python
from abc import ABC, abstractmethod
# Abstract class
class Shape(ABC):
@abstractmethod
def area(self):
pass
# Subclass implementing the abstract method

class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius ** 2
# Create objects
rect = Rectangle(5, 3)
circle = Circle(7)
print(f"Rectangle area: {rect.area()}")

print(f"Circle area: {circle.area()}")
```
### 6. **Method Overloading (Using Default Arguments)**
```python
class MathOperations:
def add(self, a=None, b=None, c=None):
if a is not None and b is not None and c is not None:
return a + b + c
elif a is not None and b is not None:
return a + b
else:
return "Insufficient arguments"
# Create an object
math_op = MathOperations()
print(math_op.add(10, 20))
print(math_op.add(10, 20, 30))
print(math_op.add(10))
```
### 7. **Method Overriding**
```python
class Parent:
def show(self):
print("This is the parent class.")
class Child(Parent):
def show(self):
print("This is the child class overriding the parent class.")
# Create objects
parent_obj = Parent()
child_obj = Child()
parent_obj.show()
child_obj.show()
```
### 8. **Constructor Overloading (Using Multiple `__init__` with Default

Values)**
```python
class Person:
def __init__(self, name=None, age=None):
if name is not None and age is not None:
print(f"Name: {name}, Age: {age}")
elif name is not None:
print(f"Name: {name}")
else:
print("No information provided")
# Create objects with different constructors

person1 = Person("John", 30)
person2 = Person("Alice")
person3 = Person()
```
### 9. **Multiple Inheritance**
```python
class Father:
def skill(self):
print("Father is good at painting.")
class Mother:
def skill(self):
print("Mother is good at singing.")
class Child(Father, Mother):
def skill(self):
super().skill() # Calls skill method from Father due to method resolution
order
# Create object
child = Child()
child.skill()
```
### 10. **Operator Overloading**
```python
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
# Overloading + operator
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __str__(self):
return f"Point({self.x}, {self.y})"
# Create objects
p1 = Point(2, 3)
p2 = Point(4, 5)
# Add objects
p3 = p1 + p2
print(p3)
```

Python Programs for Oops

Uploaded by

Python Programs for Oops

Uploaded by

Python programs for Object-Oriented Programming (OOP) concepts that are

commonly covered in labs:

### 1. Class and Object

# Create an object of the class

def set_salary(self, new_salary):

emp = Employee("Alice", 50000)

### 5. Abstraction (Using Abstract Base Classes)

# Subclass implementing the abstract method

print(f"Rectangle area: {rect.area()}")

### 6. Method Overloading (Using Default Arguments)

### 7. Method Overriding

### 8. **Constructor Overloading (Using Multiple `init` with Default

# Create objects with different constructors

### 9. Multiple Inheritance

### 10. Operator Overloading

You might also like