PART 3 • LEVEL 11

🏗️ Object-Oriented Python

Model real entities as cooperating objects that combine data with behavior and grow safely through inheritance, composition and polymorphism.

⏱ 110–125 minutes📚 8 concepts💻 5 programs🧠 6-question quiz

Start Lesson ↓Jump to Problems

student.pyPython 3

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks

    def result(self):
        return "Pass" if self.marks >= 40 else "Fail"

KEY IDEAState + Behaviour = Object

LEARNING OUTCOMES

By the End of This Level

You will be able to design small object-oriented Python solutions.

Create classes, objects, constructors and instance attributes.

Protect state through clear methods and controlled access.

Reuse and specialise behaviour through inheritance.

Apply overriding, polymorphism and composition appropriately.

MODEL AN ENTITY

Classes and Objects

A class describes a category of objects; an object is one concrete instance created from that class.

A class groups related data and functions under one name. Attributes represent state, while methods represent actions that use or change that state.

Object

A runtime value with its own identity, type and state. Multiple objects from the same class can store different attribute values.

1Define ClassDescribe the model

→

2Call ClassRequest an object

→

3InitialiseStore object state

→

4Use ObjectAccess its behaviour

EXAMPLE 1

Create Two Student Objects

class Student:
    pass

first = Student()
second = Student()
print(type(first) == type(second))

Output

True

INITIALISE STATE

`init`, `self` and Attributes

Python calls __init__ after creating an instance so its starting state can be established.

Part	Purpose	Example
`__init__`	Initialises a new instance	`def __init__(self, name):`
`self`	Refers to the current instance	`self.name`
Instance attribute	Stores per-object state	`self.marks = marks`
Object creation	Calls the class	`Student("Asha", 88)`

self is explicit

Python supplies the current object automatically during a method call, but the method definition must declare self as its first parameter.

BEHAVIOUR WITH STATE

Instance Methods

An instance method receives self and performs work using the current object’s attributes.

EXAMPLE 2

Calculate a Rectangle’s Area

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

box = Rectangle(8, 5)
print("Area =", box.area())

Output

Area = 40

Call syntax

box.area() is conceptually similar to Rectangle.area(box); the instance becomes the self argument.

CONTROL STATE CHANGES

Encapsulation and Properties

Encapsulation keeps state and the rules that protect it together inside a class.

CONVENTION

Non-public attribute

A leading underscore communicates that an attribute is an internal implementation detail.

self._balance = 0

PROPERTY

Controlled access

@property exposes method logic through attribute-like syntax and can validate assignments.

@property
def balance(self):
    return self._balance

Name mangling

A double-leading name such as self.__pin is transformed to reduce accidental access; it does not provide security or true privacy.

SHARED AND ALTERNATIVE BEHAVIOUR

Class Attributes, Class Methods and Static Methods

Class members belong to the class itself and support information or behaviour shared across instances.

Member	First parameter	Typical use
Instance method	`self`	Read or change one object
Class method	`cls`	Alternative constructor or class-level operation
Static method	None supplied automatically	Related utility that needs no instance or class state
Class attribute	Not applicable	Shared constant or counter

EXAMPLE 3

Track a Shared School Name

class Student:
    school = "CodeBhavya Academy"

    def __init__(self, name):
        self.name = name

student = Student("Bhavya")
print(student.school)

Output

CodeBhavya Academy

REUSE AND SPECIALISE

Inheritance and `super()`

Inheritance creates a specialised class from an existing class when a genuine “is-a” relationship exists.

1Base ClassCommon state

→

2SubclassDeclare relationship

→

3super()Reuse base setup

→

4SpecialiseAdd new behaviour

EXAMPLE 4

Specialise an Employee

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

class Developer(Employee):
    def __init__(self, name, language):
        super().__init__(name)
        self.language = language

Relationship

Developer is an Employee

ONE INTERFACE • MANY FORMS

Method Overriding and Polymorphism

A subclass overrides a method by defining a method with the same name but specialised behaviour.

OVERRIDE

Specialise inherited behaviour

A subclass supplies its own implementation while keeping the method name expected by callers.

class Dog:
    def speak(self):
        return "Woof"

POLYMORPHISM

Program to behaviour

Different objects respond to the same operation, allowing callers to work with a common interface.

for animal in animals:
    print(animal.speak())

Duck typing

Python often cares about the behaviour an object provides rather than requiring it to inherit from one particular base class.

BUILD FROM COOPERATING OBJECTS

Composition

