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

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

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

for pet in [Dog(), Cat()]:
    pet.speak()

Each object responds differently to the same speak() call.

Method Overloading (Simulated)

class Math:
    def add(self, a, b, c=None):
        if c:
            return a + b + c
        return a + b

m = Math()
print(m.add(1, 2))
print(m.add(1, 2, 3))

Python doesn’t support true overloading, so we use default parameters.

Polymorphism with Functions & Objects

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

class Plane:
    def move(self):
        print("Plane is flying")

def operate(vehicle):
    vehicle.move()

operate(Car())
operate(Plane())

Same function → different behavior based on object type.

Polymorphism with Inheritance

class Shape:
    def area(self):
        raise NotImplementedError("Subclass must implement this")

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

class Circle(Shape):
    def __init__(self, r):
        self.r = r
    def area(self):
        return 3.14 * self.r * self.r

for s in [Square(4), Circle(5)]:
    print(s.area())

Child classes provide unique logic for inherited structure.

Real-World Example (Combined)

class User:
    def login(self):
        print("Login from User")

class Admin(User):
    def login(self):
        print("Admin login with security check")

class Customer(User):
    def login(self):
        print("Customer login")

users = [Admin(), Customer(), User()]
for u in users:
    u.login()

Explanation

Admin & Customer override the login() method.
Same method name → different behaviors based on object type.

Summary

Feature	What It Does	Example
Inheritance	Reuse parent class features	`class B(A)`
Multiple Inheritance	Child from multiple parents	`class C(A,B)`
Polymorphism	Same method, different behavior	Overriding
Overriding	Modify parent method	Redefine in child
Overloading	Same name, different arguments	Default parameters

Python Inheritance

Inheritance Definition

Inheritance allows a class (child) to acquire properties and methods of another class (parent).

This promotes:

Code reusability
Hierarchy / structure
Cleaner and scalable programs

Basic Inheritance

class Animal:
    def speak(self):
        print("Animals make sound")

class Dog(Animal):  # Dog inherits from Animal
    pass

d = Dog()
d.speak()

Explanation

Animal is the parent/base class.
Dog is the child/derived class.
Dog gets the speak() method without writing it again.

Single Inheritance

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

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

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

📝 Child gets access to both:
➡ show() (from Parent)
➡ display() (its own)

Multilevel Inheritance

class A:
    def feature1(self):
        print("Feature 1")

class B(A):
    def feature2(self):
        print("Feature 2")

class C(B):
    def feature3(self):
        print("Feature 3")

c = C()
c.feature1()
c.feature2()
c.feature3()

📝 Chain of inheritance: A → B → C
Class C inherits everything.

Multiple Inheritance

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

class Mother:
    def car(self):
        print("Mother's car")

class Child(Father, Mother):
    pass

obj = Child()
obj.bike()
obj.car()

📝 Child receives methods of both parents.

Hierarchical Inheritance

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

class Dog(Animal):
    pass

class Cat(Animal):
    pass

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

📝 One parent → Multiple children.

Using `super()` to Access Parent Data

class Parent:
    def __init__(self):
        print("Parent constructor")

class Child(Parent):
    def __init__(self):
        super().__init__()
        print("Child constructor")

c = Child()

📝 super() is used to call parent methods/constructors.

Python Generators

Python Generators Introduction

A Generator in Python is a special type of function that yields values one at a time, instead of returning them all at once.

Generators are memory-efficient and used for working with large datasets, streams, or infinite sequences.

Why Generators?

Feature	Why it matters
Lazy evaluation	Values are produced on demand, not all at once
Memory efficient	Doesn’t store entire data in memory
Improves performance	Faster for large datasets / loops
Infinite sequences	Possible to generate endless values

Regular Function vs Generator

Normal Function

def numbers():
    return [1,2,3]

Generator Function

def numbers():
    yield 1
    yield 2
    yield 3

The keyword yield makes it a generator.

How to Use a Generator

def numbers():
    yield 1
    yield 2
    yield 3

gen = numbers()
print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3

Generator with Loop

def countdown(n):
    while n > 0:
        yield n
        n -= 1

for num in countdown(5):
    print(num)

Difference Between return and yield

Keyword	Behavior
return	Exits function and sends a single value
yield	Pauses function, saves state, returns value, resumes on next call

Generator Expression

List comprehension

squares = [x*x for x in range(5)]

Generator expression

squares = (x*x for x in range(5))
print(squares)         # <generator object>
print(next(squares))   # 0, then 1, 4, 9...

Practical Examples

Generate Even Numbers

def even_numbers(limit):
    for n in range(limit+1):
        if n % 2 == 0:
            yield n

for i in even_numbers(10):
    print(i)

Read Large Files Line by Line (Memory Friendly)

