Author: Saravana Kumar

Difference Between Abstraction and Encapsulation in Python | Simple Words + Examples

🔸 Let’s Understand Both:

Feature	Abstraction	Encapsulation
Meaning	Hide how it works, show only what it does	Hide data and code in one unit
Focus	On functionality	On security and data protection
Used with	Abstract Classes, `@abstractmethod`	Private variables, methods, classes
Real-life idea	TV remote – You don’t know how it works inside	Medicine capsule – It hides the inner parts

🔹 Example of Abstraction:

from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def pay(self):
        pass

class UPI(Payment):
    def pay(self):
        print("Payment using UPI")

p = UPI()
p.pay()

✅ The user only knows they are using UPI. How it works inside is hidden.

🔹 Example of Encapsulation:

class Student:
    def __init__(self):
        self.__marks = 0  # private variable

    def set_marks(self, m):
        self.__marks = m

    def get_marks(self):
        return self.__marks

s = Student()
s.set_marks(95)
print(s.get_marks())  # Output: 95

✅ The marks are protected. We use methods to access them.

🧾 Summary Table

Key Point	Abstraction	Encapsulation
Purpose	Hides unnecessary details	Hides sensitive data
How it’s done	With abstract classes & methods	Using private variables & methods
Access control?	No	Yes (`__private`)
Real-life comparison	TV remote	Medicine capsule

🧠 Easy Tip to Remember

🔍 Abstraction = “Don’t show how it works” (Focus on What)
🔒 Encapsulation = “Don’t let others touch my data” (Focus on How safe)

🎯 Recap in 2 Lines:

Abstraction hides logic
Encapsulation hides data

Both help you write clean and secure code.

July 6, 2025

Abstraction in Python | Hiding the Complex, Showing Only the Needed

🔹 What is Abstraction?

Abstraction means:

Hiding the complex details and showing only the important parts.

It helps us to:

Focus on what an object does
Not worry about how it does it

🔸 Real-Life Example:

Think about a TV remote:

You press the power button to turn on the TV.
You don’t need to know how electricity flows inside.

🟢 This is abstraction — showing only the button (interface), hiding the working inside.

🔹 Abstraction in Python

We use:

Abstract Base Class (ABC)
The abc module

🔹 How to Use Abstraction in Python

Import ABC and abstractmethod
Create a class that inherits from ABC
Use @abstractmethod to define abstract methods
Subclass must override these methods

🔹 Example:

from abc import ABC, abstractmethod

class Animal(ABC):  # Abstract class
    @abstractmethod
    def sound(self):  # Abstract method
        pass

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

class Cat(Animal):
    def sound(self):
        print("Cat meows")

d = Dog()
c = Cat()
d.sound()
c.sound()

🟢 Output:

Dog barks
Cat meows

🔹 Key Rules of Abstraction:

You cannot create an object of abstract class.
Child class must implement (override) abstract methods.
Abstract class can also have normal methods.

🔹 Abstract Class with Normal Method

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def start(self):
        pass

    def fuel_type(self):
        print("Fuel type is petrol")

class Car(Vehicle):
    def start(self):
        print("Car is starting...")

c = Car()
c.start()
c.fuel_type()

📝 Practice Questions with Answers

❓ Q1: Create an abstract class `Shape` with abstract method `area()`. Implement it in `Rectangle` and `Circle`.

✅ Answer:

from abc import ABC, abstractmethod

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

class Rectangle(Shape):
    def area(self):
        print("Area = length × width")

class Circle(Shape):
    def area(self):
        print("Area = π × radius²")

r = Rectangle()
c = Circle()
r.area()
c.area()

❓ Q2: Make an abstract class `Device` with `turn_on()` and `turn_off()` methods.

✅ Answer:

from abc import ABC, abstractmethod

class Device(ABC):
    @abstractmethod
    def turn_on(self):
        pass

    @abstractmethod
    def turn_off(self):
        pass

class Laptop(Device):
    def turn_on(self):
        print("Laptop is turning on")

    def turn_off(self):
        print("Laptop is shutting down")

l = Laptop()
l.turn_on()
l.turn_off()

🧾 Summary Table

Term	Meaning
Abstraction	Hiding how things work, showing only what’s needed
Abstract Class	A class with abstract methods
Abstract Method	Method with no body (empty function)
`@abstractmethod`	Used to create abstract methods