Composition places one object inside another when the relationship is naturally “has-a”.

INHERITANCE

Is-a relationship

A Developer is an Employee. Use inheritance when the subtype can safely replace the base type.

COMPOSITION

Has-a relationship

A Car has an Engine. Delegate work to the contained object instead of forcing an unrelated class hierarchy.

🧩

Flexible

Components can be replaced independently.

🧪

Testable

Each collaborator can be tested alone.

🔧

Maintainable

Responsibilities stay clearly separated.

♻️

Reusable

One component can serve many owners.

COMMON MISTAKES

Object-Oriented Errors to Avoid

Forgetting self

Instance methods must declare self first and use it to access instance state.

Sharing mutable class state accidentally

Put per-object lists and dictionaries inside __init__, not directly on the class.

Using inheritance only to reuse code

Inheritance should represent a valid substitutable “is-a” relationship.

Exposing uncontrolled state changes

Use methods or properties when an attribute must obey validation rules.

QUICK REVISION

📌 Object-Oriented Python — Quick Revision

Review these ten rules before attempting the quiz and programming problems.

A class describes the state and behaviour of objects.

An object is one instance of a class.

__init__ establishes an instance’s initial state.

self refers to the current instance.

Instance attributes store per-object values.

Class attributes are shared through the class.

Encapsulation keeps state and its rules together.

Inheritance models a substitutable “is-a” relationship.

Overriding gives a subclass specialised behaviour.

Composition models a flexible “has-a” relationship.

KNOWLEDGE CHECK

🧠 Level 11 Quiz

Select one answer for each question, then check your score.

1. What does `self` refer to inside an instance method?

The parent class The current object Every object in the program

2. Which method normally establishes an object’s initial attributes?

__init__ __start__ create

3. Which member is normally shared by all instances?

Local variable Instance attribute Class attribute

4. What does `super()` help a subclass do?

Delete its base class Access the next implementation in the inheritance chain Convert every method into a static method

5. Which concept allows different objects to respond to the same method name?

Polymorphism Recursion Serialization

6. A car containing an engine is primarily which relationship?

Is-a Overrides-a Has-a

PROGRAMMING PROBLEMS

💻 CodeBhavya Object-Oriented Challenges

Design each class and run it in the browser. The checker uses the displayed input and exact expected output.

0 / 5Solved independently

0Completed with solution

0 / 500Best score

0%Progress

1. Student Result Class

Create a Student class that stores a name and marks and returns Pass for marks of at least 40.

Sample inputs: Bhavya, 78Expected output: Bhavya: Pass

💡 Store both values in __init__ and let result() return one classification string.

Official Python Program

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks

    def result(self):
        if self.marks >= 40:
            return "Pass"
        return "Fail"

name = input()
marks = int(input())
student = Student(name, marks)
print(student.name + ":", student.result())

2. Rectangle Measurements

Create a rectangle object with separate methods that return its area and perimeter.

Sample inputs: 8, 5Expected output: Area = 40 and Perimeter = 26

💡 Both methods should read self.length and self.width without requesting new input.

Official Python Program

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeter(self):
        return 2 * (self.length + self.width)

length = int(input())
width = int(input())
box = Rectangle(length, width)
print("Area =", box.area())
print("Perimeter =", box.perimeter())

3. Bank Account Operations

Store a starting balance, deposit an amount and withdraw an amount only when sufficient funds are available.

Sample inputs: 1000, 500, 300Expected output: Balance = 1200

💡 Let deposit() add to self.balance and let withdraw() check the amount before subtracting.

Official Python Program

class BankAccount:
    def __init__(self, balance):
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount

    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount

balance = int(input())
deposit = int(input())
withdraw = int(input())
account = BankAccount(balance)
account.deposit(deposit)
account.withdraw(withdraw)
print("Balance =", account.balance)

4. Developer Inheritance

Create Employee and Developer classes. Reuse the base constructor and return a developer summary.

Sample inputs: Asha, 60000, PythonExpected output: Asha | 60000 | Python

💡 Call super().__init__(name, salary) before storing the language on the developer.

Official Python Program

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

class Developer(Employee):
    def __init__(self, name, salary, language):
        super().__init__(name, salary)
        self.language = language

    def details(self):
        return self.name + " | " + str(self.salary) + " | " + self.language

name = input()
salary = int(input())
language = input()
developer = Developer(name, salary, language)
print(developer.details())

5. Shape Polymorphism

Override area() in rectangle and square subclasses, then call the same method on both objects.

