1.

Class and Object

• A class is like a blueprint or template which defines how something should be.

• It contains attributes (data) and methods (functions) that describe a real-world

entity.

• An object is a real instance of a class — it holds actual values and performs actions.

• For example, a Car class can have objects like BMW, Tesla that have different colors
and speeds.

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

p1 = person("John", 36)

print(p1.name)
print(p1.age)

John
36

#example - 2
class car:
def __init__(self,brand,color,speed):
self.brand = brand
self.color = color
self.speed = speed
def show(self):
return self.speed,self.brand,self.color

c1 = car('bmw','grey',300)

c1.brand

{"type":"string"}

2. Constructor (init())
• A constructor is a special function in Python which automatically runs when an
object is created.

• Its purpose is to initialize the object's variables (like setting a name or age when a
student is created).
 • In Python, the constructor is always named init() and it's the first method that gets
triggered.

• It helps in automatically setting up the object with necessary data as soon as it's
made.

# Example 1
class Student:
def __init__(self, name, roll):
self.name = name
self.roll = roll

s1 = Student("Aman", 101)
print(s1.name, s1.roll)

Aman 101

# Example 2
class Book:
def __init__(self, title, author):
print("Constructor called")
self.title = title
self.author = author

b1 = Book("Python 101", "John")

print(b1.title, "-", b1.author)

Constructor called
Python 101 - John

3. Encapsulation
• Encapsulation means binding data and methods together so that access to data is
controlled.

• It hides the internal details of how something works and allows access only via
methods.

• We use _ for protected and __ (double underscore) for private variables in Python.

• For example, you cannot directly access your bank account balance — you need to
go through proper methods.

