DEV Community: Deepika Pusala

Week 4 - Task 2.3 : From Functions to Powerful Decorators 🐍💜

Deepika Pusala — Tue, 25 Aug 2026 09:27:00 +0000

Four concepts, one story: functions can be treated like values → that lets inner functions remember things → which lets us build decorators → which can be made configurable. Let's walk through it end to end.

First-Class Functions
        ↓
Functions can be passed around & returned
        ↓
Closures become possible
        ↓
Closures help us build decorators
        ↓
Decorators can accept parameters
        ↓
functools.wraps preserves metadata

1️⃣ First-Class Functions

In Python, a function is just another value — you can store it, pass it, or return it, exactly like an int or a string.

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

x = greet   # NOT greet() — just the function itself
x()         # Hello!

Code	Meaning
`greet`	The function itself
`greet()`	Executes the function
`x = greet`	Stores the function in `x`
`x = greet()`	Stores the return value of calling it

Passing a function as an argument

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

def execute(func):
    func()

execute(greet)   # Hello!

Real use: a generic perform_action() that works with any function you hand it:

def login(): print("Logging in")
def logout(): print("Logging out")

def perform_action(action):
    action()

perform_action(login)
perform_action(logout)

Returning a function

def outer():
    def inner():
        print("Hello from inner")
    return inner

x = outer()
x()   # Hello from inner

This — a function that creates and returns another function — is the doorway into closures.

2️⃣ Closures 🔐

A closure is a function that remembers variables from its surrounding scope, even after the outer function has already finished running.

Think of it like a parent passing a secret to their child before leaving — the child still remembers it long after the parent is gone.

def outer():
    name = "Deepika"

    def inner():
        print(name)

    return inner

func = outer()
func()   # Deepika

outer() has already returned by the time we call func() — yet inner() still remembers name. That's the closure at work.

The 3 ingredients of a closure

#	Requirement
1	A nested function
2	The inner function uses a variable from the outer scope
3	The outer function returns the inner function

A more useful example

def multiplier(number):
    def multiply(x):
        return x * number
    return multiply

double = multiplier(2)
triple = multiplier(3)

print(double(5))   # 10
print(triple(5))   # 15

double and triple are two separate closures — each remembers a different number.

3️⃣ Decorators 🎁

A decorator is a function that modifies or extends another function's behavior without changing its original code.

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

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

greet()

Before function
Hello!
After function

What `@decorator` actually does

@decorator
def greet():
    print("Hello")

is literally shorthand for:

def greet():
    print("Hello")

greet = decorator(greet)

decorator(greet) returns wrapper, and greet now points to wrapper instead of the original function.

4️⃣ Parameterized Decorators 🎯

What if the decorator itself needs an argument?

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

Here repeat(3) isn't the function being decorated — it's configuring the decorator. That requires one extra layer of nesting.

def repeat(times):              # 1️⃣ receives the decorator's argument

    def decorator(func):        # 2️⃣ receives the actual function

        def wrapper():          # 3️⃣ runs the function
            for _ in range(times):
                func()

        return wrapper

    return decorator

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

greet()

Hello
Hello
Hello

The three layers:

repeat(times) — captures times = 3
decorator(func) — captures func = greet
wrapper() — actually calls func(), times times

The key insight: it's a closure

wrapper() uses times, which belongs to repeat(times) — an outer function that has already returned. That's exactly the closure pattern from earlier.

repeat(3)
│
├── times = 3
│
└── decorator()
      │
      └── wrapper()
             │
             └── remembers times = 3

Parameterized decorators are built using closures. That's the connection worth remembering.

Another example — a message decorator:

def message(text):
    def decorator(func):
        def wrapper():
            print(text)
            func()
        return wrapper
    return decorator

@message("Welcome to Python!")
def greet():
    print("Hello Deepika")

greet()

Welcome to Python!
Hello Deepika

5️⃣ The Metadata Problem 😭

def greet():
    """This function greets the user."""
    print("Hello")

print(greet.__name__)   # greet
print(greet.__doc__)    # This function greets the user.

Now decorate it:

def decorator(func):
    def wrapper():
        func()
    return wrapper

@decorator
def greet():
    """This function greets the user."""
    print("Hello")

print(greet.__name__)   # wrapper  😳

Since greet = decorator(greet) makes greet point to wrapper, Python loses track of the original function's name and docstring.

The fix: `functools.wraps`

from functools import wraps

def decorator(func):
    @wraps(func)
    def wrapper():
        func()
    return wrapper

@decorator
def greet():
    """This function greets the user."""
    print("Hello")

print(greet.__name__)   # greet
print(greet.__doc__)    # This function greets the user.

@wraps(func) copies over metadata like __name__, __doc__, __module__, and __annotations__ from the original function onto the wrapper.

Why it matters: in a real app with 100 decorated functions, without @wraps every single one shows up as wrapper during debugging. With it, each keeps its real name — much easier to trace.

6️⃣ *args and **kwargs — Making Decorators Work with Any Function

A real decorator needs to handle functions with different signatures:

from functools import wraps

def decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("Before function")
        result = func(*args, **kwargs)
        print("After function")
        return result
    return wrapper

Now it works whether the decorated function is add(10, 20), greet("Deepika"), or login(username="deepika", password="1234"). This is why almost every real-world decorator you'll see includes *args, **kwargs.

🧩 Putting It All Together

from functools import wraps

def repeat(times):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def greet():
    """Greets the user."""
    print("Hello!")

greet()
print(greet.__name__)   # greet
print(greet.__doc__)    # Greets the user.

This one example uses all four concepts:

func — a function passed as a first-class value
wrapper() remembering times — a closure
@repeat(3) — a parameterized decorator
@wraps(func) — preserving metadata

🌍 Where This Shows Up in Real Code

Application	What decorators do
🔐 Authentication	Check whether a user is logged in
⏱️ Performance	Measure execution time
📝 Logging	Record function calls
🔑 Authorization	Check permissions
💾 Caching	Store previous results (`@lru_cache`)
🐛 Debugging	Track function behavior
🌐 Web frameworks	Route functions to URLs — e.g. `@app.route("/home")`
🔄 Retry logic	Retry failed operations

🎯 Interview-Ready Definitions

Question	Answer
What is a first-class function?	A function that can be stored in a variable, passed as an argument, and returned from another function — treated like any other value
What is a closure?	An inner function that remembers and can access variables from its enclosing scope, even after the outer function has finished executing
What is a parameterized decorator?	A decorator that accepts its own arguments/configuration before receiving the function it decorates, e.g. `@repeat(3)`
Why use `functools.wraps`?	It preserves the original function's metadata (name, docstring, etc.) when a decorator replaces it with a wrapper

🧠 One Mental Model to Hold On To

FUNCTION
   │  can be treated like a value
   ▼
FIRST-CLASS FUNCTION
   │  can be returned
   ▼
INNER FUNCTION
   │  remembers outer variables
   ▼
CLOSURE
   │  used to build
   ▼
DECORATOR
   │  accepts configuration
   ▼
PARAMETERIZED DECORATOR
   │  use @wraps
   ▼
CLEAN + PRESERVED METADATA

The go-to code skeleton for any configurable decorator:

from functools import wraps

def decorator(argument):
    def actual_decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # extra behavior before
            result = func(*args, **kwargs)
            # extra behavior after
            return result
        return wrapper
    return actual_decorator

Once you can name what each of those three nested functions is doing, parameterized decorators stop looking scary. ❤️

Week 04- Task 2.2: functools Toolkit: reduce, partial, lru_cache & wraps 🧰

Deepika Pusala — Tue, 25 Aug 2026 09:22:53 +0000

functools is Python's built-in module for working with functions themselves — combining them, pre-filling their arguments, remembering their results, and preserving their identity through decorators. Let's go through all four.

Python
  │
  ├── math
  ├── random
  ├── os
  └── functools   ← tools for working with functions

from functools import reduce, partial, lru_cache, wraps

➕ 1. `reduce()` — Combine everything into ONE

reduce() collapses a collection down to a single value by repeatedly combining items.

from functools import reduce

numbers = [1, 2, 3, 4, 5]
result = reduce(lambda a, b: a + b, numbers)
print(result)   # 15

Step by step:

1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15

Syntax: reduce(function, iterable) — where a is the accumulated result so far, and b is the next item.

🧠 map vs filter vs reduce — the shape of the output

	Direction	Example (`[1,2,3,4]`)
`map()`	many → many	`[2, 4, 6, 8]`
`filter()`	many → fewer	`[2, 4]`
`reduce()`	many → one	`10`

🟣 2. `partial()` — Pre-fill some arguments

Say you have a normal two-argument function:

def add(a, b):
    return a + b

print(add(10, 20))   # 30

Now imagine you almost always want a to be 10. You could write a wrapper function manually:

def add_10(b):
    return add(10, b)

...but partial() does this for you, cleanly:

from functools import partial

add_10 = partial(add, 10)

print(add_10(5))    # 15
print(add_10(20))   # 30

add_10(5) is really just add(10, 5) under the hood — the first argument is permanently locked in.

Think of it like a form with a field you've already filled in:

Name: ______
Age:  ______
City: Bangalore   ← pre-filled by partial()

Another example:

def multiply(a, b):
    return a * b

multiply_by_10 = partial(multiply, 10)

print(multiply_by_10(5))   # 50
print(multiply_by_10(7))   # 70

Use partial() when: a function takes several arguments, but one of them is always the same in your use case. Instead of repeating function(10, x) everywhere, create new_function = partial(function, 10) once and call new_function(x).

🔵 3. `lru_cache()` — Remember previous results

Caching = remembering answers you've already calculated, so you don't redo the work.

Without caching:

def square(n):
    print("Calculating...")
    return n * n

square(5)
square(5)
square(5)
# "Calculating..." prints all three times

With caching:

from functools import lru_cache

@lru_cache
def square(n):
    print("Calculating...")
    return n * n

square(5)
square(5)
square(5)

Calculating...
25
25
25

"Calculating..." only prints once — every call after the first pulls the answer straight from the cache instead of recomputing it.

square(5) first call
   ↓
not in cache → calculate → 25 → remember (5 → 25)

square(5) again
   ↓
found in cache → return 25, no calculation

Why "LRU"?

LRU = Least Recently Used. If the cache has limited space and needs to make room for a new result, it evicts the entry that hasn't been used in the longest time.

One-liner for interviews: "lru_cache caches a function's results so repeated calls with the same arguments return instantly without recalculating."

🔥 Where it actually matters

Expensive, repeatable computations: recursion, dynamic programming, heavy math, or repeated lookups.

Classic case — Fibonacci:

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

Plain recursion recalculates the same sub-values over and over:

fib(5)
 ├── fib(4)
 │    ├── fib(3)
 │    └── fib(2)
 └── fib(3)          ← calculated again!
      ├── fib(2)     ← calculated again!
      └── fib(1)

Add caching, and each unique value is computed only once:

from functools import lru_cache

@lru_cache
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))

🟠 4. `wraps()` — Preserve a function's identity through decorators

First, what's a decorator?

A function that adds behavior around another function, without touching its original code:

def decorator(func):
    def wrapper():
        print("Starting")
        func()
        print("Finished")
    return wrapper

@decorator
def greet():
    print("Hello")

greet()

Starting
Hello
Finished

The problem

print(greet.__name__)

You'd expect "greet" — but you actually get "wrapper". Once decorated, greet now points to the inner wrapper function, so Python loses track of the original function's name, docstring, and other metadata.

The fix: `@wraps(func)`

from functools import wraps

def decorator(func):
    @wraps(func)
    def wrapper():
        print("Before")
        func()
        print("After")
    return wrapper

Now greet.__name__ correctly stays "greet", and its docstring survives too.

🎁 A simple analogy

Original gift:

🎁 Name: Birthday Gift
   Description: Something special

You wrap it in another box:

📦
  🎁

Without wraps(), Python thinks the outer box is the gift and forgets the label. With wraps(), you tell Python: "There's a wrapper here, but keep the original gift's identity."

The standard pattern you'll see everywhere

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # extra behavior here
        result = func(*args, **kwargs)
        return result
    return wrapper

🧩 Putting It All Together

Tool	Purpose	Example
`reduce()`	Combine many values into one	`reduce(lambda a,b: a+b, [1,2,3,4])` → `10`
`partial()`	Pre-fill some arguments of a function	`partial(multiply, 2)(5)` → `10`
`lru_cache()`	Remember previous results, skip recomputation	`@lru_cache` on `square(n)`
`wraps()`	Preserve a function's metadata inside a decorator	`@wraps(func)` inside `wrapper`

                 functools
                     │
       ┌─────────────┼──────────────┐
       │             │              │
     reduce       partial       lru_cache
       │             │              │
   many → ONE    pre-fill       remember
                  arguments      results
       │             │              │
       └─────────────┼──────────────┘
                     │
                   wraps
                     │
             preserve function
                information

