🐍 Lesson 20: Python OOP – Inheritance, Polymorphism & Encapsulation

Welcome to Lesson 20! Today we’ll explore advanced Object-Oriented Programming (OOP) concepts in Python: Inheritance, Polymorphism, and Encapsulation. These concepts help create powerful, reusable, and organized code, making your programs more modular and flexible.

---

⭐ What You Will Learn in This Lesson

• Understand inheritance and how to create child and parent classes
• Learn about polymorphism and how objects of different classes can share the same interface
• Explore encapsulation to protect the internal state of an object
• Improve code organization and reusability with OOP principles

---

👥 Who Is This Lesson For?

• Python developers looking to master advanced OOP concepts
• Anyone building large applications, frameworks, or games
• Developers interested in writing cleaner, reusable, and modular code

---

📦 1. Inheritance

Inheritance allows one class (child) to inherit attributes and methods from another class (parent), promoting code reuse and modularity.

class Animal:
    def sound(self):
        print("Some sound")

class Dog(Animal):  # Dog inherits from Animal
    def bark(self):
        print("Bark!")

d = Dog()
d.sound()  # Inherited method
d.bark()   # Own method

---

📦 2. Polymorphism

Polymorphism means “many forms.” In Python, it allows objects to use the same method name but behave differently depending on the object type.

class Cat:
    def sound(self):
        print("Meow")

class Dog:
    def sound(self):
        print("Bark")

animals = [Cat(), Dog()]
for animal in animals:
    animal.sound()  # Same method, different behavior

---

📦 3. Encapsulation

Encapsulation hides the internal state of an object and protects it from direct access. It helps ensure that an object’s state is modified only in controlled ways, using methods.

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

    def get_name(self):
        return self.__name

    def set_age(self, age):
        if age > 0:
            self.__age = age

p = Person("Alice", 25)
print(p.get_name())  # Access using method
# print(p.__age)     # Error: private attribute

---

🧩 4. Why These Concepts Matter

• Inheritance promotes code reuse and modularity
• Polymorphism allows flexible and scalable code
• Encapsulation protects data and ensures safe access
• Essential for building large applications, frameworks, and games

---

🧪 Practice

1. Create a parent class Vehicle with child classes Car and Bike, each with its own method.
2. Implement polymorphism: create a method start() in both child classes and call it in a loop.
3. Create a class with private attributes and methods to get/set them safely.
4. Combine inheritance and encapsulation: create a parent class with private attributes and a child class that accesses them via methods.

---

❌ Common Mistakes

• Not using self in methods
• Incorrectly calling methods or accessing attributes
• Confusing inheritance and method overriding
• Not properly encapsulating attributes and methods

---

❓ Frequently Asked Questions (FAQ)

1. What is inheritance in Python?

Inheritance allows a class to inherit the attributes and methods of another class, promoting code reuse and modularity.

2. How does polymorphism work in Python?

Polymorphism enables different classes to use the same method name but implement different behavior for that method.

3. Why is encapsulation important in OOP?

Encapsulation ensures that an object’s internal state is protected from unauthorized access and is only modified through controlled methods.

---

🚀 What’s Next?

In the next lesson, you’ll learn about:

• Advanced file handling in Python
• Reading and writing different file types (e.g., CSV, JSON)
• Working with external files and data sources

---

➡ Next Lesson

Go to Lesson 21 →