🎯 Quick Recap

Abstraction = Hiding details, showing only the essentials.
Use abc module, ABC, and @abstractmethod.
Helps write clean, structured, and safe code.

📣 Coming Up Next:

➡️ Difference Between Abstraction and Encapsulation in Python (Simple Words)

July 6, 2025

Method Overriding in Python | Easy Explanation with Examples
🔹 What is Method Overriding?

Method Overriding means:

A child class (subclass) writes its own version of a method that already exists in the parent class (superclass).
- It helps the child class change or improve the behavior of a parent method.
- The method name must be same in both classes.
🔸 Real-Life Example:

Imagine a general printer prints in black & white. But a color printer overrides that function and prints in color.

🔹 Basic Example of Method Overriding:
```
class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):  # Overriding the parent's method
        print("Dog barks")

d = Dog()
d.speak()  # Output: Dog barks
```
✅ Dog class has its own version of the speak() method.

🔹 Why Use Method Overriding?

✅ To customize behavior
✅ To add extra work in child class
✅ To make code flexible and clean

🔹 Calling Parent Method Using super()

Sometimes we want to call the original (parent) method also:
```
class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        super().speak()  # Call parent method
        print("Dog barks")

d = Dog()
d.speak()
```
🟢 Output:
```
Animal speaks
Dog barks
```
🔹 Another Example: Bank Account
```
class Account:
    def show_balance(self):
        print("Balance is $1000")

class SavingsAccount(Account):
    def show_balance(self):
        print("Savings balance is $1500")

a = SavingsAccount()
a.show_balance()
```
📝 Practice Questions with Answers

❓ Q1: Create a class Shape with a method draw(). Override it in Circle and Square.

✅ Answer:
```
class Shape:
    def draw(self):
        print("Drawing a shape")

class Circle(Shape):
    def draw(self):
        print("Drawing a circle")

class Square(Shape):
    def draw(self):
        print("Drawing a square")

c = Circle()
s = Square()

c.draw()
s.draw()
```
❓ Q2: Create a class Employee with method work(). Override it in Manager and Developer.

✅ Answer:
```
class Employee:
    def work(self):
        print("Employee works")

class Manager(Employee):
    def work(self):
        print("Manager manages the team")

class Developer(Employee):
    def work(self):
        print("Developer writes code")

m = Manager()
d = Developer()

m.work()
d.work()
```
🧾 Summary

Term Meaning
Overriding Child class redefines parent method
Method Name Must be the same in both classes
Use of super() To call the parent class method from child

🎯 Quick Recap
- Method Overriding = Changing a parent method in the child class.
- Useful when child class needs a different behavior.
- super() helps to use parent’s method with the new one.
July 6, 2025
Polymorphism in Python | One Name, Many Uses
🔹 What is Polymorphism?

The word Polymorphism means:

Poly = many, morph = form
So, Polymorphism = many forms

📌 In Python, the same function or method can work in different ways depending on the object.

🔹 Why Use Polymorphism?

✅ Makes code flexible
✅ Easy to understand and update
✅ Helps work with different objects in a similar way

🔹 Example: Polymorphism with Functions
```
def add(a, b):
    return a + b

print(add(3, 4))        # Numbers
print(add("Hi ", "Tom"))  # Strings
```
✅ Same function name add() works with numbers and strings — this is polymorphism.

🔹 Polymorphism with Classes

Let’s see two different classes using the same method name:
```
class Dog:
    def speak(self):
        print("Dog barks")

class Cat:
    def speak(self):
        print("Cat meows")

def animal_sound(animal):
    animal.speak()

d = Dog()
c = Cat()

animal_sound(d)
animal_sound(c)
```
✅ Different objects (Dog, Cat) use the same method speak() in different ways.

🔹 Polymorphism with Inheritance
```
class Vehicle:
    def move(self):
        print("Vehicle is moving")

class Car(Vehicle):
    def move(self):
        print("Car is driving")

class Boat(Vehicle):
    def move(self):
        print("Boat is sailing")

def start_trip(vehicle):
    vehicle.move()

v1 = Car()
v2 = Boat()

start_trip(v1)
start_trip(v2)
```
✅ move() method works differently for each object. This is runtime polymorphism.