class Bank:
def __init__(self, name, balance):
self.name = name
if not isinstance(balance, int) or balance < 0:
raise ValueError("Initial balance must be a non-negative
integer")
 self.__balance = balance

def get(self):
return self.__balance

def set(self, new_balance):

if not isinstance(new_balance, int):
raise TypeError("Balance must be an integer")
if new_balance < 0:
raise ValueError("Balance must be positive")
self.__balance = new_balance

person1 = Bank("Rohit", 10000)

person1.set(50000)
print(person1.get()) # Output: 50000

50000

person1.set('five')

----------------------------------------------------------------------
-----
TypeError Traceback (most recent call
last)
<ipython-input-31-1470266873> in <cell line: 0>()
----> 1 person1.set('five')

<ipython-input-25-3308413514> in set(self, new_balance)

11 def set(self, new_balance):
12 if not isinstance(new_balance, int):
---> 13 raise TypeError("Balance must be an integer")
14 if new_balance < 0:
15 raise ValueError("Balance must be positive")

TypeError: Balance must be an integer

print(person1.get())

50000

4. Inheritance
• Inheritance allows a new class (called child class) to use the properties and methods
of an existing class (called parent class).

• This avoids code duplication and makes it easy to reuse and extend functionality.

• Child classes can add new features or even modify (override) inherited ones.
 • For example, a Dog class can inherit common behavior from Animal class and add its
own features like bark().

# Example 1 - Single Inheritance

class Animal:
def speak(self):
print("Animal speaks")

class Dog(Animal):
def bark(self):
print("Dog barks")

d = Dog()
d.speak()
d.bark()

Animal speaks
Dog barks

# Example 2 - Multilevel Inheritance

class Grandparent:
def house(self):
print("Grandparent's house")

class Parent(Grandparent):
def car(self):
print("Parent's car")

class Child(Parent):
def bike(self):
print("Child's bike")

c = Child()
c.house()
c.car()
c.bike()

Grandparent's house
Parent's car
Child's bike

5. Polymorphism
• Polymorphism means same function or method name behaving differently based on
the object that calls it.

• It makes your code flexible, reusable, and easier to manage, especially in large
applications.
 • Python supports it via method overriding (same method, different class) and built-
in functions like len() working on both strings and lists.

• For example, speak() method can make a dog bark and a cat meow — same method,
different behavior.

# Example 1 - Built-in polymorphism

print(len("Rohit")) # 5
print(len([1, 2, 3])) # 3

5
3

# Example 2 - Method overriding

class Bird:
def sound(self):
print("Generic bird sound")

class Sparrow(Bird):
def sound(self):
print("Chirp Chirp")

s = Sparrow()
s.sound()

Chirp Chirp

# 6. Abstraction

• Abstraction means showing only essential features and hiding the internal
implementation from the user.

• It helps in focusing on what an object does instead of how it does it.

• In Python, abstraction is achieved using the ABC module where we define abstract
classes and methods.

• For example, when you drive a car, you press the accelerator — but you don’t need
to know how fuel is burned inside.

# Example 1
from abc import ABC, abstractmethod

class Shape(ABC):
@abstractmethod
def area(self):
pass

class Rectangle(Shape):
def area(self):
 return 10 * 20

r = Rectangle()
print("Area:", r.area())

Area: 200

# Example 2
class Animal(ABC):
@abstractmethod
def make_sound(self):
pass

class Cat(Animal):
def make_sound(self):
print("Meow")

c = Cat()
c.make_sound()

Meow

7. Method Overloading and Overriding

• Method Overloading allows us to use the same method name with different number
of parameters. Python doesn’t support it directly but we can simulate using default
arguments.

• Method Overriding means redefining a parent class’s method in the child class to
provide specific behavior.

• Overloading is useful when you want one function to handle multiple types of
inputs.

• Overriding helps when you want your child class to behave differently from the
parent class for a specific method.

# Overloading using default arguments

class Calculator:
def add(self, a, b=0, c=0):
return a + b + c

calc = Calculator()
print(calc.add(5))
print(calc.add(5, 3))
print(calc.add(5, 3, 2))
5
8
10

# Overriding
class Parent:
def message(self):
print("Message from parent")

class Child(Parent):
def message(self):
print("Message from child")

c = Child()
c.message()

Message from child

8. Self Keyword
• self is a special keyword in Python which refers to the current object of the class.

• It is used inside methods to access the object’s own variables and functions.

• Every time you create an object and call its method, self helps Python understand
which object you're talking about.

• It is mandatory in instance methods as it allows each object to maintain its own

values.

class Bike:
def __init__(self, brand):
self.brand = brand

def show(self):
print("Brand:", self.brand)

b = Bike("Yamaha")
b.show()

Brand: Yamaha

9. Class Variable vs Instance Variable

• A class variable is shared by all instances (objects) of the class. Changing it affects all
objects.

• An instance variable is unique to each object — changing one doesn't affect others.
 • Use class variables when the data is common to all objects, like company_name, and
instance variables for data like employee_name.

• This helps organize and separate global data from object-specific data.

class Employee:
company = "Google" # Class variable

def __init__(self, name):

self.name = name # Instance variable

e1 = Employee("Amit")
e2 = Employee("Rita")

print(e1.company)
print(e2.company)
print(e1.name)
print(e2.name)

Google
Google
Amit
Rita

Final Mini Project: Student Management

System using OOPs
This project uses:
Class/Object
Constructor
Encapsulation
Inheritance
Polymorphism
Abstraction
self
Class vs Instance Variable

from abc import ABC, abstractmethod

# Abstract class
class Person(ABC):
def __init__(self, name, age):
self._name = name
self._age = age

@abstractmethod
def display(self):
pass

# Student class using inheritance & encapsulation

class Student(Person):
school_name = "ABC Public School" # class variable

def __init__(self, name, age, student_id, marks):

super().__init__(name, age)
self.__student_id = student_id
self.marks = marks # instance variable

def display(self):
print(f"Student: {self._name}, Age: {self._age}, ID:
{self.__student_id}, Marks: {self.marks}")

# Teacher class using inheritance

class Teacher(Person):
def __init__(self, name, age, subject):
super().__init__(name, age)
self.subject = subject

def display(self):
print(f"Teacher: {self._name}, Age: {self._age}, Subject:
{self.subject}")

# Polymorphism in action
people = [
Student("Rohit", 20, "S001", 88),
Teacher("Mrs. Sharma", 35, "Mathematics")
]

for person in people:

person.display()

Student: Rohit, Age: 20, ID: S001, Marks: 88

Teacher: Mrs. Sharma, Age: 35, Subject: Mathematics