Week 04 - Task 2.1: Functional Programming in Python: map(), filter(), reduce() 🗺️🔎➕

Deepika Pusala — Tue, 25 Aug 2026 09:19:25 +0000

Give Python a collection of values, and you'll almost always want to do one of three things to it: change every item, pick out some items, or combine everything into one. That's the entire story of map(), filter(), and reduce().

🧠 What Is Functional Programming, Really?

Nothing scary — it's just a style where you process data by passing it through functions, rather than manually looping and mutating things.

[1, 2, 3, 4, 5]
       ↓
   multiply by 2
       ↓
[2, 4, 6, 8, 10]

Python gives you three built-in tools for exactly this kind of thinking: map(), filter(), and reduce().

🗺️ `map()` — "Do this to EVERY item"

map() transforms every single element the same way.

numbers = [1, 2, 3, 4, 5]
result = list(map(lambda x: x * 2, numbers))
print(result)
# [2, 4, 6, 8, 10]

What's lambda x: x * 2? Just a tiny, unnamed function — shorthand for:

def double(x):
    return x * 2

Real example:

names = ["deepika", "rahul", "ananya"]
result = list(map(str.upper, names))
# ['DEEPIKA', 'RAHUL', 'ANANYA']

Interview-ready answer: "map() applies a function to every element of an iterable and produces the transformed results."

Use it when: you're converting/transforming every item the same way — uppercasing strings, doubling numbers, converting units, extracting a field from each object.

🧠 MAP = MODIFY EVERYONE

🔎 `filter()` — "Keep only the ones I want"

filter() doesn't change anything — it selects items based on a condition.

numbers = [1, 2, 3, 4, 5, 6]
result = list(filter(lambda x: x % 2 == 0, numbers))
print(result)
# [2, 4, 6]

For each number, lambda x: x % 2 == 0 asks "is this even?" — only the ones that return True survive:

1 → False → ❌
2 → True  → ✅
3 → False → ❌
4 → True  → ✅
5 → False → ❌
6 → True  → ✅

Interview-ready answer: "filter() keeps only the elements for which the condition returns True."

🧠 FILTER = CHOOSE

🆚 map() vs filter() — the quick gut-check

	`map()`	`filter()`
Job	Transform every item	Select some items
Item count	Stays the same	Can shrink
Mental model	"Do something to everyone"	"Keep only those who qualify"

➕ `reduce()` — "Combine everything into ONE result"

The trickiest of the three — because instead of many outputs, you get one.

from functools import reduce

numbers = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, numbers)
print(result)
# 15

It works step by step:

1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15

Why two parameters (x, y) instead of one? Because reduce() is always combining two things at a time: the accumulated result so far (x) and the next item (y).

Note: unlike map() and filter(), reduce() isn't built-in by default — you import it from functools.

🧠 REDUCE = COMBINE

🍕 Real-World Example: Running a Pizza Shop

prices = [100, 200, 300, 400]

map() — bump every price by ₹50:

new_prices = list(map(lambda x: x + 50, prices))
# [150, 250, 350, 450]

filter() — show only pizzas above ₹200:

expensive = list(filter(lambda x: x > 200, prices))
# [300, 400]

reduce() — get the total bill:

from functools import reduce
total = reduce(lambda x, y: x + y, prices)
# 1000

🏆 The Cheat Sheet

Function	Meaning	Question it answers	Result
`map()`	Transform	"What should I do to every item?"	Transformed values
`filter()`	Select	"Which items should I keep?"	Selected values
`reduce()`	Combine	"How can I combine everything?"	Usually one value

MAP    → TRANSFORM
FILTER → SELECT
REDUCE → COMBINE

⚠️ A Small Gotcha

map() and filter() don't hand you a plain list directly — they return a lazy map/filter object. That's why you'll almost always wrap them in list(...):

result = list(map(lambda x: x * 2, numbers))
result = list(filter(lambda x: x % 2 == 0, numbers))

🤔 "Why not just use a `for` loop?"

You absolutely can:

result = []
for x in numbers:
    result.append(x * 2)

This does the exact same thing as list(map(lambda x: x * 2, numbers)). map()/filter() can express intent more concisely for simple transformations — but they're not automatically "better." Python developers often reach for a plain loop when the logic gets more complex or less readable as a one-liner.

✨ The More "Pythonic" Alternative: List Comprehensions

For simple cases, most Python code actually favors list comprehensions over map()/filter():

# instead of:
result = list(map(lambda x: x * 2, numbers))
# you'll often see:
result = [x * 2 for x in numbers]

# instead of:
result = list(filter(lambda x: x % 2 == 0, numbers))
# you'll often see:
result = [x for x in numbers if x % 2 == 0]

Still — understanding map(), filter(), and reduce() matters, because they're the foundation of functional-programming thinking in Python (and show up constantly in interviews and other languages too).

🎯 One Sentence to Remember

map() changes every item, filter() picks the items that qualify, and reduce() collapses everything down into a single result.

Week 04 - Task 1.3 : @dataclass, abstract base classes via the abc module & composition vs inheritance

Deepika Pusala — Tue, 25 Aug 2026 09:15:09 +0000

Three more Python OOP tools that sound fancy but solve very ordinary problems: cutting boilerplate, enforcing rules on child classes, and choosing the right kind of relationship between objects.

🎁 `@dataclass` — Stop Writing Boilerplate

Every class that just stores data ends up looking the same:

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

    def __repr__(self):
        return f"Student(name={self.name}, age={self.age})"

@dataclass writes that for you:

from dataclasses import dataclass

@dataclass
class Student:
    name: str
    age: int

student = Student("Deepika", 21)
print(student)
# Student(name='Deepika', age=21)

Python auto-generates __init__(), __repr__(), and a few other useful methods based on the fields you declare.

Simple definition: @dataclass is a decorator that auto-generates common methods for classes whose main job is holding data.

Use it when: the class is basically a data container — think DTOs, config objects, records — not something with complex custom behavior.

🧱 Abstract Base Classes (`abc`) — Enforcing a Contract

Sometimes you don't want to give child classes an option to implement something — you want to force it.

Say you have several shapes, and every single one must have an area() method:

from abc import ABC, abstractmethod

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

Shape is now an Abstract Base Class. @abstractmethod means:

"Every child class must provide its own area()."

class Circle(Shape):
    def area(self):
        return 3.14 * 5 * 5

Try to instantiate Shape directly, though:

shape = Shape()   # ❌ TypeError

Python refuses, because Shape still has an unimplemented abstract method.

Shape
 ├── Circle     → must implement area()
 ├── Rectangle  → must implement area()
 └── Triangle   → must implement area()

Simple definition: an Abstract Base Class defines methods that every child class is required to implement — a shared contract.

⚖️ `@dataclass` vs ABC — Different Jobs

`@dataclass`	Abstract Base Class
Mainly stores data	Defines rules/structure
Cuts boilerplate	Forces child classes to implement methods
Auto-generates `__init__`, `__repr__`, etc.	Uses `@abstractmethod`
Great for data models	Great for shared interfaces

One-liners to remember:

@dataclass → "I want to store data easily."
ABC → "I want my child classes to follow a rule."

🧬 Composition vs Inheritance

This one trips people up conceptually more than syntactically. The cleanest way to hold it in your head:

Inheritance = IS-A · Composition = HAS-A

Inheritance (IS-A)

One class is a type of another.

class Animal:
    def eat(self):
        print("Eating")

class Dog(Animal):
    pass

Dog IS-A Animal — so Dog inherits eat() for free.

Same logic: Car IS-A Vehicle, Circle IS-A Shape.

Composition (HAS-A)

One class contains another — it's built out of other objects, rather than being a specialized version of one.

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self.engine = Engine()

car = Car()
car.engine.start()

A Car is not an Engine — it has an Engine. That relationship calls for composition, not inheritance.

A car also HAS-A Steering and HAS-A Battery — same pattern.

Side by Side

Inheritance	Composition
IS-A relationship	HAS-A relationship
Child inherits from parent	Object contains another object
`class Car(Vehicle)`	`self.engine = Engine()`
Reuse through hierarchy	Reuse through objects
Can create tight coupling	Usually more flexible

When to use which

Inheritance → genuine IS-A relationship: Dog IS-A Animal, Car IS-A Vehicle, Circle IS-A Shape
Composition → HAS-A relationship: Car HAS-A Engine, Computer HAS-A CPU, House HAS-A Room

Rule of thumb: if you're forcing an IS-A relationship just to reuse some code, it's usually a sign you actually wanted composition.

🎯 Quick Recap

Tool	Solves
`@dataclass`	Repetitive `__init__`/`__repr__` boilerplate for data-holding classes
`abc` / `@abstractmethod`	Forcing child classes to implement required methods
Inheritance	"This is a specialized version of that"
Composition	"This has a piece that does the work"

Week 04 - Task 1.2: dunder/magic methods (init, repr, eq, len, add, etc.)

Deepika Pusala — Tue, 25 Aug 2026 09:11:11 +0000

Python Dunder Methods, Demystified 🪄

__init__, __repr__, __add__... they look scary with all those underscores. But once you get the one idea behind them, they stop being magic and start being obvious.

🔤 What Does "Dunder" Even Mean?

Dunder = Double UNDERscore.

__init__
 ↑     ↑
 double  double
 underscore underscore

So dunder methods are just methods whose names start and end with __. You'll also hear them called magic methods or special methods — all three names mean the same thing.

Examples: __init__, __repr__, __eq__, __len__, __add__

💡 Why Do They Exist?

Python already knows what to do with its built-in types:

print(10 + 20)        # 30
print(len("hello"))   # 5

But now make your own class:

class Money:
    def __init__(self, amount):
        self.amount = amount

m1 = Money(100)
m2 = Money(200)
print(m1 + m2)   # 💥 Error!

Python has no idea what + should mean for two Money objects. Dunder methods are how you teach Python what to do. Define __add__, and suddenly + makes sense for your class too.

The big idea: dunder methods let your custom objects behave like Python's built-in ones.

⚙️ Are They Automatic?

Yes — but you still write them yourself. You just don't call them directly.

You write	Python actually calls
`a + b`	`a.__add__(b)`
`len(a)`	`a.__len__()`
`a == b`	`a.__eq__(b)`
`print(a)`	uses `a.__repr__()`

You define the dunder method once inside your class. From then on, Python quietly routes the normal syntax to it behind the scenes.

🧠 The translation trick: whenever you see a + b, mentally read it as a.__add__(b). Do this for every operator and dunder methods stop feeling magical.

🙋 A Quick Word on `self`

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

s1 = Student("Deepika")

When Python runs s1 = Student("Deepika"), it's really doing s1.__init__("Deepika") internally — and inside that method, self is s1. So self.name = name simply means s1.name = "Deepika".

🧰 The Core Dunder Methods

`init` — set up the object

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

Runs automatically when you create an object, to set its starting values.

⚠️ Common myth: "Every class must have __init__." False — it's optional. class Student: pass is perfectly valid Python.

`repr` — give it a readable identity

Without it:

print(s)
# <__main__.Student object at 0x000001...>

With it:

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

    def __repr__(self):
        return f"Student(name='{self.name}', age={self.age})"

print(s)
# Student(name='Deepika', age=21)

Mostly used for clean debugging/logging output.

`eq` — define what "equal" means

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

    def __eq__(self, other):
        return self.name == other.name

s1 = Student("Deepika")
s2 = Student("Deepika")
print(s1 == s2)   # True

`len` — teach `len()` about your object

class Team:
    def __init__(self, members):
        self.members = members

    def __len__(self):
        return len(self.members)

team = Team(["A", "B", "C"])
print(len(team))   # 3

`add` — define what `+` means

class Money:
    def __init__(self, amount):
        self.amount = amount

    def __add__(self, other):
        return Money(self.amount + other.amount)

m3 = Money(100) + Money(200)
print(m3.amount)   # 300

🧩 Putting It All Together

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

    def __repr__(self):
        return f"Student(name='{self.name}', marks={self.marks})"

    def __eq__(self, other):
        return self.marks == other.marks

    def __len__(self):
        return len(self.marks)

    def __add__(self, other):
        return Student(self.name + " & " + other.name,
                        self.marks + other.marks)

s1 = Student("Deepika", [90, 95])
s2 = Student("Koushik", [85, 92])

print(s1)          # __repr__  → Student(name='Deepika', marks=[90, 95])
print(len(s1))     # __len__   → 2
print(s1 == s2)    # __eq__    → False
s3 = s1 + s2        # __add__

🚨 Don't Confuse `main` with `init`

