Course: Python Programming Training
Topic: Applying Polymorphism, Encapsulation, and Abstraction
Course Link: Python Training Course at JustAcademy
Demo Link: Register for a Course Demo
Website: JustAcademy Homepage
Object-oriented programming (OOP) is a programming approach that organizes software around classes and objects. A class defines attributes and methods, while an object represents a particular instance of that class.
Python supports several OOP principles that help developers build reusable, maintainable, and extensible applications. Three important principles are polymorphism, encapsulation, and abstraction.
These principles are often used together. For example, a payment application may use abstraction to define a payment interface, polymorphism to support different payment methods, and encapsulation to manage each payment method's internal data.
After completing this topic, you will be able to:
abc module.The word polymorphism means "many forms." In programming, polymorphism allows the same interface, method name, or operation to behave differently depending on the object or data involved.
For example, a make_sound() method might produce a different sound for a dog and a cat. The calling code can use the same method name without needing to know every implementation detail of each animal.
class Dog:
def make_sound(self):
return "Bark"
class Cat:
def make_sound(self):
return "Meow"
dog = Dog()
cat = Cat()
print(dog.make_sound())
print(cat.make_sound())Output:
Bark
MeowExplanation:
make_sound().A function can operate on different objects as long as they provide the expected behavior.
class Dog:
def make_sound(self):
print("Dog barks")
class Cat:
def make_sound(self):
print("Cat meows")
class Cow:
def make_sound(self):
print("Cow moos")
def animal_sound(animal):
animal.make_sound()
animals = [Dog(), Cat(), Cow()]
for animal in animals:
animal_sound(animal)Output:
Dog barks
Cat meows
Cow moosThe animal_sound() function does not need separate branches for each class. It simply calls the method that each object provides.
Method overriding occurs when a subclass defines a method with the same name as a method inherited from its parent class. The subclass implementation is used when that method is called on an instance of the subclass.
class Vehicle:
def start(self):
print("Vehicle is starting")
class Car(Vehicle):
def start(self):
print("Car engine is starting")
class Motorcycle(Vehicle):
def start(self):
print("Motorcycle engine is starting")
vehicle = Vehicle()
car = Car()
motorcycle = Motorcycle()
vehicle.start()
car.start()
motorcycle.start()Output:
Vehicle is starting
Car engine is starting
Motorcycle engine is startingKey points:
Car and Motorcycle inherit from Vehicle.start() method.The super() function allows a subclass to call an implementation defined higher in the method resolution order. This is useful when the subclass wants to extend rather than completely replace the parent's behavior.
class Vehicle:
def start(self):
print("Checking vehicle system")
class Car(Vehicle):
def start(self):
super().start()
print("Car engine is starting")
car = Car()
car.start()Output:
Checking vehicle system
Car engine is startingThe subclass first reuses the parent's behavior and then adds its own behavior.
Python supports duck typing, a programming style in which an object is used according to the operations it supports rather than requiring it to belong to a particular inheritance hierarchy.
The idea is often summarized as: if an object provides the required behavior, it can be used for that operation.
class PDFReport:
def export(self):
return "Exporting PDF report"
class ExcelReport:
def export(self):
return "Exporting Excel report"
class CSVReport:
def export(self):
return "Exporting CSV report"
def export_report(report):
print(report.export())
export_report(PDFReport())
export_report(ExcelReport())
export_report(CSVReport())Output:
Exporting PDF report
Exporting Excel report
Exporting CSV reportThe report classes do not need to share a parent class for this example to work. Each object only needs to provide a compatible export() method.
Python's built-in functions often work with different data types through a shared interface.
print(len("Python"))
print(len([10, 20, 30]))
print(len({"name": "Asha", "age": 25}))Output:
6
3
2The len() function works with strings, lists, and dictionaries, although the meaning of length depends on the object.
In languages such as Java, method overloading commonly means defining multiple methods with the same name but different parameter lists. Python does not support traditional signature-based method overloading in the same way. Defining a second method with the same name in a class replaces the earlier definition in the class namespace.
Python programmers can often achieve similar flexibility through default parameters, variable-length arguments, or type-based dispatch.
Example using default parameters:
class Calculator:
def add(self, a, b=0, c=0):
return a + b + c
calculator = Calculator()
print(calculator.add(5))
print(calculator.add(5, 10))
print(calculator.add(5, 10, 15))Output:
5
15
30Example using variable-length arguments:
class Calculator:
def add(self, *numbers):
return sum(numbers)
calculator = Calculator()
print(calculator.add(2, 3))
print(calculator.add(2, 3, 4, 5))Output:
5
14Encapsulation combines data and the methods that operate on that data inside a class. It also encourages controlled access to an object's internal state so that data remains valid and consistent.
For example, a bank account should not allow an arbitrary invalid withdrawal that makes the balance negative when the application's rules prohibit overdrafts. A class can expose a withdrawal method that checks the amount before updating the balance.
Public attributes can be accessed directly from outside the class. They are suitable when unrestricted access is appropriate.
class Student:
def __init__(self, name):
self.name = name
student = Student("Rohan")
print(student.name)
student.name = "Karan"
print(student.name)Output:
Rohan
KaranThe name attribute is public, so the caller can read or replace its value directly.
A single leading underscore, such as _balance, signals that an attribute is intended for internal use or use by subclasses. This is a convention, not strict access control. Python does not prevent external code from accessing such an attribute.
class Employee:
def __init__(self, name, salary):
self.name = name
self._salary = salary
employee = Employee("Priya", 50000)
print(employee.name)
print(employee._salary)Output:
Priya
50000Although the example can access _salary, the underscore communicates that callers should generally use a public interface instead of depending directly on the internal attribute.
A double leading underscore, such as __balance, triggers name mangling in most ordinary class definitions. Python changes the attribute's internal name to include the class name, which helps avoid accidental name conflicts in subclasses.
This mechanism is not a security boundary and does not make data absolutely inaccessible.
class BankAccount:
def __init__(self, balance):
self.__balance = balance
def get_balance(self):
return self.__balance
account = BankAccount(5000)
print(account.get_balance())Output:
5000Directly accessing account.__balance normally raises an AttributeError because the stored attribute is name-mangled.
Encapsulation allows a class to expose methods that validate requests before changing internal data.
class BankAccount:
def __init__(self, owner, balance=0):
if balance < 0:
raise ValueError("Initial balance cannot be negative")
self.owner = owner
self.__balance = balance
def deposit(self, amount):
if amount <= 0:
raise ValueError("Deposit amount must be positive")
self.__balance += amount
def withdraw(self, amount):
if amount <= 0:
raise ValueError("Withdrawal amount must be positive")
if amount > self.__balance:
raise ValueError("Insufficient balance")
self.__balance -= amount
def get_balance(self):
return self.__balance
account = BankAccount("Aarav", 1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance())Output:
1300Explanation:
__balance.deposit() method rejects non-positive amounts.withdraw() method checks both the amount and available balance.get_balance() method provides a controlled way to read the balance.This example illustrates encapsulation. In real financial software, additional requirements such as decimal-based currency calculations, transaction logging, concurrency controls, and authorization would also be necessary.
Python's @property decorator lets a class expose a method as an attribute. This can provide a convenient interface while keeping validation logic inside the class.
class Product:
def __init__(self, price):
self.price = price
@property
def price(self):
return self.__price
@price.setter
def price(self, value):
if value < 0:
raise ValueError("Price cannot be negative")
self.__price = value
product = Product(250)
print(product.price)
product.price = 300
print(product.price)Output:
250
300How it works:
@property defines the getter for price.@price.setter defines the setter for the same property.product.price, the setter validates it.__price, avoiding recursive calls to the property.If a negative value is assigned, the setter raises a ValueError.
A property without a setter can be used as a read-only attribute through the normal public interface.
class Circle:
def __init__(self, radius):
if radius <= 0:
raise ValueError("Radius must be positive")
self._radius = radius
@property
def radius(self):
return self._radius
@property
def area(self):
return 3.14159 * self._radius ** 2
circle = Circle(5)
print(circle.radius)
print(circle.area)Output:
5
78.53975The caller can read radius and area through properties, but assigning to circle.area raises an AttributeError unless a setter is defined. Python's object model is not designed to provide absolute protection against deliberate modification of internal attributes.
Abstraction means exposing essential functionality while hiding implementation details that callers do not need to understand.
For example, a person can drive a car by using its steering wheel, accelerator, and brakes without needing to understand every detail of the engine's internal operation. The controls form an interface, while the internal mechanisms implement the behavior.
In software, abstraction helps define what an object must do without requiring every implementation to work in exactly the same way internally.
Python provides the abc module, which supports abstract base classes. An abstract base class can define abstract methods that concrete subclasses must implement before they can be instantiated.
The @abstractmethod decorator marks a method as abstract. A class with unresolved abstract methods cannot normally be instantiated.
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
rectangle = Rectangle(5, 4)
print(rectangle.area())Output:
20Explanation:
ABC is the base class used to define an abstract base class.Shape specifies that concrete shapes must provide an area() implementation.Rectangle implements the required method.from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self):
pass
class Rectangle(Shape):
pass
rectangle = Rectangle()Result: Python raises a TypeError because Rectangle has not implemented the abstract method area().
This behavior helps catch incomplete implementations before objects are used.
An abstract class can define multiple required operations. A concrete subclass must implement all inherited abstract methods before it can be instantiated.
from abc import ABC, abstractmethod
class PaymentMethod(ABC):
@abstractmethod
def pay(self, amount):
pass
@abstractmethod
def refund(self, amount):
pass
class CardPayment(PaymentMethod):
def pay(self, amount):
return f"Paid {amount} using a card"
def refund(self, amount):
return f"Refunded {amount} to the card"
payment = CardPayment()
print(payment.pay(1000))
print(payment.refund(200))Output:
Paid 1000 using a card
Refunded 200 to the cardThe abstract base class specifies the required interface, while CardPayment supplies the concrete behavior.
An abstract method can contain executable code rather than only pass. A subclass may call that shared implementation through super() while providing its own additional behavior.
from abc import ABC, abstractmethod
class Notification(ABC):
@abstractmethod
def send(self, message):
print(f"Preparing notification: {message}")
class EmailNotification(Notification):
def send(self, message):
super().send(message)
print(f"Sending email: {message}")
notification = EmailNotification()
notification.send("Welcome")Output:
Preparing notification: Welcome
Sending email: WelcomeAbstraction is a design principle, not a feature limited to abstract classes. A well-designed class can provide a simple public interface while keeping internal steps inside private or internal methods.
class CoffeeMachine:
def make_coffee(self):
self.__boil_water()
self.__brew_coffee()
return "Coffee is ready"
def __boil_water(self):
print("Boiling water")
def __brew_coffee(self):
print("Brewing coffee")
machine = CoffeeMachine()
print(machine.make_coffee())Output:
Boiling water
Brewing coffee
Coffee is readyThe user calls the single public method make_coffee() instead of coordinating the internal steps directly.
| Feature | Polymorphism | Encapsulation | Abstraction |
|---|---|---|---|
| Main purpose | Allow different objects to provide different behavior through a common operation. | Combine data and behavior and control how internal state is accessed. | Expose essential behavior while hiding unnecessary implementation details. |
| Focus | Flexible behavior and interchangeable implementations. | Data integrity and controlled access. | Interfaces and reduced complexity. |
| Common Python techniques | Method overriding, duck typing, shared interfaces. | Methods, naming conventions, properties, validation. | Abstract base classes, abstract methods, public interfaces. |
| Typical example | Different payment classes implement pay(). |
A bank account validates deposits and withdrawals. | A payment interface defines operations without specifying every implementation. |
| Key benefit | Extensibility and code reuse. | Reliable and maintainable object state. | Simpler usage and clear contracts. |
| Question it answers | How can the same operation work differently for different objects? | How should data and its updates be managed? | What should an object expose, and what can remain hidden? |
A payment processing system is a useful example because different payment methods share a common purpose but have different implementations. The system also needs controlled data and a clear interface.
This example demonstrates:
PaymentMethod class defines the required pay() method.from abc import ABC, abstractmethod
class PaymentMethod(ABC):
def __init__(self):
self.__total_paid = 0.0
@property
def total_paid(self):
return self.__total_paid
def _record_payment(self, amount):
if not isinstance(amount, (int, float)) or isinstance(amount, bool):
raise TypeError("Amount must be numeric")
if amount <= 0:
raise ValueError("Amount must be positive")
self.__total_paid += amount
@abstractmethod
def pay(self, amount):
pass
class CardPayment(PaymentMethod):
def pay(self, amount):
self._record_payment(amount)
return f"Processing card payment of {amount:.2f}"
class WalletPayment(PaymentMethod):
def pay(self, amount):
self._record_payment(amount)
return f"Processing wallet payment of {amount:.2f}"
def process_payment(payment_method, amount):
print(payment_method.pay(amount))
card = CardPayment()
wallet = WalletPayment()
process_payment(card, 1500)
process_payment(wallet, 500)
print(f"Card total: {card.total_paid:.2f}")
print(f"Wallet total: {wallet.total_paid:.2f}")Output:
Processing card payment of 1500.00
Processing wallet payment of 500.00
Card total: 1500.00
Wallet total: 500.00Abstraction: The abstract PaymentMethod class requires concrete payment classes to implement pay(). It defines the interface without specifying the exact payment process.
Encapsulation: The total paid amount is stored in __total_paid. The public total_paid property provides read access, while _record_payment() validates the amount before updating the total.
Polymorphism: The process_payment() function accepts different payment objects and calls pay(). The correct implementation runs according to the object's class.
Design note: This is a learning example, not production payment software. Real payment processing requires secure payment-provider integrations, appropriate currency handling, authentication, error management, and transaction reconciliation.
The following example demonstrates encapsulation and polymorphism while using an abstract class to define the behavior expected from employee types.
from abc import ABC, abstractmethod
class Employee(ABC):
def __init__(self, name, base_salary):
if base_salary < 0:
raise ValueError("Salary cannot be negative")
self.name = name
self.__base_salary = base_salary
@property
def base_salary(self):
return self.__base_salary
@abstractmethod
def calculate_salary(self):
pass
class FullTimeEmployee(Employee):
def calculate_salary(self):
return self.base_salary
class CommissionEmployee(Employee):
def __init__(self, name, base_salary, commission):
super().__init__(name, base_salary)
if commission < 0:
raise ValueError("Commission cannot be negative")
self.commission = commission
def calculate_salary(self):
return self.base_salary + self.commission
employees = [
FullTimeEmployee("Asha", 50000),
CommissionEmployee("Rohan", 30000, 8000)
]
for employee in employees:
print(employee.name, employee.calculate_salary())Output:
Asha 50000
Rohan 38000Here, the abstract Employee class defines the salary-calculation contract. The base salary is managed through a property, and the subclasses provide different salary-calculation behavior.
| Problem | Why It Happens | How to Fix It |
|---|---|---|
| Subclass does not behave as expected | The subclass may not override the intended method, or the wrong object is being used. | Check the method name, inheritance, and object type. |
| Abstract class cannot be instantiated | One or more abstract methods have not been implemented. | Implement all required abstract methods in the concrete subclass. |
| Invalid values modify internal data | Validation is missing from the method that updates the state. | Validate input before changing the stored value. |
| Double underscore attribute is inaccessible | Python applies name mangling to attributes with double leading underscores. | Use a public method or property to access the data. |
| Assuming underscore attributes are completely private | A single leading underscore is only a convention, and double-underscore name mangling is not a security feature. | Use clear public interfaces and avoid relying on internal attributes from outside the class. |
| Same method name defined twice | The later definition replaces the earlier definition in the class namespace. | Use default parameters, variable-length arguments, or a deliberate dispatch strategy. |
| Unrelated objects cause AttributeError | A function assumes an object has a method or attribute that it does not provide. | Document the expected interface, use abstract base classes where appropriate, or validate inputs. |
| Property setter calls itself recursively | The setter assigns to the same property instead of an internal storage attribute. | Store the value in a separate attribute such as self._price or self.__price. |
class Product:
@property
def price(self):
return self.price
@price.setter
def price(self, value):
self.price = valueThis code recursively calls the property getter or setter because both methods access self.price internally.
Corrected version:
class Product:
def __init__(self, price):
self.price = price
@property
def price(self):
return self.__price
@price.setter
def price(self, value):
if value < 0:
raise ValueError("Price cannot be negative")
self.__price = valuefrom abc import ABC, abstractmethod
class Report(ABC):
@abstractmethod
def generate(self):
pass
report = Report()Python raises a TypeError because Report has an abstract method that has not been implemented.
Corrected version:
from abc import ABC, abstractmethod
class Report(ABC):
@abstractmethod
def generate(self):
pass
class SalesReport(Report):
def generate(self):
return "Sales report generated"
report = SalesReport()
print(report.generate())Output:
Sales report generatedsuper() to reuse parent behavior when appropriate.calculate_salary(), process_payment(), and validate_amount().Create Circle, Rectangle, and Triangle classes. Each class should implement an area() method. Store the objects in a list and call area() for each object using the same loop.
Create a base class named Notification with a method called send(). Create subclasses for email, SMS, and push notifications that override the method with different behavior.
Create a BankAccount class with a name-mangled balance attribute. Add methods for deposits and withdrawals. Reject zero or negative transaction amounts and prevent withdrawals that exceed the available balance.
Create a Product class with a price property. Ensure that negative prices cannot be assigned. Add a second property that calculates a discounted price.
Create an abstract class named Storage with abstract methods save() and load(). Implement subclasses such as FileStorage and MemoryStorage that provide their own behavior.
Build a library management application with the following requirements:
Polymorphism allows different objects to respond to the same operation or method call in different ways. It can be implemented using method overriding and duck typing, among other techniques.
Method overriding occurs when a subclass defines a method with the same name as an inherited method, providing its own implementation.
Duck typing means that code focuses on the operations an object supports rather than requiring the object to belong to a particular class hierarchy.
Python does not support traditional signature-based method overloading through multiple definitions with the same name in one class. Default arguments, *args, **kwargs, and dispatch tools can provide alternative patterns.
Encapsulation combines data and related behavior inside a class and encourages controlled access to internal state through methods and properties.
A single leading underscore is a convention that signals internal use. A double leading underscore triggers name mangling, which helps avoid accidental name conflicts but does not provide absolute privacy or security.
A property allows a method to be accessed through attribute syntax. Properties can provide computed values, validation, and controlled attribute updates.
Abstraction exposes essential functionality while hiding unnecessary implementation details. It helps callers interact with a clear interface rather than manage internal operations.
An abstract class can define abstract methods that concrete subclasses must implement. Python supports this through the abc module.
The @abstractmethod decorator marks a method as abstract, requiring a concrete subclass to provide an implementation before it can normally be instantiated.
Yes. An abstract class can contain both abstract methods and fully implemented methods that subclasses inherit or extend.
Yes. Any design that exposes a simple interface while hiding unnecessary implementation details can apply abstraction.
Encapsulation focuses on combining data and behavior and managing access to internal state. Abstraction focuses on exposing essential functionality while hiding implementation complexity.
An abstract base class can define a common interface, while different subclasses implement that interface in different ways. Code can then call the common operation polymorphically.
They help create software that is modular, reusable, easier to test, and easier to extend. They also help keep object state consistent and make complex systems easier to work with.
Polymorphism, encapsulation, and abstraction are foundational principles of Python object-oriented programming. Polymorphism allows different objects to support the same operation with different behavior. Encapsulation helps manage internal data and preserve valid state. Abstraction defines clear interfaces and hides unnecessary implementation details.
Applying these principles together helps developers create flexible and maintainable software. Practice with payment processing, employee management, bank accounts, and library systems to strengthen your understanding of how OOP principles work in real applications.
Continue learning through the Python Training Course at JustAcademy, visit the JustAcademy website, or register for a course demo.