Sample inputs: 6, 4, 5Expected output: Rectangle = 24 and Square = 25

💡 Give both subclasses an area() method; the caller should not need different calculation function names.

Official Python Program

class Shape:
    def area(self):
        return 0

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side * self.side

length = int(input())
width = int(input())
side = int(input())
rectangle = Rectangle(length, width)
square = Square(side)
print("Rectangle =", rectangle.area())
print("Square =", square.area())

KEY TAKEAWAY

🎯 Give Every Object a Clear Responsibility

1Model State

Store meaningful attributes.

→

2Define Behaviour

Keep rules in methods.

→

3Reuse Carefully

Inherit only for “is-a”.

→

4Compose Systems

Connect focused objects.

Object orientation is most useful when it clarifies responsibilities. Well-designed objects protect their own valid state, expose purposeful behaviour and collaborate through small, predictable interfaces.

INTERACTIVE LEARNING

🎬 Object Creation — Visual Flow

Follow a class call as Python creates, initialises and returns a usable object.

PROGRAM TRACING

🔎 Program Tracing — Constructor and Method Call

Trace a rectangle object from class call through attribute storage and area calculation.

INTERVIEW PREPARATION

🎤 Object-Oriented Python — Interview Questions

Answer aloud before opening each explanation.

What is the difference between a class and an object?

Why is self required in instance method definitions?

self gives the method access to the particular object on which it was called, including that object’s attributes and other methods.

How do instance attributes and class attributes differ?

What is method overriding?

When should composition be preferred over inheritance?

What does polymorphism improve in a program?

EXTRA TIPS

💡 Object-Oriented Python — Extra Tips

01
Name classes with nouns in PascalCase, such as BankAccount.
02
Keep methods small and focused on the responsibility of their class.
03
Create per-object mutable attributes inside __init__.
04
Expose behaviour instead of asking callers to manipulate internal state directly.
05
Use super() so cooperative inheritance follows Python’s method resolution order.
06
Prefer composition when collaborators may change independently.

EXTRA PRACTICE

✍️ Object-Oriented Python — Extra Practice Questions

Create a Book class with title, author and a display method.
Build a Circle class that returns area and circumference.
Add controlled deposit and withdrawal methods to an account.
Use a class attribute to count how many objects were created.
Create a class method that builds a student from a comma-separated string.
Validate an age assignment using a property setter.
Derive Car and Bike from a Vehicle class.
Override a fare() method for bus and taxi objects.
Model a computer that contains processor and memory objects.
Explain why an unrelated helper class should not inherit only for code reuse.

LEVEL 11 CHECKPOINT

Object-Oriented Python Complete

When you can design classes, protect instance state and explain inheritance, overriding, polymorphism and composition, mark this level complete and continue.

Continue to Level 12 →

🏗️ Object-Oriented Python

By the End of This Level

Classes and Objects

Create Two Student Objects

__init__, self and Attributes

Instance Methods

Calculate a Rectangle’s Area

Encapsulation and Properties

Non-public attribute

Controlled access

Class Attributes, Class Methods and Static Methods

Track a Shared School Name

Inheritance and super()

Specialise an Employee

Method Overriding and Polymorphism

Specialise inherited behaviour

Program to behaviour

Composition

Is-a relationship

Has-a relationship

Flexible

Testable

Maintainable

Reusable

Object-Oriented Errors to Avoid

📌 Object-Oriented Python — Quick Revision

🧠 Level 11 Quiz

1. What does self refer to inside an instance method?

2. Which method normally establishes an object’s initial attributes?

3. Which member is normally shared by all instances?

4. What does super() help a subclass do?

5. Which concept allows different objects to respond to the same method name?

6. A car containing an engine is primarily which relationship?

💻 CodeBhavya Object-Oriented Challenges

Python Code Editor

Program Output

Test Case

Python Code Editor

Program Output

Test Case

Python Code Editor

Program Output

Test Case

Python Code Editor

Program Output

Test Case

Python Code Editor

Program Output

Test Case

🎯 Give Every Object a Clear Responsibility

🎬 Object Creation — Visual Flow

🏗️ How an Object Is Created

1. Call the Class

🔎 Program Tracing — Constructor and Method Call

🎤 Object-Oriented Python — Interview Questions

💡 Object-Oriented Python — Extra Tips

✍️ Object-Oriented Python — Extra Practice Questions

Object-Oriented Python Complete

`init`, `self` and Attributes

Inheritance and `super()`

1. What does `self` refer to inside an instance method?

4. What does `super()` help a subclass do?