def read_file(filepath):
    with open(filepath) as f:
        for line in f:
            yield line

for line in read_file("large_data.txt"):
    print(line)

Infinite Generator (Be careful!)

def infinite_counter():
    num = 1
    while True:
        yield num
        num += 1

gen = infinite_counter()
print(next(gen))
print(next(gen))

Fibonacci Series Generator

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(10):
    print(num)

Generator to Filter Data

def filter_positive(numbers):
    for num in numbers:
        if num > 0:
            yield num

nums = [-4, 3, 5, -1, 9]
for n in filter_positive(nums):
    print(n)

Python Decorators

Decorator Definition

A decorator in Python is a function that modifies the behavior of another function, without changing its code.

Think of a decorator as adding a layer of functionality before and/or after the original function runs.

Why Use Decorators?

Purpose	Example Use Case
Add functionality without editing original code	Logging, Authorization
Reuse common logic	Validation
Track performance	Execution time calculator
Restrict access	Admin/user roles

Basic Decorator Structure

def decorator_function(original_function):
    def wrapper_function():
        # Code before
        original_function()
        # Code after
    return wrapper_function

Applying a Decorator

@decorator_function
def display():
    print("Display function executed")

The @decorator_function applies extra behavior to the display() function.

Basic Example

def my_decorator(func):
    def wrapper():
        print("Before function runs")
        func()
        print("After function runs")
    return wrapper

@my_decorator
def greet():
    print("Hello!")

greet()

Output:

Before function runs
Hello!
After function runs

Decorator With Arguments

def decorator(func):
    def wrapper(*args, **kwargs):
        print("Arguments:", args, kwargs)
        return func(*args, **kwargs)
    return wrapper

@decorator
def add(a, b):
    print("Sum =", a + b)

add(5, 3)

Decorator Returning a Value

def decorator(func):
    def wrapper(*args):
        result = func(*args)
        print("Function returned:", result)
        return result
    return wrapper

@decorator
def multiply(x, y):
    return x * y

multiply(4, 5)

Real-World Example – Logging

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"Running function: {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@logger
def show():
    print("Inside show function")

show()

Example – Execution Time Calculator

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"Execution Time: {end-start:.5f} seconds")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(2)

slow_function()

Authentication / Access Control

def require_admin(func):
    def wrapper(user):
        if user != "admin":
            print("Access Denied!")
        else:
            return func(user)
    return wrapper

@require_admin
def delete_data(user):
    print("Data deleted successfully!")

delete_data("guest")
delete_data("admin")

Decorators with Parameters (Advanced)

Sometimes we need the decorator to accept its own argument:

def repeat(num):
    def decorator(func):
        def wrapper():
            for _ in range(num):
                func()
        return wrapper
    return decorator

@repeat(3)
def hello():
    print("Hello")

hello()

Output

Hello
Hello
Hello

Nesting Multiple Decorators

def bold(func):
    def wrapper():
        print("<b>", end="")
        func()
        print("</b>")
    return wrapper

def italic(func):
    def wrapper():
        print("<i>", end="")
        func()
        print("</i>")
    return wrapper

@bold
@italic
def text():
    print("Decorated Text", end="")

text()

Python List MCQ Quiz (Random 10 from 50)

⏳ Time Remaining: 60 seconds

Python String MCQ Quiz (Random 10 from 50)

Python Loops MCQ Quiz (Random 10 from 50)

Python IF Conditions MCQ Quiz (Random 10 from 50)

Python Datatypes MCQ Quiz (Random 10 Questions)

Python Variables MCQ Quiz (Random 10 of 50 Questions)

Polymorphism Definition

Method Overriding (Runtime Polymorphism)

Method Overloading (Simulated)

Polymorphism with Functions & Objects

Polymorphism with Inheritance

Real-World Example (Combined)

Explanation

Summary

Inheritance Definition

Basic Inheritance

Explanation

Single Inheritance

Multilevel Inheritance

Multiple Inheritance

Hierarchical Inheritance

Using super() to Access Parent Data

Python Generators Introduction

Why Generators?

Regular Function vs Generator

Normal Function

Generator Function

How to Use a Generator

Generator with Loop

Difference Between return and yield

Generator Expression

List comprehension

Generator expression

Practical Examples

Generate Even Numbers

Read Large Files Line by Line (Memory Friendly)

Infinite Generator (Be careful!)

Fibonacci Series Generator

Generator to Filter Data

Decorator Definition

Why Use Decorators?

Basic Decorator Structure

Applying a Decorator

Basic Example

Decorator With Arguments

Decorator Returning a Value

Real-World Example – Logging

Example – Execution Time Calculator

Authentication / Access Control

Decorators with Parameters (Advanced)

Nesting Multiple Decorators

Using `super()` to Access Parent Data