🔹 Built-in Polymorphism Example
```
print(len("Python"))       # Output: 6
print(len([1, 2, 3, 4]))    # Output: 4
print(len((10, 20, 30)))    # Output: 3
```
✅ len() function works with string, list, tuple — same function name, many forms.

📝 Practice Questions with Answers

❓ Q1: Create a method called greet() in two classes: English and Spanish.

✅ Answer:
```
class English:
    def greet(self):
        print("Hello")

class Spanish:
    def greet(self):
        print("Hola")

def say_hello(obj):
    obj.greet()

e = English()
s = Spanish()
say_hello(e)
say_hello(s)
```
❓ Q2: Write a function that accepts any shape class and prints area using area() method.

✅ Answer:
```
class Circle:
    def area(self):
        print("Area of Circle: πr²")

class Square:
    def area(self):
        print("Area of Square: side²")

def print_area(shape):
    shape.area()

c = Circle()
s = Square()
print_area(c)
print_area(s)
```
🧾 Summary Table

Term Meaning
Polymorphism One method or function, many forms
Built-in Functions like len(), +, etc.
User-defined Methods in different classes with same name

🎯 Quick Recap
- Polymorphism helps the same method name work in different ways.
- It can be seen in:
  - Functions
  - Classes
  - Inheritance
  - Built-in functions
July 6, 2025

Term	Meaning
Overriding	Child class redefines parent method
Method Name	Must be the same in both classes
Use of `super()`	To call the parent class method from child

Term	Meaning
Polymorphism	One method or function, many forms
Built-in	Functions like `len()`, `+`, etc.
User-defined	Methods in different classes with same name

Inheritance in Python | Learn How One Class Can Use Another

🔹 What is Inheritance?

Inheritance means a class (child) can use the data and functions from another class (parent).
This helps us reuse code and build bigger programs easily.

📌 Real-life example: A child gets features from parents — like eyes, language, habits.
Same way, a class gets methods and data from another class.

🔹 Why Use Inheritance?

✅ Reuse old code
✅ Add new features easily
✅ Clean and simple design
✅ Avoid writing same code again

🔹 Basic Example: Simple Inheritance

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

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

d = Dog()
d.speak()  # From parent
d.bark()   # From child

🔸 Types of Inheritance in Python (with Examples)

Python supports 5 types of inheritance:

1. Single Inheritance

One parent class → One child class

class Parent:
    def show(self):
        print("This is Parent")

class Child(Parent):
    def display(self):
        print("This is Child")

c = Child()
c.show()
c.display()

2. Multilevel Inheritance

Parent → Child → Grandchild

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

class Father(Grandfather):
    def car(self):
        print("Father's car")

class Son(Father):
    def bike(self):
        print("Son's bike")

s = Son()
s.house()
s.car()
s.bike()

3. Hierarchical Inheritance

One parent → Many children

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

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

class Cat(Animal):
    def meow(self):
        print("Cat meows")

d = Dog()
c = Cat()
d.sound(); d.bark()
c.sound(); c.meow()

4. Multiple Inheritance

Child class inherits from two or more parent classes

class Father:
    def job(self):
        print("Father is a teacher")

class Mother:
    def cook(self):
        print("Mother cooks food")

class Child(Father, Mother):
    def play(self):
        print("Child plays cricket")

c = Child()
c.job()
c.cook()
c.play()

5. Hybrid Inheritance

Combination of multiple types (e.g., multiple + multilevel)

class A:
    def a(self):
        print("Class A")

class B(A):
    def b(self):
        print("Class B")

class C:
    def c(self):
        print("Class C")

class D(B, C):  # Combines B (from A) + C
    def d(self):
        print("Class D")

obj = D()
obj.a()
obj.b()
obj.c()
obj.d()

🔹 Using `super()` to Access Parent Constructor

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

class Student(Person):
    def __init__(self, name, grade):
        super().__init__(name)  # call parent __init__
        self.grade = grade

s = Student("Arun", "A")
print(s.name, s.grade)

📝 Practice Questions with Answers

❓ Q1: Create a base class `Vehicle`, and `Car`, `Bike` should inherit from it.

✅ Answer:

class Vehicle:
    def start(self):
        print("Vehicle starts")

class Car(Vehicle):
    def drive(self):
        print("Car drives")

class Bike(Vehicle):
    def ride(self):
        print("Bike rides")

c = Car()
c.start(); c.drive()