if __name__ == "__main__":
    print("Program started")

__name__ is a special variable and "__main__" is just a special value it can hold — it's not a dunder method. Easy to mix up because both have double underscores, but they're unrelated concepts.

🏢 Where This Shows Up in Real Code

Scenario	Dunder used	Why
Combining prices in a cart	`__add__`	`product1 + product2` reads naturally
Financial apps (`Money`, `Invoice`)	`__add__`	`total = m1 + m2` instead of manual math
Shopping cart item count	`__len__`	`len(cart)` instead of `len(cart.items)`
Debugging a `User` object	`__repr__`	`print(user)` → `User(id=101, name='Deepika')` instead of a memory address

This isn't just interview trivia — it's how real Python libraries (like datetime, pandas, or pathlib) make objects feel native to the language.

🎯 Cheat-Sheet Answers

Question	Short Answer
What are dunder methods?	Special methods with double-underscore names that define how your objects respond to built-in Python operations
Do we call them directly?	Usually no — normal syntax (`+`, `len()`, `==`) triggers them automatically
Do all classes need `__init__`?	No, it's optional — only needed to initialize attributes
Why called "magic methods"?	Because Python invokes them behind the scenes, without an explicit call

🧠 One Picture to Remember

              YOUR OBJECT
                   │
        "How should I behave?"
       ┌───────────┼────────────┐
       ↓           ↓            ↓
      +            ==          len()
       ↓           ↓            ↓
  __add__       __eq__       __len__

object created  → __init__
object printed  → __repr__

Golden rule: Dunder methods are the mechanism Python uses to let your custom objects participate naturally in its built-in operations.

Week 4, Task - 1.1: Classes, Inheritance & MRO 🐍

Deepika Pusala — Tue, 25 Aug 2026 09:06:49 +0000

Object-Oriented Programming sounds intimidating until you realize it's really just... family trees and blueprints. Let's break down three concepts that trip up almost everyone at first: classes, inheritance, and MRO.

🧱 What Is a Class?

A class is a blueprint. An object is the real thing built from that blueprint.

Think of a company that hires employees. Every employee has a name, age, and salary, and can work(). Instead of writing that logic separately for each person, you define it once:

class Employee:
    def work(self):
        print("Employee is working")

e1 = Employee()
e2 = Employee()

Term	Meaning
Class	The design/template
Object	An actual instance created from that template

Quick answer for interviews: "A class defines the attributes and methods its objects will have. An object is an instance of that class."

🧬 What Is Inheritance?

Inheritance lets a child class reuse the attributes and methods of a parent class — and add its own on top.

class Animal:
    def eat(self):
        print("Animal is eating")

class Dog(Animal):
    def bark(self):
        print("Dog is barking")

Animal
   ↑
   |
  Dog

A Dog object can call both bark() and eat() — the second one comes free, inherited from Animal.

Why bother? Without it, you'd repeat the same eat()/sleep() code in every animal class. Inheritance = write once, reuse everywhere, specialize as needed.

🌳 The 5 Types of Inheritance

Type	Shape	Example
Single	`A → B`	One parent, one child
Multilevel	`A → B → C`	Grandparent → Parent → Child
Hierarchical	`A → B` and `A → C`	One parent, many children
Multiple	`A + B → C`	One child, many parents
Hybrid	Mix of the above	Combines two or more patterns

A quick real-world flavor:

class Animal:
    def eat(self): print("Eating")

class Machine:
    def charge(self): print("Charging")

class Robot(Animal, Machine):   # Multiple inheritance
    pass

Robot can now both eat() and charge() — pulling from two separate parents.