b = Bike()
b.start(); b.ride()

❓ Q2: Show multilevel inheritance using `Company`, `Manager`, `Employee`.

✅ Answer:

class Company:
    def company_name(self):
        print("XYZ Ltd")

class Manager(Company):
    def manage(self):
        print("Manages team")

class Employee(Manager):
    def work(self):
        print("Works on project")

e = Employee()
e.company_name()
e.manage()
e.work()

🧾 Summary Table

Inheritance Type	Structure Example
Single	A → B
Multilevel	A → B → C
Hierarchical	A → B, A → C
Multiple	A + B → C
Hybrid	Combination of above

📣 Coming Up Next:

➡️ Polymorphism in Python | One Name, Many Forms (Easy Guide)

July 6, 2025

Author: Saravana Kumar

Difference Between Abstraction and Encapsulation in Python | Simple Words + Examples

🔸 Let’s Understand Both:

🔹 Example of Abstraction:

🔹 Example of Encapsulation:

🧾 Summary Table

🧠 Easy Tip to Remember

🎯 Recap in 2 Lines:

Abstraction in Python | Hiding the Complex, Showing Only the Needed

🔹 What is Abstraction?

🔸 Real-Life Example:

🔹 Abstraction in Python

🔹 How to Use Abstraction in Python

🔹 Example:

🔹 Key Rules of Abstraction:

🔹 Abstract Class with Normal Method

📝 Practice Questions with Answers

❓ Q1: Create an abstract class Shape with abstract method area(). Implement it in Rectangle and Circle.

❓ Q2: Make an abstract class Device with turn_on() and turn_off() methods.

🧾 Summary Table

🎯 Quick Recap

📣 Coming Up Next:

Method Overriding in Python | Easy Explanation with Examples

🔹 What is Method Overriding?

🔸 Real-Life Example:

🔹 Basic Example of Method Overriding:

🔹 Why Use Method Overriding?

🔹 Calling Parent Method Using super()

🔹 Another Example: Bank Account

📝 Practice Questions with Answers

❓ Q1: Create a class Shape with a method draw(). Override it in Circle and Square.

❓ Q2: Create a class Employee with method work(). Override it in Manager and Developer.

🧾 Summary

🎯 Quick Recap

Polymorphism in Python | One Name, Many Uses

🔹 What is Polymorphism?

🔹 Why Use Polymorphism?

🔹 Example: Polymorphism with Functions

🔹 Polymorphism with Classes

🔹 Polymorphism with Inheritance

🔹 Built-in Polymorphism Example

📝 Practice Questions with Answers

❓ Q1: Create a method called greet() in two classes: English and Spanish.

❓ Q2: Write a function that accepts any shape class and prints area using area() method.

🧾 Summary Table

🎯 Quick Recap

Inheritance in Python | Learn How One Class Can Use Another

🔹 What is Inheritance?

🔹 Why Use Inheritance?

🔹 Basic Example: Simple Inheritance

🔸 Types of Inheritance in Python (with Examples)

1. Single Inheritance

2. Multilevel Inheritance

3. Hierarchical Inheritance

4. Multiple Inheritance

5. Hybrid Inheritance

🔹 Using super() to Access Parent Constructor

📝 Practice Questions with Answers

❓ Q1: Create a base class Vehicle, and Car, Bike should inherit from it.

❓ Q2: Show multilevel inheritance using Company, Manager, Employee.

🧾 Summary Table

📣 Coming Up Next:

❓ Q1: Create an abstract class `Shape` with abstract method `area()`. Implement it in `Rectangle` and `Circle`.

❓ Q2: Make an abstract class `Device` with `turn_on()` and `turn_off()` methods.

🔹 Calling Parent Method Using `super()`

❓ Q1: Create a class `Shape` with a method `draw()`. Override it in `Circle` and `Square`.

❓ Q2: Create a class `Employee` with method `work()`. Override it in `Manager` and `Developer`.

❓ Q1: Create a method called `greet()` in two classes: `English` and `Spanish`.

❓ Q2: Write a function that accepts any shape class and prints area using `area()` method.

🔹 Using `super()` to Access Parent Constructor

❓ Q1: Create a base class `Vehicle`, and `Car`, `Bike` should inherit from it.

❓ Q2: Show multilevel inheritance using `Company`, `Manager`, `Employee`.