🔄 Overriding vs ➕ Overloading (don't mix these up!)

Concept	Meaning	Works in Python?
Overriding	Child redefines a method that already exists in the parent, giving it new behavior	✅ Yes
Overloading	Same method name, different parameter lists (like Java)	❌ Not directly

Overriding example:

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

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

About overloading: Python doesn't support true overloading — defining add() twice just replaces the first version. Instead, we fake it with default arguments or *args:

class Calculator:
    def add(self, a, b, c=0):
        return a + b + c

🧭 MRO: Method Resolution Order

MRO is just Python's rule for which class to check first when looking for a method — especially useful once multiple parents are involved.

Child
  ↓
Parent
  ↓
Grandparent
  ↓
object

Python always starts the search at the object's own class and works upward. object sits at the very end — it's the ultimate base class every Python class inherits from, even implicitly.

Check it yourself:

print(Dog.mro())
# or
print(Dog.__mro__)

Where it really matters: multiple inheritance

class Bangalore:
    def show(self):
        print("Bangalore")

class Vizag(Bangalore):
    def show(self):
        print("Vizag")

class Hyderabad(Bangalore):
    def show(self):
        print("Hyderabad")

class Chennai(Hyderabad, Vizag):
    pass

city = Chennai()
city.show()
print(Chennai.mro())

Hyderabad
[<class 'Chennai'>, <class 'Hyderabad'>, <class 'Vizag'>, <class 'Bangalore'>, <class 'object'>]

Chennai itself has no show(), so Python walks the MRO left to right: Chennai → Hyderabad → Vizag→ Bangalore → object. It hits Hyderabad first (since it's listed first in class Chennai(Hyderabad, Vizag)) and stops there — that's why the output is "Hyderabad", not "Vzag" or "Bangalore".

🪜 super() — jump to the next class in line

super() tells Python: "go to the next class in the MRO and use its version of this method." If you skip it, the parent's version simply never runs.

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

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

d = Dog()
d.speak()

Dog barks

Because super().speak() is commented out, Animal's speak() never gets called — Python only runs Dog's overridden version. Uncomment that line and you'd get both lines:

Animal speaks
Dog barks

🏢 A Real-World Flavor

User roles in an e-commerce app:

                User
              /      \
        Customer     Seller → Admin

All roles share login()/logout() from User, while adding their own methods (buy_product(), add_product(), etc.).

Payment systems are a classic overriding example:

class Payment:
    def pay(self): print("Processing payment")

class UPIPayment(Payment):
    def pay(self): print("Processing UPI payment")   # overridden

Mixins (common in frameworks) are where MRO quietly does its job:

class LoggingMixin:
    def log(self): print("Logging")

class AuthMixin:
    def authenticate(self): print("Authenticating")

class UserService(LoggingMixin, AuthMixin):
    pass

🎯 Cheat-Sheet Answers

Question	Short Answer
What is inheritance?	A child class reuses a parent's attributes/methods and can add or override behavior
Why use it?	Code reuse + specialization
What is overriding?	Child redefines a parent's method with its own implementation
Does Python support overloading?	No — use default args or `*args` instead
What is MRO?	The order Python searches classes for a method, especially with multiple inheritance
Where does `object` sit in MRO?	Always at the end — it's the base of everything
How to check MRO?	`ClassName.mro()` or `ClassName.__mro__`

💡 The Whole Topic, One Breath

A class is a blueprint that makes objects. A child class can use inheritance to reuse a parent's code — and if it redefines a method, that's overriding. Python skips true overloading in favor of default arguments. When multiple parents are involved, MRO decides the search order, always ending at object. And super() is your shortcut to the next class in that order.

Week-04,Task- 1: OOP & Dunder Methods

Deepika Pusala — Mon, 24 Aug 2026 11:27:37 +0000

🐍 Python OOP — Simple Tutorial for Beginners

We'll cover:

🧱 Classes, Inheritance & MRO
✨ Dunder / Magic Methods
🏷️ @dataclass + Abstract Base Classes (abc)
🧩 Composition vs Inheritance
📋 Dunder Methods Cheat Sheet

1️⃣ Classes, Inheritance & MRO

Let's start from the absolute basics.

🧱 What is a Class?

A class is like a blueprint for creating objects.

Imagine you want to create students.

Every student might have:

name
age
college

Instead of writing separate code for every student, we create a class.

class Student:

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

    def introduce(self):
        print("Hi, I am", self.name)

Now we can create objects:

student1 = Student("Deepika", 21)
student2 = Student("Sneha", 22)

student1.introduce()
student2.introduce()

Output:

Hi, I am Deepika
Hi, I am Sneha

🧠 Think like this:

Class
  ↓
Blueprint

Object
  ↓
Actual thing created from blueprint

Example:

Student class
     ↓
 ┌───────────────┐
 │ Deepika       │ ← object
 │ Sneha         │ ← object
 │ Koushik       │ ← object
 └───────────────┘

2️⃣ 👨‍👩‍👧 What is Inheritance?

Inheritance means:

One class can reuse the properties and methods of another class.

Suppose we have:

class Animal:

    def eat(self):
        print("Animal is eating")

    def sleep(self):
        print("Animal is sleeping")

Now we create:

class Dog(Animal):
    pass

Because Dog inherits from Animal, Dog automatically gets:

eat()
sleep()

So:

dog = Dog()

dog.eat()
dog.sleep()

Output:

Animal is eating
Animal is sleeping

🎉 We didn't write eat() or sleep() inside Dog.

That's inheritance.

🌳 Parent and Child

We usually call:

Animal
   ↓
Parent class / Base class / Superclass

and:

Dog
   ↓
Child class / Derived class / Subclass

So:

class Dog(Animal):

means:

"Dog is a type of Animal."

3️⃣ 🔄 Method Overriding

What if Dog wants its own version of eat()?

Easy!

class Animal:

    def eat(self):
        print("Animal is eating")


class Dog(Animal):

    def eat(self):
        print("Dog is eating")

Now:

dog = Dog()
dog.eat()

Output:

Dog is eating

Python chooses the method from Dog.

This is called method overriding.

4️⃣ 🧭 What is MRO?

Now comes the scary-looking word:

MRO = Method Resolution Order

But don't worry 😭.

It's simply:

The order in which Python searches for a method.

Suppose:

class Animal:

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


class Dog(Animal):
    pass

When we do:

dog = Dog()
dog.speak()

Python asks:

Does Dog have speak()?
        ↓
       NO
        ↓
Does Animal have speak()?
        ↓
       YES
        ↓
Run Animal.speak()

That's basically method resolution.

🔍 How do I see MRO?

Use:

print(Dog.mro())

or:

print(Dog.__mro__)

You'll get something similar to:

[<class 'Dog'>, <class 'Animal'>, <class 'object'>]

Meaning:

Dog
Animal
object

Python searches in that order.

5️⃣ 😵 Multiple Inheritance + MRO

Here's where MRO becomes REALLY important.

class A:

    def show(self):
        print("A")


class B(A):

    def show(self):
        print("B")


class C(A):

    def show(self):
        print("C")


class D(B, C):
    pass

Now:

obj = D()
obj.show()

What happens?

Python needs to decide:

D
↓
B or C?
↓
A?

Python uses MRO to decide the order.

print(D.mro())

Conceptually:

D → B → C → A → object

Therefore:

obj.show()

finds show() in B first.

Output:

⭐ Important: You don't manually decide which parent's method runs. Python follows its MRO rules.

6️⃣ ✨ Dunder / Magic Methods

Now let's enter the fun part.

You've probably seen things like:

__init__
__str__
__repr__
__eq__
__len__
__add__

These are called Dunder methods.

"Dunder" = Double UNDERscore

__method__
↑       ↑
double  double
underscore

They are also called magic methods.

7️⃣ 🤔 Why do we need Dunder Methods?

Let's start with something familiar.

You can do:

a = 10
b = 20

print(a + b)

Output:

But what if we create our own class?

class Number:

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

Then:

a = Number(10)
b = Number(20)

print(a + b)

❌ Python doesn't automatically know how to add two Number objects.

That's where __add__() comes in.

8️⃣ `init()` 🏗️

You've already seen this.

class Student:

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

When you write:

student = Student("Deepika")

Python automatically calls __init__().

Think:

Student("Deepika")
       ↓
__init__("Deepika")
       ↓
self.name = "Deepika"

🧠 Purpose: __init__() is used to initialize an object's data.

9️⃣ `repr()` 🔎

Suppose:

class Student:

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

Then:

student = Student("Deepika", 21)

print(student)

Without defining a representation, Python gives something ugly like:

<__main__.Student object at 0x000001...>

Not very useful 😭.

So:

class Student:

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

    def __repr__(self):
        return f"Student(name='{self.name}', age={self.age})"

Now:

print(student)

can show:

Student(name='Deepika', age=21)

🧠 Purpose: __repr__() gives a useful representation of an object, especially for debugging.

🔟 `eq()` ⚖️

eq means equal.

Normally:

a == b

asks: "Are these two things equal?"

For our own class, we can define what equality means.

class Student:

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

    def __eq__(self, other):
        return self.name == other.name

Now:

s1 = Student("Deepika")
s2 = Student("Deepika")

print(s1 == s2)

Output:

True

Because:

s1.name == s2.name
Deepika == Deepika
True

1️⃣1️⃣ `len()` 📏

Python's len() can work with our class if we define __len__().

Example:

class Team:

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

    def __len__(self):
        return len(self.members)

Now:

team = Team(["Deepika", "Sneha", "Koushik"])

print(len(team))

Output:

Python internally does something conceptually like:

team.__len__()

1️⃣2️⃣ `add()` ➕

This controls the + operator.

class Number:

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

    def __add__(self, other):
        return Number(self.value + other.value)

Now:

a = Number(10)
b = Number(20)

c = a + b

print(c.value)

Output:

Behind the scenes:

a + b

roughly means:

a.__add__(b)

🔥 That's the magic.

1️⃣3️⃣ Other Useful Dunder Methods

There are MANY, but you don't need to memorize all of them.

Here's the important beginner set:

Dunder	Used for
`__init__`	Initialize object
`__repr__`	Developer-friendly representation
`__str__`	User-friendly string
`__eq__`	`==`
`__ne__`	`!=`
`__lt__`	`<`
`__gt__`	`>`
`__le__`	`<=`
`__ge__`	`>=`
`__len__`	`len()`
`__add__`	`+`
`__sub__`	`-`
`__mul__`	`*`
`__truediv__`	`/`
`__getitem__`	`obj[index]`
`__setitem__`	`obj[index] = value`
`__contains__`	`x in obj`
`__iter__`	iteration
`__next__`	next item
`__enter__`	`with` block starts
`__exit__`	`with` block ends

🏷️ 1️⃣4️⃣ What is `@dataclass`?

Now imagine you're writing this:

class Student:

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

And then you also want __repr__ and __eq__.

That's a lot of repetitive code 😭.

Python gives us @dataclass, which can automatically generate common methods for us.

Without `@dataclass`

class Student:

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

    def __repr__(self):
        return f"Student(name='{self.name}', age={self.age})"

    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

That's a lot.

With `@dataclass`

from dataclasses import dataclass

@dataclass
class Student:
    name: str
    age: int

That's it! 😭❤️

Now:

s1 = Student("Deepika", 21)
s2 = Student("Deepika", 21)

print(s1)
print(s1 == s2)

Output:

Student(name='Deepika', age=21)
True

🧠 Simple definition: @dataclass is a decorator that automatically creates common methods for classes that mainly store data.

It can generate things like:

__init__
__repr__
__eq__

and more depending on the options you use.

🚨 When should you use `@dataclass`?

Use it when your class is mainly a data container.

For example:

@dataclass
class Employee:
    name: str
    salary: float
    department: str

Great use case ✅.

But if your class contains complicated business logic and isn't primarily storing data, a normal class may be better.

🧠 1️⃣5️⃣ Abstract Base Classes — `abc`

This sounds terrifying. It's actually pretty simple.

Imagine we say:

Every animal MUST have a sound() method.

We don't want to provide the actual implementation in the parent class. We just want to create a rule.

That's where an abstract class comes in.

Example

from abc import ABC, abstractmethod

class Animal(ABC):

    @abstractmethod
    def sound(self):
        pass

Now:

class Dog(Animal):

    def sound(self):
        print("Woof")

And:

class Cat(Animal):

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

Why is this useful?

We are basically saying:

Animal
  ↓
Every child MUST implement sound()

So:

dog = Dog()
dog.sound()

works.

But:

animal = Animal()

❌ doesn't work because Animal is abstract.

🧠 Think of ABC like a contract

Imagine your manager says:

"Every employee class must have a calculate_salary() method."

You can create:

class Employee(ABC):

    @abstractmethod
    def calculate_salary(self):
        pass

Then:

class Developer(Employee):

    def calculate_salary(self):
        return 50000


class Designer(Employee):

    def calculate_salary(self):
        return 45000

The parent establishes the rule. The child provides the actual implementation.

🧩 1️⃣6️⃣ Composition vs Inheritance

This is SUPER important for interviews.

Let's first understand inheritance.

Inheritance = "IS-A"

Example:

Dog IS-A Animal
Car IS-A Vehicle
Manager IS-A Employee

So:

class Dog(Animal):

makes sense, because:

Dog → Animal
IS-A relationship

🧩 Composition = "HAS-A"

Composition means one object contains/uses another object.

Example:

Car HAS-A Engine
House HAS-A Room
Computer HAS-A CPU

For example:

class Engine:

    def start(self):
        print("Engine started")


class Car:

    def __init__(self):
        self.engine = Engine()

    def start_car(self):
        self.engine.start()
        print("Car started")

Now:

car = Car()
car.start_car()

Output:

Engine started
Car started

Here:

Car
 ↓
HAS-A
 ↓
Engine

That's composition.

⚔️ Composition vs Inheritance

Let's compare.

Inheritance:

class Dog(Animal):
    pass

Means: Dog IS-A Animal

Composition:

class Car:

    def __init__(self):
        self.engine = Engine()

Means: Car HAS-A Engine

🧠 When should I use which?

A simple rule:

Use inheritance when the relationship genuinely is IS-A:

Dog → Animal
Cat → Animal
Manager → Employee

Use composition when the relationship is HAS-A:

Car → Engine
Computer → CPU
House → Room

💡 Why is composition often preferred?

Suppose:

class Car(Engine):

This says: "Car IS-A Engine."

🤨 That doesn't make sense. A car isn't an engine. A car has an engine.

So:

class Car:

    def __init__(self):
        self.engine = Engine()

is much more logical.

🧠 The Entire Topic in One Picture

                    PYTHON OOP
                        │
        ┌───────────────┼────────────────┐
        │               │                │
     Classes       Inheritance       Composition
        │               │                │
    Blueprint         IS-A             HAS-A
        │               │                │
     Objects        Dog-Animal       Car-Engine
                        │
                       MRO
                        │
              Search order for methods


                    DUNDER METHODS
                          │
          ┌───────────────┼───────────────┐
          │               │               │
       __init__        __repr__         __eq__
          │               │               │
     initialize       representation    equality
          │
          ├── __len__ → len()
          ├── __add__ → +
          ├── __str__ → str()
          ├── __getitem__ → []
          └── __iter__ → iteration


                    SPECIAL TOOLS
                          │
              ┌───────────┴───────────┐
              │                       │
          @dataclass                 abc
              │                       │
       Data-focused class        Rules/contracts
       auto-generated methods    abstract methods

📋 Dunder Cheat Sheet — SAVE THIS! ⭐

Method	What it controls	Easy meaning
`__init__`	Object creation	Set up object
`__str__`	`str(obj)` / `print(obj)`	User-friendly text
`__repr__`	`repr(obj)`	Developer representation
`__eq__`	`obj1 == obj2`	Are they equal?
`__ne__`	`obj1 != obj2`	Are they different?
`__lt__`	`obj1 < obj2`	Less than
`__gt__`	`obj1 > obj2`	Greater than
`__le__`	`obj1 <= obj2`	Less/equal
`__ge__`	`obj1 >= obj2`	Greater/equal
`__len__`	`len(obj)`	Object length
`__add__`	`obj1 + obj2`	Addition
`__sub__`	`obj1 - obj2`	Subtraction
`__mul__`	`obj1 * obj2`	Multiplication
`__truediv__`	`obj1 / obj2`	Division
`__getitem__`	`obj[key]`	Get item
`__setitem__`	`obj[key] = value`	Set item
`__contains__`	`x in obj`	Membership
`__iter__`	`for x in obj`	Make iterable
`__next__`	`next(obj)`	Get next item
`__enter__`	Enter `with`	Start context manager
`__exit__`	Exit `with`	Finish context manager
`__call__`	`obj()`	Make object callable

🎯 The 10 Things I Want You to Remember

If you're preparing for your internship/interview, don't try to memorize everything at once.

Remember these:

Class — Blueprint for creating objects.
Object — Actual instance created from a class.
Inheritance — Child class gets/reuses functionality from parent. class Dog(Animal):
Method overriding — Child provides its own version of parent's method.
MRO — Order Python follows when searching for a method. Dog.mro()
Dunder methods — Special methods that let our objects work naturally with Python operations. __init__, __repr__, __eq__, __len__, __add__
@dataclass — Makes data-focused classes much shorter by automatically generating common methods.
Abstract Base Class — Defines rules that child classes must follow. @abstractmethod
Inheritance = IS-A — Dog IS-A Animal
Composition = HAS-A — Car HAS-A Engine

🐍 Python Context Managers: The Easy Guide (with, enter/exit, @contextmanager, contextlib)

Deepika Pusala — Thu, 20 Aug 2026 09:55:29 +0000

🐍 Python Context Managers: The Easy Guide (`with`, `enter`/`exit`, `@contextmanager`, `contextlib`)

If you've ever written this:

with open("file.txt") as f:
    data = f.read()

...you've already used a context manager! 🎉 But have you ever wondered what's happening behind the curtain? Let's demystify it — no jargon, just simple examples. 🚀

🤔 What Even Is a Context Manager?

A context manager is just an object that knows how to:

🟢 Set something up when you enter a with block
🔴 Clean something up when you leave the block — even if an error happens!

Think of it like a polite guest 🧑‍🍳: they walk into your kitchen (setup), cook a meal, and always clean the dishes before leaving — whether dinner went perfectly or they set off the smoke alarm. 🔥

The classic use case? Resource management:

📂 Opening/closing files
🔒 Acquiring/releasing locks
🗄️ Opening/closing database connections
⏱️ Timing code blocks

🏗️ Method 1: The `enter` / `exit` Protocol

This is the "manual," object-oriented way to build a context manager. You create a class with two special methods.

📜 The Syntax

class MyContextManager:
    def __enter__(self):
        # 🟢 setup code goes here
        print("Entering the context!")
        return self  # this becomes the 'as X' value

    def __exit__(self, exc_type, exc_value, traceback):
        # 🔴 cleanup code goes here
        print("Exiting the context!")
        return False  # False = don't suppress exceptions

🔍 Breaking Down `exit`'s Weird Parameters

__exit__ always receives 3 arguments about any exception that happened inside the with block:

Parameter	Meaning
`exc_type`	The exception class (e.g. `ValueError`) — or `None` if no error 😌
`exc_value`	The actual exception instance — or `None`
`traceback`	The traceback object — or `None`

💡 Key trick: If __exit__ returns True, it swallows the exception (pretends nothing happened). If it returns False (or None), the exception keeps bubbling up normally. Most of the time, you want False!

✅ Full Working Example

class OpenFile:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        print(f"📂 Opening {self.filename}")
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        print(f"🔒 Closing {self.filename}")
        self.file.close()
        return False

with OpenFile("greeting.txt", "w") as f:
    f.write("Hello, world! 👋")

# Output:
# 📂 Opening greeting.txt
# 🔒 Closing greeting.txt

Notice: even if f.write() throws an error, __exit__ still runs and closes the file. That's the whole point! 🛡️

✨ Method 2: The `@contextmanager` Decorator (The Easy Way)

Writing a whole class for simple setup/teardown feels like overkill, right? Enter contextlib.contextmanager — it lets you write a context manager as a single generator function. 🎩

📜 The Syntax

from contextlib import contextmanager

@contextmanager
def my_context():
    # 🟢 setup code
    print("Entering!")

    yield "some value"  # ⬅️ this is the 'as X' value

    # 🔴 cleanup code (runs after the 'with' block ends)
    print("Exiting!")

The magic ingredient is yield:

Everything before yield = your __enter__ logic
The yielded value = what you get after as
Everything after yield = your __exit__ logic

✅ Full Working Example

from contextlib import contextmanager
import time

@contextmanager
def timer(label):
    start = time.time()
    print(f"⏱️ Starting '{label}'...")
    yield
    end = time.time()
    print(f"✅ '{label}' took {end - start:.4f} seconds")

with timer("crunching numbers"):
    total = sum(i * i for i in range(1_000_000))

# Output:
# ⏱️ Starting 'crunching numbers'...
# ✅ 'crunching numbers' took 0.0821 seconds

So clean! No class, no self, just a function. 😍

⚠️ Handling Errors in `@contextmanager`

Wrap the yield in try/finally to guarantee cleanup even on errors:

@contextmanager
def safe_resource():
    print("🟢 Acquiring resource")
    try:
        yield "resource"
    finally:
        print("🔴 Releasing resource (always happens!)")

with safe_resource() as r:
    raise ValueError("Oops! 💥")

# Output:
# 🟢 Acquiring resource
# 🔴 Releasing resource (always happens!)
# (then the ValueError is re-raised)

🧰 Bonus: Handy `contextlib` Utilities

The contextlib module has more goodies beyond @contextmanager. Here are the most useful ones:

1️⃣ `contextlib.suppress()` — Ignore Specific Exceptions

Instead of writing a clunky try/except/pass:

# 😩 The old way
try:
    import missing_module
except ImportError:
    pass

# 😎 The contextlib way
from contextlib import suppress

with suppress(ImportError):
    import missing_module

2️⃣ `contextlib.closing()` — Auto-Close Objects That Have `.close()`

Useful for objects that support .close() but aren't natively context managers:

from contextlib import closing
from urllib.request import urlopen

with closing(urlopen("https://example.com")) as page:
    html = page.read()
# automatically calls page.close() when done ✅

3️⃣ `contextlib.ExitStack()` — Manage a Dynamic Number of Contexts

Great when you don't know how many resources you need ahead of time:

from contextlib import ExitStack

filenames = ["a.txt", "b.txt", "c.txt"]

with ExitStack() as stack:
    files = [stack.enter_context(open(fname)) for fname in filenames]
    # all files are open here 📚
    # ExitStack closes ALL of them automatically when the block ends 🔒

4️⃣ `contextlib.redirect_stdout()` — Capture `print()` Output

import io
from contextlib import redirect_stdout

buffer = io.StringIO()
with redirect_stdout(buffer):
    print("This goes into the buffer, not the console!")

print(buffer.getvalue())  # "This goes into the buffer, not the console!\n"

🥊 `enter`/`exit` vs `@contextmanager`: Which Should I Use?

	Class-based (`__enter__`/`__exit__`)	`@contextmanager` decorator
🧠 Learning curve	Steeper	Gentler
📏 Best for	Complex, stateful, reusable objects	Quick, simple, one-off logic
🔁 Reusability	Great — can hold lots of internal state	Good, but state is limited to local variables
✍️ Code length	More boilerplate	Shorter & cleaner

👉 Rule of thumb: Start with @contextmanager for simple cases. Reach for a full class when your context manager needs to track a lot of internal state or offer multiple methods.

🎯 Real-World Use Cases

🗃️ Database connections — auto-close connections/cursors, even on query errors
🔐 Thread locks — auto-release a threading.Lock() so you never deadlock
🧪 Testing — temporarily patch environment variables or mock objects, then restore them
📁 Temp files/directories — auto-delete temp files when you're done (tempfile uses this!)
🌐 Network connections — auto-close sockets or HTTP sessions
⏳ Timing & profiling — measure how long a code block takes (like our timer example above!)

🏁 Quick Recap

🟢 A context manager = something that runs setup code, then guarantees cleanup code runs
🏗️ Build one with a class using __enter__ (setup) and __exit__ (cleanup)
✨ Or build one fast with @contextmanager + a generator function + yield
🧰 contextlib gives you free tools: suppress(), closing(), ExitStack(), redirect_stdout(), and more
🛡️ The real superpower: cleanup always happens, even when exceptions blow up your code

Week-03 Task-2: Iterators, Generators & Context Managers

Deepika Pusala — Wed, 19 Aug 2026 09:47:07 +0000

1. Iterator Protocol (`iter()` / `next()`)

What is an Iterator?

An iterator is an object that gives us values one at a time.

Example:

numbers = [10, 20, 30]

it = iter(numbers)

print(next(it))
print(next(it))
print(next(it))

Output:

10
20
30

If we call next() again:

print(next(it))

Python raises:

StopIteration

because there are no more values.

Important Functions

iter() → gets an iterator.

it = iter(numbers)

next() → gets the next value.

next(it)

Iterator Protocol

A custom iterator follows two special methods:

__iter__()
__next__()

__iter__() → returns the iterator.
__next__() → returns the next value.
When there are no more values, __next__() raises StopIteration.

Simple Custom Iterator

class MyNumbers:

    def __init__(self):
        self.number = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.number <= 3:
            value = self.number
            self.number += 1
            return value
        else:
            raise StopIteration


numbers = MyNumbers()

print(next(numbers))
print(next(numbers))
print(next(numbers))

Output:

1
2
3

Iterable vs Iterator

Iterable: Something that can be looped over.

Examples:

list
tuple
string
dictionary
set

Iterator: The object that actually gives the values one by one using next().

Simple flow:

Iterable
   ↓
iter()
   ↓
Iterator
   ↓
next()
   ↓
Value

How does a `for` loop work?

When we write:

for number in [10, 20, 30]:
    print(number)

Python internally uses the iterator protocol.

Conceptually:

iterator = iter([10, 20, 30])

while True:
    try:
        number = next(iterator)
        print(number)
    except StopIteration:
        break

So a for loop automatically calls iter() and next() for us.

Real-world use cases

Iterators are useful when working with:

Large datasets
Files
Database results
API results
Data pipelines
Streaming data

They allow us to process data one item at a time instead of handling everything at once.

2. Generator Functions & `yield`

What is a Generator?

A generator is an easy way to create an iterator.

Generators produce values one at a time instead of creating all the values at once.

They are created using the yield keyword.

Simple Generator

def numbers():
    yield 1
    yield 2
    yield 3

Create a generator:

gen = numbers()

Get values one at a time:

print(next(gen))
print(next(gen))
print(next(gen))

Output:

1
2
3

Another next() gives:

StopIteration

because the generator is finished.

`yield` vs `return`

`return`

return gives a value and ends the function.

def test():
    return 10

After return, the function is finished.

`yield`

yield gives a value and pauses the function.

The function remembers where it stopped and continues from there when next() is called again.

def numbers():
    yield 10
    yield 20
    yield 30

The flow is:

yield 10
   ↓
pause
   ↓
yield 20
   ↓
pause
   ↓
yield 30
   ↓
pause
   ↓
finished

So remember:

return → give value and finish

yield → give value and pause

Generators are Lazy

Generators use lazy evaluation.

This means values are produced only when they are needed.

Example:

def numbers():
    print("Generating 1")
    yield 1

    print("Generating 2")
    yield 2

When we write:

gen = numbers()

the function does not immediately run.

When we write:

print(next(gen))

it starts running and produces:

Generating 1
1

This makes generators useful for large amounts of data because we don't need to store everything in memory at once.

Generator with a Loop

def numbers():
    for i in range(1, 6):
        yield i


for number in numbers():
    print(number)

Output:

Real-world Generator Use Case

Suppose a file has millions of lines.

Instead of loading everything into memory, we can process one line at a time:

def read_lines(file):
    for line in file:
        yield line

Then:

for line in read_lines(file):
    process(line)

This is useful for:

Large files
Large datasets
Logs
Database records
API data
Data processing pipelines

3. Generator Expressions

A generator expression is a short way to create a generator.

It looks similar to list comprehension.

List Comprehension

numbers = [x * 2 for x in range(5)]

This creates a list immediately:

[0, 2, 4, 6, 8]

Generator Expression

numbers = (x * 2 for x in range(5))

This creates a generator.

Values are produced when needed.

print(next(numbers))
print(next(numbers))

Output:

0
2

Easy Difference

[x * 2 for x in range(5)]

→ List → values are created immediately.

(x * 2 for x in range(5))

→ Generator → values are produced one at a time.

Simple memory trick:

[ ] → List

( ) → Generator expression

4. `itertools` Basics

itertools is a Python standard library module that provides useful tools for working with iterators.

Import it using:

import itertools

Some important functions are:

`itertools.count()`

Produces numbers continuously.

import itertools

numbers = itertools.count(1)

print(next(numbers))
print(next(numbers))
print(next(numbers))

Output:

1
2
3

It keeps going:

4
5
6
7
...

`itertools.cycle()`

Repeats a sequence continuously.

import itertools

colors = itertools.cycle(["red", "blue", "green"])

print(next(colors))
print(next(colors))
print(next(colors))
print(next(colors))
print(next(colors))

Output:

red
blue
green
red
blue

`itertools.repeat()`

Repeats the same value.

import itertools

values = itertools.repeat("Hello", 3)

for value in values:
    print(value)

Output:

Hello
Hello
Hello

`itertools.chain()`

Combines multiple iterables into one sequence.

import itertools

list1 = [1, 2, 3]
list2 = [4, 5, 6]

result = itertools.chain(list1, list2)

for number in result:
    print(number)

Output:

`itertools.islice()`

Takes a limited portion from an iterator.

import itertools

numbers = itertools.count(1)

result = itertools.islice(numbers, 5)

for number in result:
    print(number)

Output:

Important `itertools` functions to remember

Function	Meaning
`count()`	Keep counting
`cycle()`	Repeat a sequence
`repeat()`	Repeat one value
`chain()`	Join iterables
`islice()`	Take a portion of an iterator

5. Context Manager Protocol (`enter()` / `exit()`)

What is a Context Manager?

A context manager manages setup and cleanup around a block of code.

The easiest way to understand it is:

Setup
  ↓
Do the work
  ↓
Cleanup

A common example is working with files.

Without a context manager:

file = open("data.txt", "r")

content = file.read()

file.close()

We have to manually close the file.

With a context manager:

with open("data.txt", "r") as file:
    content = file.read()

Python automatically handles the cleanup.

The `with` Statement

The basic syntax is:

with something:
    # code

For example:

with open("data.txt") as file:
    print(file.read())

The basic flow is:

Open / Setup
     ↓
__enter__()
     ↓
Use the resource
     ↓
__exit__()
     ↓
Cleanup

Context Manager Protocol

A context manager uses two special methods:

__enter__()
__exit__()

`enter()`

Runs when we enter the with block.

Usually handles setup.

Examples:

Open a resource
Create a connection
Acquire a lock

`exit()`

Runs when we leave the with block.

Usually handles cleanup.

Examples:

Close a file
Close a database connection
Release a lock
Clean up resources

Simple Custom Context Manager

class MyContext:

    def __enter__(self):
        print("Entering")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting")


with MyContext():
    print("Inside")

Output:

Entering
Inside
Exiting

The order is:

__enter__()
    ↓
Code inside with
    ↓
__exit__()

Using `as`

__enter__() can return a value.

Example:

class MyContext:

    def __enter__(self):
        print("Entering")
        return "Hello"

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting")


with MyContext() as value:
    print(value)

Output:

Entering
Hello
Exiting

Whatever __enter__() returns is stored in the variable after as.

So:

with MyContext() as value:

means:

__enter__()
    ↓
returned value
    ↓
value

What are `exc_type`, `exc_value`, and `traceback`?

A normal __exit__() looks like:

def __exit__(self, exc_type, exc_value, traceback):
    ...

These parameters provide information about an exception if one occurs.

exc_type → type of the exception
exc_value → exception details/message
traceback → information about where the exception occurred

If there is no exception, they are generally:

None
None
None

Context Managers and Errors

One important feature is that __exit__() gets called even if an exception occurs inside the with block.

Example:

class MyContext:

    def __enter__(self):
        print("Entering")

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting")


with MyContext():
    print("Inside")
    x = 10 / 0

The __exit__() method still gets a chance to run.

This makes context managers useful for cleanup even when something goes wrong.

Real-world Uses of Context Managers

Context managers are commonly used for:

Files
Database connections
Locks
Network resources
Temporary resources
Transactions

The common pattern is:

Setup
  ↓
Use
  ↓
Cleanup

6. Iterator vs Generator vs Context Manager

Concept	Main Purpose	Important Methods/Keyword
Iterator	Give values one at a time	`__iter__()`, `__next__()`
Generator	Easily create an iterator	`yield`
Generator Expression	Short way to create a generator	`( )`
`itertools`	Ready-made iterator tools	`count()`, `cycle()`, `chain()` etc.
Context Manager	Manage setup and cleanup	`__enter__()`, `__exit__()`

7. Easy Interview Explanations

What is an Iterator?

"An iterator is an object that gives values one at a time. It follows the iterator protocol using __iter__() and __next__(). __next__() returns the next value and raises StopIteration when there are no more values."

What is a Generator?

"A generator is an easy way to create an iterator. It uses the yield keyword to produce values one at a time. yield pauses the function and remembers its state so it can continue later."

What is a Generator Expression?

"A generator expression is a compact way to create a generator using parentheses. It produces values lazily instead of creating the entire collection immediately."

Example:

(x * 2 for x in range(5))

What is `itertools`?

"itertools is a Python standard library module that provides ready-made tools for working with iterators efficiently."

What is a Context Manager?

"A context manager manages setup and cleanup around a block of code. It uses the context manager protocol with __enter__() and __exit__(), usually through the with statement."

8. Final Quick Revision

Iterator

Gives values one by one
        ↓
__iter__()
__next__()
        ↓
StopIteration when finished

Generator

Easy way to create an iterator
        ↓
yield
        ↓
Produces values one at a time
        ↓
Lazy / memory efficient

Generator Expression

(x for x in range(5))

Short way to create a generator.

itertools

Ready-made iterator tools
        ↓
count()
cycle()
repeat()
chain()
islice()

Context Manager

Setup
  ↓
__enter__()
  ↓
Work
  ↓
__exit__()
  ↓
Cleanup

Usually used with:

with:

⭐ The 3 Most Important Lines to Remember

ITERATOR  → __iter__() + __next__()
GENERATOR → yield
CONTEXT MANAGER → with + __enter__() + __exit__()

Super-simple explanation:

Iterator: "Give me the next value."

Generator: "I'll give you values one at a time using yield."

Context Manager: "I'll set things up, let you do your work, and clean things up when you're done."

Python Scope, First-Class Functions, *args,**kwargs & Mutable Default Arguments

Deepika Pusala — Mon, 17 Aug 2026 10:15:22 +0000

Python has several concepts that look difficult at first, but they become simple once we understand what Python is actually doing.

This guide covers:

LEGB Scoping Rule
Local, Enclosing, Global and Built-in scopes
nonlocal
First-Class Functions
*args
**kwargs
Packing and Unpacking
Mutable Default Argument Pitfall
Safe ways to use default arguments

1. LEGB Scoping Rule

What is Scope?

Scope means the area of a program where a variable can be accessed.

For example:

def greet():
    name = "Deepika"
    print(name)

greet()

Here, name is created inside greet(), so it belongs to the local scope of that function.

Python follows a specific rule to find variables. This rule is called the LEGB rule.

L → Local
E → Enclosing
G → Global
B → Built-in

Python searches for a variable in this order:

Local
   ↓
Enclosing
   ↓
Global
   ↓
Built-in

Python stops searching as soon as it finds the variable.

2. L → Local Scope

A variable created inside a function is usually a local variable.

Example

def greet():
    name = "Deepika"
    print(name)

greet()

Here, name = "Deepika" is local to greet().

It cannot normally be accessed outside the function:

def greet():
    name = "Deepika"

print(name)

This gives a NameError because name only exists inside greet().

Simple Definition: Local scope is the scope inside the current function.

3. E → Enclosing Scope

The enclosing scope appears when one function is defined inside another function.

Example

def outer():
    name = "Deepika"

    def inner():
        print(name)

    inner()

outer()

Here, name is not inside inner(). It is inside outer().

Therefore, from the point of view of inner(), name is in the enclosing scope.

outer()
│
├── name = "Deepika"
│
└── inner()
       │
       └── print(name)

Simple Definition: Enclosing scope is the scope of an outer function surrounding the current inner function.

This concept is especially important when learning closures.

4. G → Global Scope

A variable created outside all functions is generally in the global scope.

Example

name = "Deepika"

def greet():
    print(name)

greet()

Python cannot find name inside greet(), so it looks in the global scope and finds it.

Local      → Not found
Enclosing  → Not found
Global     → Found!

Output:

Deepika

Simple Definition: Global scope is the scope outside functions and classes at the module level.

5. B → Built-in Scope

Python already provides many names that we can use directly.

Examples: print(), len(), sum(), max(), min(), type()

These names belong to Python's built-in scope.

Example

numbers = [10, 20, 30]

print(len(numbers))

For len, Python searches:

Local      → Not found
Enclosing  → Not found
Global     → Not found
Built-in   → Found!

Output:

Simple Definition: Built-in scope contains names that are provided by Python itself.

6. Complete LEGB Example

x = "Global"

def outer():
    x = "Enclosing"

    def inner():
        x = "Local"
        print(x)

    inner()

outer()

Output:

Local

Why? Because Python searches Local first and finds it there. It stops immediately and does not continue searching the enclosing, global, or built-in scopes.

7. Another LEGB Example

x = "Global"

def outer():
    x = "Enclosing"

    def inner():
        print(x)

    inner()

outer()

Output:

Enclosing

Why? Python searches:

Local      → Not found
Enclosing  → Found!

So it uses "Enclosing".

8. `nonlocal`

nonlocal is used when an inner function wants to modify a variable belonging to an enclosing function.

Example

def outer():
    count = 0

    def inner():
        nonlocal count
        count += 1

    inner()
    print(count)

outer()

Output:

Here, nonlocal count tells Python: "count belongs to the enclosing function. I want to modify that variable."

Simple Definition: nonlocal tells Python to use a variable from the enclosing function's scope instead of creating a new local variable.

When is nonlocal useful? It is commonly used with:

Nested functions
Closures
Functions that need to remember and update state

9. First-Class Functions

One of the most important things about Python is:

Functions are objects too.

Because functions are objects, they can be treated like other values. A function can be:

Assigned to a variable
Passed as an argument
Returned from another function
Stored in a list
Stored in a dictionary
Used later

This is called first-class functions.

10. Assigning a Function to a Variable

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

x = greet

x()

Output:

Hello!

Here, x = greet means x now refers to the greet function.

Important Difference

greet means: the function itself.
greet() means: call or execute the function.

So x = greet stores the function, but x = greet() calls the function immediately and stores its return value.

11. Passing a Function as an Argument

Because functions are first-class objects, we can pass a function to another function.

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

def execute(function):
    function()

execute(greet)

Output:

Hello!

Here, execute(greet) passes the greet function to execute(). Inside execute(), function() calls the function.

The flow is:

greet
  ↓
passed to execute()
  ↓
stored in parameter "function"
  ↓
function()
  ↓
Hello!

12. Returning a Function

A function can also return another function.

def outer():
    def inner():
        print("Hello!")

    return inner

x = outer()

x()

Output:

Hello!

Here, x = outer() stores the returned inner function in x. Then x() calls inner().

This idea is very important for understanding closures and decorators.

13. When Are First-Class Functions Useful?

First-class functions are useful when we want to:

Pass behavior to another function
Create callbacks
Build decorators
Create closures
Choose a function dynamically
Store multiple functions
Execute functions later

Simple Idea

Normally, we pass data:

process(10)

But because functions are objects, we can also pass behavior:

process(greet)

14. `*args`

Sometimes we don't know how many positional arguments a function will receive.

def add(a, b):
    return a + b

This function expects two arguments: add(10, 20). But this will cause an error:

add(10, 20, 30, 40)

If we want the function to accept any number of positional arguments, we can use *args.

Syntax

def function_name(*args):
    ...

Example

def show(*args):
    print(args)

show(10, 20, 30)

Output:

(10, 20, 30)

The arguments are collected into a tuple:

args = (10, 20, 30)

15. Example Using `*args`

def add(*args):
    total = 0

    for number in args:
        total += number

    return total

print(add(10, 20))
print(add(10, 20, 30))
print(add(10, 20, 30, 40))

Output:

30
60
100

Simple Definition: *args allows a function to accept any number of positional arguments and collects them into a tuple.

16. Is `args` a Special Keyword?

No. The * is what matters. The name can technically be anything:

def show(*numbers):
    print(numbers)

But Python programmers normally use *args because it is the standard convention.

17. `**kwargs`

Now let's talk about keyword arguments.

def student(name, age):
    print(name)
    print(age)

We can call this function using keyword arguments:

student(name="Deepika", age=21)

But what if we don't know how many keyword arguments will be provided? We can use **kwargs.

Syntax

def function_name(**kwargs):
    ...

Example

def student(**kwargs):
    print(kwargs)

student(name="Deepika", age=21, city="Bangalore")

Output:

{'name': 'Deepika', 'age': 21, 'city': 'Bangalore'}

The keyword arguments are collected into a dictionary:

kwargs = {
    "name": "Deepika",
    "age": 21,
    "city": "Bangalore"
}

18. Simple Definition of `**kwargs`

**kwargs allows a function to accept any number of keyword arguments and collects them into a dictionary.

19. `*args` vs `**kwargs`

Feature	`*args`	`**kwargs`
Accepts	Positional arguments	Keyword arguments
Stores data as	Tuple	Dictionary
Example	`10, 20, 30`	`name="Deepika"`
Symbol	`*`	`**`

The easiest way to remember:

*args → Positional arguments → Tuple
**kwargs → Keyword arguments → Dictionary

20. Using `*args` and `**kwargs` Together

We can use both in the same function.

def demo(*args, **kwargs):
    print(args)
    print(kwargs)

demo(
    10,
    20,
    30,
    name="Deepika",
    age=21
)

Output:

(10, 20, 30)
{'name': 'Deepika', 'age': 21}

Python separates them: 10, 20, 30 → *args → Tuple, and name="Deepika", age=21 → **kwargs → Dictionary.

21. Packing and Unpacking

The * and ** symbols can also be used for unpacking. There are two different ideas: Packing and Unpacking.

22. Packing

When defining a function:

def demo(*args):
    print(args)

*args collects multiple positional arguments into one tuple. This is called packing.

demo(10, 20, 30)

becomes conceptually:

args = (10, 20, 30)

23. Unpacking with `*`

Suppose we have a list:

numbers = [10, 20, 30]

def add(a, b, c):
    return a + b + c

We can do:

print(add(*numbers))

This is equivalent to:

print(add(10, 20, 30))

The * takes the elements from the list and passes them as separate positional arguments. This is called unpacking.

24. Dictionary Unpacking with `**`

Suppose we have:

student = {
    "name": "Deepika",
    "age": 21
}

def show(name, age):
    print(name)
    print(age)

We can do:

show(**student)

This is equivalent to:

show(name="Deepika", age=21)

The ** unpacks the dictionary into keyword arguments.

25. Packing vs Unpacking

PACKING
↓
Many values → One variable

Example: def show(*args):

UNPACKING
↓
One collection → Many arguments

Example: show(*numbers)

For dictionaries:

**kwargs packs keyword arguments into a dictionary.
function(**data) unpacks a dictionary into keyword arguments.

26. Mutable Default Argument Pitfall

Now let's look at one of Python's famous pitfalls.

A default argument is a value given to a parameter when the caller doesn't provide one.

def greet(name="Deepika"):
    print("Hello", name)

greet()

Output:

Hello Deepika

Here, name="Deepika" is the default value.

27. What Is a Mutable Object?

A mutable object is an object whose contents can be changed. Common mutable types include list, dict, set.

numbers = []

numbers.append(10)

print(numbers)

Output:

[10]

The list was modified.

28. The Mutable Default Argument Problem

Consider this function:

def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item("Apple"))
print(add_item("Banana"))
print(add_item("Mango"))

Output:

['Apple']
['Apple', 'Banana']
['Apple', 'Banana', 'Mango']

This may be surprising. We might expect:

['Apple']
['Banana']
['Mango']

But that's not what happens.

29. Why Does This Happen?

The important rule is:

Python creates default argument objects when the function is defined, not every time the function is called.

So def add_item(item, items=[]): creates one default list.

Function
   |
   └── Default list
          |
          ├── First call → ['Apple']
          |
          ├── Second call → ['Apple', 'Banana']
          |
          └── Third call → ['Apple', 'Banana', 'Mango']

The same list is being reused. Because lists are mutable, changes made to that list remain there.

30. Why Is It Called a "Mutable Default Argument Pitfall"?

Mutable — the object can be changed. [] is a mutable list.
Default Argument — this is the default parameter: items=[]
Pitfall — the same mutable object can be reused across function calls.

Simple Definition: The mutable default argument pitfall occurs when a mutable object such as a list, dictionary, or set is used as a default parameter and modified, causing its changes to persist between function calls.

31. The Wrong Way

Avoid this when you want a fresh list for every function call:

def add_item(item, items=[]):
    items.append(item)
    return items

32. The Safe Way: Use `None`

Instead, use:

def add_item(item, items=None):
    if items is None:
        items = []

    items.append(item)
    return items

print(add_item("Apple"))
print(add_item("Banana"))
print(add_item("Mango"))

Output:

['Apple']
['Banana']
['Mango']

Perfect!

33. Why Does `None` Fix the Problem?

We use items=None as a signal meaning: "The caller did not provide a list."

Then if items is None: items = [] creates a new list when needed.

So instead of:

Call 1 ─┐
Call 2 ─┼──→ SAME LIST
Call 3 ─┘

we get:

Call 1 → NEW LIST
Call 2 → NEW LIST
Call 3 → NEW LIST

34. Mutable Default Dictionaries

The same problem can happen with dictionaries.

Avoid:

def add_user(name, users={}):
    users[name] = "active"
    return users

Prefer:

def add_user(name, users=None):
    if users is None:
        users = {}

    users[name] = "active"
    return users

35. Mutable Default Sets

The same idea applies to sets.

Avoid:

def add_number(number, numbers=set()):
    numbers.add(number)
    return numbers

Prefer:

def add_number(number, numbers=None):
    if numbers is None:
        numbers = set()

    numbers.add(number)
    return numbers

36. Are All Default Arguments Dangerous?

No. The problem specifically concerns mutable objects that are modified.

Common immutable types include: int, float, str, tuple, bool, None.

def counter(count=0):
    count += 1
    return count

print(counter())
print(counter())
print(counter())

Output:

1
1
1

This is fine because integers are immutable.

37. The Safe Pattern to Remember

Whenever you want a fresh mutable object for every function call, use None.

List

def function(data=None):
    if data is None:
        data = []

Dictionary

def function(data=None):
    if data is None:
        data = {}

Set

def function(data=None):
    if data is None:
        data = set()

This pattern is extremely common in real Python code.

38. Quick Revision

LEGB

L → Local
E → Enclosing
G → Global
B → Built-in

LEGB is Python's rule for searching for a variable name.

nonlocal

nonlocal variable

nonlocal tells an inner function to use and modify a variable from its enclosing function.

First-Class Functions

Functions are objects in Python, so they can be assigned to variables, passed as arguments, returned from functions, and stored in collections.

def greet():
    print("Hello")

x = greet
x()

*args

def function(*args):

*args accepts any number of positional arguments and stores them in a tuple.

def show(*args):
    print(args)

show(10, 20, 30)

Output: (10, 20, 30)

`kwargs`**

def function(**kwargs):

**kwargs accepts any number of keyword arguments and stores them in a dictionary.

def show(**kwargs):
    print(kwargs)

show(name="Deepika", age=21)

Output: {'name': 'Deepika', 'age': 21}

Mutable Default Argument

Avoid:

def function(items=[]):

Prefer:

def function(items=None):
    if items is None:
        items = []

A mutable default argument can cause changes to persist between function calls because the default object is created when the function is defined and can be reused.

39. Final Cheat Sheet

LEGB

L → Local
E → Enclosing
G → Global
B → Built-in

Python searches in this order.

First-Class Functions

Functions are objects.

They can be:
• Assigned to variables
• Passed as arguments
• Returned from functions
• Stored in collections

*args

Many positional arguments
        ↓
      Tuple

`kwargs`**

Many keyword arguments
        ↓
    Dictionary

Mutable Default Argument

Avoid:
def func(items=[]):

Prefer:
def func(items=None):
    if items is None:
        items = []

One-Minute Memory

LEGB → Where does Python search for a variable?
Local → Enclosing → Global → Built-in

First-Class Function → Function can be treated like an object.

*args → Many positional arguments → Tuple

**kwargs → Many keyword arguments → Dictionary

*list → Unpack list/sequence → Positional arguments

**dictionary → Unpack dictionary → Keyword arguments

Mutable Default → Avoid [] / {} / set() as defaults → Use None → Create a fresh object inside the function

These concepts are important foundations for understanding closures, decorators, callbacks, scope, function arguments, and advanced Python programming.

The LEGB scoping rule, first-class functions, *args,**kwargs(key-word args),mutable-default-argument pitfall

Deepika Pusala — Mon, 17 Aug 2026 09:54:19 +0000

Python Functions, Scope, "args", "*kwargs" & Common Pitfalls

Python has a few concepts that look complicated at first, but become very easy once we understand what Python is actually doing.

This guide covers:

LEGB Scoping Rule
Local, Enclosing, Global and Built-in scopes
"nonlocal"
First-Class Functions
"*args"
"**kwargs"
Packing and Unpacking
Mutable Default Argument Pitfall
Safe ways to use default arguments

LEGB Scoping Rule

What is Scope?

Scope means the area of a program where a variable can be accessed.

For example:

def greet():
name = "Deepika"
print(name)

greet()

Here, "name" is created inside "greet()", so it belongs to the local scope of that function.

Python follows a specific rule to find a variable.

This rule is called LEGB.

L → Local
E → Enclosing
G → Global
B → Built-in

Python searches for a variable in this order:

Local
↓
Enclosing
↓
Global
↓
Built-in

Python stops searching as soon as it finds the variable.

L → Local Scope

A variable created inside a function is usually a local variable.

Example

def greet():
name = "Deepika"
print(name)

greet()

Here:

name = "Deepika"

is local to "greet()".

It cannot normally be accessed outside the function:

def greet():
name = "Deepika"

print(name)

This produces a "NameError" because "name" only exists inside "greet()".

Simple definition

«Local scope is the scope inside the current function.»

E → Enclosing Scope

The enclosing scope appears when one function is defined inside another function.

Example

def outer():

name = "Deepika"

def inner():
    print(name)

inner()

outer()

"name" is not inside "inner()".

It is inside "outer()".

Therefore, from the point of view of "inner()", "name" is in the enclosing scope.

outer()
│
├── name = "Deepika"
│
└── inner()
│
└── print(name)

Simple definition

«Enclosing scope is the scope of an outer function surrounding the current inner function.»

This concept is especially important when learning closures.

G → Global Scope

A variable created outside all functions is generally in the global scope.

Example

name = "Deepika"

def greet():
print(name)

greet()

Python cannot find "name" inside "greet()", so it looks in the global scope and finds it.

Local → not found
Enclosing → not found
Global → found

Output:

Deepika

Simple definition

«Global scope is the scope outside functions and classes at the module level.»

B → Built-in Scope

Python has many names that are already available to us.

Examples:

print()
len()
sum()
max()
min()
type()

These belong to Python's built-in scope.

Example

numbers = [10, 20, 30]

print(len(numbers))

Python looks for "len":

Local → not found
Enclosing → not found
Global → not found
Built-in → found

Output:

Simple definition

«Built-in scope contains names provided by Python itself.»

Complete LEGB Example

x = "Global"

def outer():

x = "Enclosing"

def inner():

    x = "Local"

    print(x)

inner()

outer()

Output:

Local

Why?

Because Python searches:

Local → found!

It stops there.

It does not continue searching the enclosing or global scope.

Another LEGB Example

x = "Global"

def outer():

x = "Enclosing"

def inner():
    print(x)

inner()

outer()

Output:

Enclosing

Why?

Local → not found
Enclosing → found!

"nonlocal"

"nonlocal" is used when an inner function wants to modify a variable belonging to an enclosing function.

Example

def outer():

count = 0

def inner():
    nonlocal count
    count += 1

inner()

print(count)

outer()

Output:

Without "nonlocal", Python would treat an assignment such as:

count += 1

as involving a local "count" inside "inner()".

Simple definition

«"nonlocal" tells Python that a variable belongs to an enclosing function's scope, not the current local scope.»

When is "nonlocal" useful?

It is commonly used with:

Nested functions
Closures
Functions that need to remember and update state

First-Class Functions

One of the most important things to understand about Python is:

«Functions are objects too.»

Because functions are objects, they can be treated like other values.

They can be:

Assigned to variables
Passed as arguments
Returned from functions
Stored in lists, dictionaries, etc.

This is called first-class functions.

Assigning a Function to a Variable

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

x = greet

x()

Output:

Hello!

Here:

x = greet

means "x" refers to the function.

Notice the difference:

greet

means the function itself.

greet()

means call the function.

Passing a Function as an Argument

Because functions are first-class objects, we can pass them to another function.

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

def execute(function):
function()

execute(greet)

Output:

Hello!

Here:

execute(greet)

passes the "greet" function to "execute()".

Inside "execute()":

function()

calls that function.

Returning a Function

A function can also return another function.

def outer():

def inner():
    print("Hello!")

return inner

x = outer()

x()

Output:

Hello!

Here:

x = outer()

stores the returned "inner" function in "x".

This idea is important for understanding closures and decorators.

When Are First-Class Functions Useful?

First-class functions are useful when we want to:

Pass behavior to another function
Create callbacks
Build decorators
Create closures
Choose a function dynamically
Store multiple functions and execute them later

Simple idea

Instead of only passing data:

process(10)

we can also pass behavior:

process(greet)

"*args"

Sometimes we don't know how many positional arguments a function will receive.

For example:

def add(a, b):
return a + b

This only accepts two arguments:

add(10, 20)

But this won't work:

add(10, 20, 30, 40)

We can use "*args" when we want to accept any number of positional arguments.

Syntax

def function_name(*args):
...

Example

def show(*args):
print(args)

show(10, 20, 30)

Output:

(10, 20, 30)

"args" contains the positional arguments inside a tuple.

Conceptually:

args = (10, 20, 30)

Example Using "*args"

def add(*args):

total = 0

for number in args:
    total += number

return total

print(add(10, 20))
print(add(10, 20, 30))
print(add(10, 20, 30, 40))

Output:

30
60
100

Simple definition

«"*args" allows a function to accept any number of positional arguments and collects them into a tuple.»

Is "args" a Special Keyword?

No.

The "*" is important.

The name can technically be anything:

def show(*numbers):
print(numbers)

But Python programmers normally use:

*args

because it is the standard convention.

"**kwargs"

Now let's talk about keyword arguments.

Consider:

def student(name, age):
print(name)
print(age)

We can call it using keyword arguments:

student(name="Deepika", age=21)

But what if we don't know how many keyword arguments will be provided?

We can use:

**kwargs

Syntax

def function_name(**kwargs):
...

Example

def student(**kwargs):
print(kwargs)

student(name="Deepika", age=21, city="Bangalore")

Output:

{'name': 'Deepika', 'age': 21, 'city': 'Bangalore'}

"kwargs" contains the keyword arguments inside a dictionary.

Conceptually:

kwargs = {
"name": "Deepika",
"age": 21,
"city": "Bangalore"
}

Simple Definition of "**kwargs"

«"**kwargs" allows a function to accept any number of keyword arguments and collects them into a dictionary.»

"args" vs "*kwargs"

The easiest thing to remember:

*args
↓
positional arguments
↓
tuple

**kwargs
↓
keyword arguments
↓
dictionary

Using "args" and "*kwargs" Together

We can use both in the same function.

def demo(*args, **kwargs):

print(args)
print(kwargs)

demo(
10,
20,
30,
name="Deepika",
age=21
)

Output:

(10, 20, 30)

{'name': 'Deepika', 'age': 21}

Python separates them:

10, 20, 30
↓
*args
↓
tuple

and:

name="Deepika"
age=21
↓
**kwargs
↓
dictionary

Packing and Unpacking

The "" and "*" symbols can also be used for unpacking.

Packing

When defining a function:

def demo(*args):
print(args)

"*args" collects multiple arguments into one tuple.

This is called packing.

Unpacking

Suppose we have:

numbers = [10, 20, 30]

We can unpack them:

def add(a, b, c):
return a + b + c

print(add(*numbers))

This is equivalent to:

add(10, 20, 30)

The "*" takes the elements from the list and sends them as separate positional arguments.

Dictionary Unpacking with "**"

Suppose:

student = {
"name": "Deepika",
"age": 21
}

We can do:

def show(name, age):
print(name)
print(age)

show(**student)

This is equivalent to:

show(name="Deepika", age=21)

So:

→ unpack sequence into positional arguments

** → unpack dictionary into keyword arguments

Mutable Default Argument Pitfall

Now let's look at one of Python's famous pitfalls.

A default argument is a value given to a parameter when the caller doesn't provide one.

Example:

def greet(name="Deepika"):
print("Hello", name)

greet()

Output:

Hello Deepika

What Is a Mutable Object?

A mutable object is an object whose contents can be changed.

Common mutable types include:

list
dict
set

Example:

numbers = []

numbers.append(10)

print(numbers)

Output:

[10]

The list was modified.

The Problem with Mutable Default Arguments

Consider this function:

def add_item(item, items=[]):

items.append(item)

return items

Now:

print(add_item("Apple"))
print(add_item("Banana"))
print(add_item("Mango"))

Output:

['Apple']
['Apple', 'Banana']
['Apple', 'Banana', 'Mango']

This can be surprising.

Why does this happen?

Because the default list:

items=[]

is created when the function is defined, not every time the function is called.

The same default list can therefore be reused between calls.

Conceptually:

Function
|
└── default list
|
├── Call 1 → ['Apple']
|
├── Call 2 → ['Apple', 'Banana']
|
└── Call 3 → ['Apple', 'Banana', 'Mango']

Why Is This Called a Pitfall?

Break the phrase into three parts:

Mutable

The object can be changed.

[]

is mutable.

Default argument

This is the default parameter:

items=[]

Pitfall

The same mutable object can be reused across function calls, causing unexpected results.

Simple definition

«The mutable default argument pitfall occurs when a mutable object such as a list, dictionary, or set is used as a default parameter and is modified, causing its changes to persist between function calls.»

The Safe Way: Use "None"

Instead of:

def add_item(item, items=[]):

use:

def add_item(item, items=None):

if items is None:
    items = []

items.append(item)

return items

Now:

print(add_item("Apple"))
print(add_item("Banana"))
print(add_item("Mango"))

Output:

['Apple']
['Banana']
['Mango']

A new list is created whenever "items" is "None".

Why Does "None" Fix the Problem?

"None" is used as a signal:

items=None

means:

«"No list was provided."»

Then:

if items is None:
items = []

creates a fresh list.

So instead of:

Call 1 ─┐
Call 2 ─┼──→ SAME LIST
Call 3 ─┘

we get:

Call 1 → NEW LIST
Call 2 → NEW LIST
Call 3 → NEW LIST

Mutable Default Dictionaries

The same problem can happen with dictionaries.

Avoid:

def add_user(name, users={}):

users[name] = "active"

return users

Prefer:

def add_user(name, users=None):

if users is None:
    users = {}

users[name] = "active"

return users

Mutable Default Sets

The same idea applies to sets.

Avoid:

def add_number(number, numbers=set()):

numbers.add(number)

return numbers

Prefer:

def add_number(number, numbers=None):

if numbers is None:
    numbers = set()

numbers.add(number)

return numbers

Are All Default Arguments Dangerous?

No.

Immutable objects such as:

int
float
str
tuple
None
bool

do not have the same mutable-default problem.

For example:

def counter(count=0):
count += 1
return count

print(counter())
print(counter())
print(counter())

Output:

1
1
1

This happens because integers are immutable.

The Pattern to Remember

Whenever you want a fresh mutable object for every function call, use "None".

List

def function(data=None):

if data is None:
    data = []

Dictionary

def function(data=None):

if data is None:
    data = {}

Set

def function(data=None):

if data is None:
    data = set()

Quick Revision

LEGB

L → Local
E → Enclosing
G → Global
B → Built-in

«Python searches for a variable in this order.»

"nonlocal"

nonlocal variable

«Used inside a nested function to modify a variable from the enclosing function.»

First-Class Functions

«Functions are objects and can be assigned to variables, passed as arguments, returned from functions, and stored in collections.»

Example:

def greet():
print("Hello")

x = greet

x()

"*args"

def function(*args):

«Accepts any number of positional arguments and stores them in a tuple.»

Example:

def show(*args):
print(args)

show(10, 20, 30)

Output:

(10, 20, 30)

"**kwargs"

def function(**kwargs):

«Accepts any number of keyword arguments and stores them in a dictionary.»

Example:

def show(**kwargs):
print(kwargs)

show(name="Deepika", age=21)

Output:

{'name': 'Deepika', 'age': 21}

Mutable Default Argument

Avoid:

def function(items=[]):

when you intend to create a fresh list for every call.

Prefer:

def function(items=None):

if items is None:
    items = []

«The key reason: default arguments are created when the function is defined, so a mutable default object can be reused between calls.»

⭐ The Most Important Things to Remember

LEGB
↓
Where does Python look for a variable?

L → Local
E → Enclosing
G → Global
B → Built-in

First-class functions
↓
Functions can be treated like objects.

*args
↓
many positional arguments
↓
tuple

**kwargs
↓
many keyword arguments
↓
dictionary

Mutable default argument
↓
Avoid [] / {} / set() as defaults
↓
Use None instead

These concepts are especially important because they form the foundation for understanding closures, decorators, callbacks, function arguments, and Python's scope behavior.

Mastering Advanced Python: Arguments, Closures, and Memory Pitfalls

Deepika Pusala — Sun, 16 Aug 2026 12:47:10 +0000

Mastering advanced Python functions requires a solid understanding of how arguments are dynamically passed, how variables are scoped in memory, and how objects evaluate over time.

Here is a breakdown of three essential Python concepts that separate beginners from pros.

1. Dynamic Arguments: `*args` and `**kwargs`

These syntaxes allow you to write flexible functions that accept an arbitrary number of inputs.

*args (Positional): Collects extra unnamed arguments into a tuple.
`kwargs` (Keyword): Collects extra named arguments into a **dictionary.

Implementation Example

def master_function(*args, **kwargs):
    print(f"args (tuple): {args}")
    print(f"kwargs (dict): {kwargs}")

# Calling the function
master_function(1, 2, 3, name="Alice", role="Admin")

# Output:
# args (tuple): (1, 2, 3)
# kwargs (dict): {'name': 'Alice', 'role': 'Admin'}

Argument Unpacking

You can also use * and ** to unpack existing iterables or dictionaries directly into function calls:

numbers = [10, 20, 30]
user_data = {"age": 25, "city": "Mumbai"}

# Unpacks sequence into individual arguments, and dict into keyword arguments
master_function(*numbers, **user_data)

2. Closures in Python

A closure is an inner function that retains access to variables from its outer (enclosing) scope, even after the outer function has completely finished executing.

Core Requirements

A nested (inner) function must exist.
The inner function must reference a variable from the enclosing scope.
The outer function must return the inner function object.

Implementation Example

def make_multiplier(factor):
    def multiply(number):
        # 'factor' is captured from the enclosing scope
        return number * factor
    return multiply

double = make_multiplier(2)
print(double(5))  # Output: 10
print(double(9))  # Output: 18

The Late-Binding Closures Pitfall

Python closures are late-binding. This means variables captured in closures are looked up at the time the inner function is called, not when it is defined.

def create_multipliers():
    return [lambda x: x * i for i in range(3)]

# Expected: [0, 2, 4] | Actual: [4, 4, 4]
print([func(2) for func in create_multipliers()])

Why? The loop variable i updates to 2 by the time the loop ends. When the lambdas are finally executed, they all see i = 2.
The Fix: Force immediate evaluation by passing i as a default argument: lambda x, i=i: x * i.

3. The Mutable-Default-Argument Pitfall

In Python, default arguments are evaluated only once—at the exact moment the function is defined, not each time the function is called.

If you use a mutable object (like a list, dictionary, or set) as a default parameter, that single object instance is shared across every single call to that function.

The Bug (Unexpected Persistence)

def add_item(item, target_list=[]):
    target_list.append(item)
    return target_list

print(add_item("apple"))  # Output: ['apple']
print(add_item("banana")) # Output: ['apple', 'banana'] (Shared the same list instance!)

The Standard Fix

To avoid this state-sharing bug, use None as the placeholder default value. Inside the function body, explicitly initialize a brand-new mutable object if the argument evaluates to None.

def add_item_fixed(item, target_list=None):
    if target_list is None:
        target_list = []  # A brand new list is created on every fresh execution
    target_list.append(item)
    return target_list

print(add_item_fixed("apple"))  # Output: ['apple']
print(add_item_fixed("banana")) # Output: ['banana'] (Correct behavior)

Quick Concept Summary

Concept	Primary Purpose	Common Use Case
*`args` / `kwargs`	Handle unexpected or variable numbers of inputs.	Creating wrapper functions or decorators.
Closures	Maintain state across functions without global variables.	Factory functions and data hiding.
`None` Defaults	Prevent unintended side-effects from mutable objects.	Safely defining optional list or dict inputs.

DEV Community: Deepika Pusala

Week 4 - Task 2.3 : From Functions to Powerful Decorators 🐍💜

1️⃣ First-Class Functions

Passing a function as an argument

Returning a function

2️⃣ Closures 🔐

The 3 ingredients of a closure

A more useful example

3️⃣ Decorators 🎁

What @decorator actually does

4️⃣ Parameterized Decorators 🎯

The key insight: it's a closure

5️⃣ The Metadata Problem 😭

The fix: functools.wraps

6️⃣ *args and **kwargs — Making Decorators Work with Any Function

🧩 Putting It All Together

🌍 Where This Shows Up in Real Code

🎯 Interview-Ready Definitions

🧠 One Mental Model to Hold On To

Week 04- Task 2.2: functools Toolkit: reduce, partial, lru_cache & wraps 🧰

➕ 1. reduce() — Combine everything into ONE

🧠 map vs filter vs reduce — the shape of the output

🟣 2. partial() — Pre-fill some arguments

🔵 3. lru_cache() — Remember previous results

Why "LRU"?

🔥 Where it actually matters

🟠 4. wraps() — Preserve a function's identity through decorators

First, what's a decorator?

The problem

The fix: @wraps(func)

🎁 A simple analogy

The standard pattern you'll see everywhere

🧩 Putting It All Together

Week 04 - Task 2.1: Functional Programming in Python: map(), filter(), reduce() 🗺️🔎➕

🧠 What Is Functional Programming, Really?

🗺️ map() — "Do this to EVERY item"

🔎 filter() — "Keep only the ones I want"

🆚 map() vs filter() — the quick gut-check

➕ reduce() — "Combine everything into ONE result"

🍕 Real-World Example: Running a Pizza Shop

🏆 The Cheat Sheet

⚠️ A Small Gotcha

🤔 "Why not just use a for loop?"

✨ The More "Pythonic" Alternative: List Comprehensions

🎯 One Sentence to Remember

Week 04 - Task 1.3 : @dataclass, abstract base classes via the abc module & composition vs inheritance

🎁 @dataclass — Stop Writing Boilerplate

🧱 Abstract Base Classes (abc) — Enforcing a Contract

⚖️ @dataclass vs ABC — Different Jobs

🧬 Composition vs Inheritance

Inheritance (IS-A)

Composition (HAS-A)

Side by Side

When to use which

🎯 Quick Recap

Week 04 - Task 1.2: dunder/magic methods (__init__, __repr__, __eq__, __len__, __add__, etc.)

Python Dunder Methods, Demystified 🪄

🔤 What Does "Dunder" Even Mean?

💡 Why Do They Exist?

⚙️ Are They Automatic?

🙋 A Quick Word on self

🧰 The Core Dunder Methods

__init__ — set up the object

__repr__ — give it a readable identity

__eq__ — define what "equal" means

__len__ — teach len() about your object

__add__ — define what + means

🧩 Putting It All Together

🚨 Don't Confuse __main__ with __init__

🏢 Where This Shows Up in Real Code

🎯 Cheat-Sheet Answers

🧠 One Picture to Remember

Week 4, Task - 1.1: Classes, Inheritance & MRO 🐍

🧱 What Is a Class?

🧬 What Is Inheritance?

🌳 The 5 Types of Inheritance

🔄 Overriding vs ➕ Overloading (don't mix these up!)

🧭 MRO: Method Resolution Order

Where it really matters: multiple inheritance

🪜 super() — jump to the next class in line

What `@decorator` actually does

The fix: `functools.wraps`

➕ 1. `reduce()` — Combine everything into ONE

🟣 2. `partial()` — Pre-fill some arguments

🔵 3. `lru_cache()` — Remember previous results

🟠 4. `wraps()` — Preserve a function's identity through decorators

The fix: `@wraps(func)`

🗺️ `map()` — "Do this to EVERY item"

🔎 `filter()` — "Keep only the ones I want"

➕ `reduce()` — "Combine everything into ONE result"

🤔 "Why not just use a `for` loop?"

🎁 `@dataclass` — Stop Writing Boilerplate

🧱 Abstract Base Classes (`abc`) — Enforcing a Contract

⚖️ `@dataclass` vs ABC — Different Jobs

Week 04 - Task 1.2: dunder/magic methods (init, repr, eq, len, add, etc.)

🙋 A Quick Word on `self`

`init` — set up the object

`repr` — give it a readable identity

`eq` — define what "equal" means

`len` — teach `len()` about your object

`add` — define what `+` means

🚨 Don't Confuse `main` with `init`

8️⃣ `init()` 🏗️

9️⃣ `repr()` 🔎

🔟 `eq()` ⚖️

1️⃣1️⃣ `len()` 📏

1️⃣2️⃣ `add()` ➕

🏷️ 1️⃣4️⃣ What is `@dataclass`?

Without `@dataclass`

With `@dataclass`

🚨 When should you use `@dataclass`?

🧠 1️⃣5️⃣ Abstract Base Classes — `abc`

🐍 Python Context Managers: The Easy Guide (with, enter/exit, @contextmanager, contextlib)

🐍 Python Context Managers: The Easy Guide (`with`, `enter`/`exit`, `@contextmanager`, `contextlib`)

🏗️ Method 1: The `enter` / `exit` Protocol

🔍 Breaking Down `exit`'s Weird Parameters

✨ Method 2: The `@contextmanager` Decorator (The Easy Way)

⚠️ Handling Errors in `@contextmanager`

🧰 Bonus: Handy `contextlib` Utilities

1️⃣ `contextlib.suppress()` — Ignore Specific Exceptions

2️⃣ `contextlib.closing()` — Auto-Close Objects That Have `.close()`

3️⃣ `contextlib.ExitStack()` — Manage a Dynamic Number of Contexts

4️⃣ `contextlib.redirect_stdout()` — Capture `print()` Output

🥊 `enter`/`exit` vs `@contextmanager`: Which Should I Use?

1. Iterator Protocol (`iter()` / `next()`)

How does a `for` loop work?

2. Generator Functions & `yield`