DEV Community: M.T.Ramkrushna

From Python Basics to Building an Async Task Processing API

M.T.Ramkrushna — Wed, 24 Jun 2026 17:27:47 +0000

Most tutorials teach concepts separately:

Classes
Decorators
Async
Generators
Type hints
Pytest

The problem?

Real applications use all of them together.

Let's build something useful.

Project Goal

Build an Async Task Processing API.

Users can:

Submit tasks
Check status
Process tasks in background

Think:

Video processing
Email sending
Report generation
AI jobs

Exactly how modern SaaS products work.

Step 1: Python Syntax Refresh

Variables:

name = "John"
age = 25

Functions:

def greet(name):
    return f"Hello {name}"

Lists:

tasks = ["email", "sms"]

Dictionaries:

task = {
    "id": 1,
    "status": "pending"
}

Step 2: Classes

Represent a task.

class Task:
    def __init__(self, task_id, name):
        self.task_id = task_id
        self.name = name
        self.status = "pending"

Usage:

task = Task(1, "Send Email")

Think of a class as a blueprint.

Like an architect's drawing before building a house.

Step 3: Type Hints

def create_task(
    name: str
) -> str:
    return name

Benefits:

Better IDE support
Easier maintenance
Self-documenting code

Step 4: Pydantic

from pydantic import BaseModel

class TaskRequest(BaseModel):
    name: str

Incoming requests validated automatically.

Step 5: Async/Await

Task simulation:

import asyncio

async def process_task():
    await asyncio.sleep(5)

The server remains available while waiting.

Step 6: Decorators

Logging decorator.

def log(func):
    def wrapper(*args, **kwargs):
        print("Running...")
        return func(*args, **kwargs)

    return wrapper

Usage:

@log
def create_task():
    pass

Think of decorators as middleware for functions.

Step 7: Generators

Large task stream.

def task_stream():
    for i in range(1000000):
        yield i

Memory friendly.

Only one value exists at a time.

Step 8: FastAPI API

from fastapi import FastAPI

app = FastAPI()

Create task:

@app.post("/tasks")
async def create_task():
    pass

Check status:

@app.get("/tasks/{id}")
async def get_task():
    pass

Step 9: Background Processing

asyncio.create_task(
    process_task()
)

Request returns immediately.

Processing continues.

This is how:

YouTube
Uber
Airbnb
Stripe

handle long-running work.

Step 10: Pytest

Test task creation.

def test_create_task():
    assert 1 + 1 == 2

API testing:

def test_task_api():
    response = client.post(
        "/tasks"
    )

    assert response.status_code == 200

Testing is insurance.

Nobody notices it until something breaks.

Final Architecture

Request

↓

Pydantic Validation

↓

FastAPI Endpoint

↓

Background Async Task

↓

Task Storage

↓

Status Endpoint

↓

Client

What You'll Learn in One Project

✓ Python Syntax

✓ Classes

✓ Type Hints

✓ Decorators

✓ Generators

✓ Async/Await

✓ Pydantic

✓ FastAPI

✓ Pytest

✓ Real Backend Architecture

This single project mirrors the foundations used inside modern AI products, SaaS platforms, and cloud-native backend systems.

Once you can build this confidently, you're no longer learning Python concepts.

You're building production systems.

Pydantic Explained Simply: The Security Guard of Your API

M.T.Ramkrushna — Wed, 24 Jun 2026 17:26:29 +0000

One of the biggest beginner mistakes in backend development is trusting user input.

Users can send:

{
  "name": 123,
  "email": false,
  "age": "banana"
}

Your application expects:

{
  "name": "John",
  "email": "john@gmail.com",
  "age": 25
}

How do we stop bad data?

Enter Pydantic.

Think of an Airport Security Check

Before passengers board a plane:

Identity checked
Bags checked
Documents checked

Not because passengers are bad.

Because systems fail when validation is skipped.

Pydantic does the same for APIs.

Without Pydantic

data = request.json()

name = data["name"]
age = data["age"]

What if:

{
  "age": "hello"
}

Crash.

With Pydantic

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

Input:

User(
    name="John",
    age=25
)

Works.

Input:

User(
    name="John",
    age="hello"
)

Validation error.

Why FastAPI Loves Pydantic

FastAPI automatically:

Validates requests
Generates documentation
Creates schemas
Returns useful errors

Example:

from fastapi import FastAPI

app = FastAPI()

@app.post("/users")
async def create_user(user: User):
    return user

That's all.

Validation included.

Real Business Example

Imagine a payment API.

You expect:

amount: float

User sends:

{
  "amount": "one million"
}

Without validation:

Database corruption
Failed transactions
Production incidents

With Pydantic:

Request rejected instantly.

Hidden Superpower

Pydantic can transform data.

Input:

{
  "age": "25"
}

Model:

class User(BaseModel):
    age: int

Output:

age = 25

Automatic conversion.

Magic with safety.

Think of Pydantic Like This

Database = Vault

API = Front Door

Pydantic = Security Guard

Without a guard, anyone walks in.

With a guard, only valid data enters.

That's why nearly every serious FastAPI project uses Pydantic.

Understanding Async/Await Visually: The Restaurant Analogy Every Developer Remembers

M.T.Ramkrushna — Tue, 23 Jun 2026 14:19:55 +0000

Most developers learn async/await by reading definitions like:

"Async programming allows non-blocking execution of code."

Sounds smart.

But many still can't explain what actually happens.

Let's fix that.

Imagine a Restaurant

You walk into a restaurant.

Synchronous World

A waiter takes your order.

Then stands next to the kitchen.

And waits.

For 20 minutes.

Doing nothing.

Then brings your food.

Then serves the next customer.

Ridiculous, right?

Yet this is exactly how synchronous code behaves.

import time

def make_pizza():
    time.sleep(20)
    return "Pizza Ready"

pizza = make_pizza()
print(pizza)

The program waits.

Nothing else happens.

Async World

Now imagine a smarter waiter.

He takes your order.

Gives it to the kitchen.

Moves to another table.

Takes more orders.

Serves drinks.

Answers questions.

When the pizza is ready, he comes back.

That's async programming.

The waiter doesn't stop working.

The kitchen works independently.

import asyncio

async def make_pizza():
    await asyncio.sleep(20)
    return "Pizza Ready"

Notice the keyword:

await

This means:

"I'm waiting for something. While waiting, let someone else work."

Why Async Exists

Modern applications spend most of their time waiting:

Database queries
API calls
File uploads
Payment gateways
Email services

The CPU isn't busy.

It's waiting.

Async lets us use that waiting time productively.

Real Example: Fetching User Data

Without async:

user = get_user()
orders = get_orders()
payments = get_payments()

Time:

1 sec + 1 sec + 1 sec = 3 sec

With async:

user, orders, payments = await asyncio.gather(
    get_user(),
    get_orders(),
    get_payments()
)

Time:

max(1,1,1) = 1 sec

Same work.

3x faster.

Common Beginner Mistake

People think async means:

Faster CPU execution.

Wrong.

Async doesn't make calculations faster.

It makes waiting smarter.

Think:

CPU work → multiprocessing
Waiting work → async

Mental Model

Imagine every function holding a microphone.

Normal function:

"Nobody talks until I'm done."

Async function:

"While I'm waiting, someone else can speak."

That single idea explains 90% of async programming.

Where You'll Use Async

Almost every modern backend framework:

FastAPI
Starlette
Sanic
Node.js
Deno
Modern Django

If your application talks to databases, APIs, queues, or cloud services, async is becoming mandatory knowledge.

Final Takeaway

Async programming is not about speed.

It's about efficiency.

A waiter who serves one table at a time creates a queue.

A waiter who keeps moving creates a business.

Your code works exactly the same way.

Why pytest Makes Python Testing Surprisingly Enjoyable

M.T.Ramkrushna — Tue, 19 May 2026 03:11:01 +0000

Many developers avoid testing because traditional testing frameworks feel heavy.

But pytest changed that perception for Python developers.

It’s minimal, readable, and extremely powerful.

Real-Life Problem

Imagine deploying:

payment systems,
trading bots,
AI pipelines,
order management systems.

One unnoticed bug can:

lose money,
corrupt data,
crash services.

Testing is insurance.

Traditional Testing Feels Verbose

Older frameworks often require:

large setup code,
boilerplate classes,
repetitive assertions.

pytest keeps things simple.

Basic Example

Suppose you have:

def calculate_total(price: int, quantity: int) -> int:
    return price * quantity

Test:

def test_calculate_total():
    result = calculate_total(100, 3)

    assert result == 300

That’s it.

No huge setup required.

Why Developers Love pytest

It provides:

simple syntax,
detailed failure reports,
fixtures,
parameterized testing,
async testing support.

Real Backend Example

Imagine validating order status.

class Order:

    def __init__(self):
        self.status = "pending"

    def complete(self):
        self.status = "completed"

Test:

def test_order_completion():
    order = Order()

    order.complete()

    assert order.status == "completed"

Readable even for non-Python developers.

Testing Async Code

Modern systems are async-heavy.

pytest handles this beautifully.

import pytest
import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return "success"

@pytest.mark.asyncio
async def test_fetch_data():
    result = await fetch_data()

    assert result == "success"

This becomes essential in:

FastAPI,
AI agents,
websocket systems,
realtime apps.

Fixtures: Reusable Test Setup

Suppose multiple tests need a sample user.

import pytest

@pytest.fixture
def sample_user():
    return {
        "name": "Ali",
        "age": 26
    }

def test_user_name(sample_user):
    assert sample_user["name"] == "Ali"

Fixtures reduce duplication massively.

Real Industry Usage

Companies use pytest for:

backend APIs,
ML pipelines,
infra automation,
data engineering,
AI systems.

Testing becomes even more important as systems scale.

Final Thoughts

pytest is one reason Python developer experience feels so good.

It encourages testing without making it painful.

And developers who write tests consistently usually:

ship faster,
debug less,
break production less often.

That becomes a serious career advantage over time.

Pydantic + Type Hints: The Cleanest Way to Validate APIs in Python

M.T.Ramkrushna — Tue, 19 May 2026 03:10:02 +0000

Backend developers spend huge amounts of time validating data.

Examples:

Is email valid?
Is age an integer?
Did the frontend send missing fields?
Is the JSON malformed?

Python’s combination of:

type hints
Pydantic

makes this dramatically simpler.

Real-Life Example

Suppose you’re building:

signup APIs,
payment systems,
booking apps,
AI tools receiving prompts.

You never trust incoming data.

Without Validation

data = {
    "name": "Ali",
    "age": "twenty"
}

This can silently break your backend later.

Using Pydantic

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

Now validation becomes automatic.

Example Usage

user = User(
    name="Ali",
    age=26
)

print(user)

Output:

name='Ali' age=26

Invalid Data Example

user = User(
    name="Ali",
    age="twenty"
)

Pydantic throws a validation error immediately.

That’s powerful.

Why This Matters in Production

Validation prevents:

corrupted databases,
API crashes,
unexpected bugs,
broken analytics,
bad AI inputs.

This is why FastAPI heavily relies on Pydantic.

Add Optional Fields

from typing import Optional

class User(BaseModel):
    name: str
    age: int
    city: Optional[str] = None

Very readable and production-friendly.

Real API Example

from fastapi import FastAPI

app = FastAPI()

class LoginRequest(BaseModel):
    email: str
    password: str

@app.post("/login")
async def login(data: LoginRequest):
    return {
        "message": "Login successful"
    }

The API now validates requests automatically.

Combining With Generators

Imagine streaming validated records from a CSV.

def valid_users():
    for i in range(5):
        yield User(
            name=f"User{i}",
            age=20 + i
        )

This pattern is useful in:

ETL pipelines,
AI preprocessing,
analytics systems.

Why Pydantic Became So Popular

Because it solves a real developer pain:

clean validation,
less boilerplate,
better IDE support,
safer APIs.

It makes Python feel modern and structured without becoming verbose.

Final Thoughts

If you want to become strong in:

FastAPI,
AI engineering,
backend systems,

learning Pydantic deeply is worth it.

It’s one of those tools that immediately improves code quality.

Async/Await in Python Explained Using a Food Delivery App

M.T.Ramkrushna — Tue, 19 May 2026 03:07:59 +0000

One of the biggest mindset shifts in Python backend development is understanding async/await.

At first, it looks confusing.

But once you connect it to real-life backend problems, it becomes much easier.

Let’s break it down using something relatable:
a food delivery app.

The Problem With Traditional Blocking Code

Imagine 100 users ordering food simultaneously.

Your backend must:

verify payment,
call restaurant API,
assign delivery partner,
send notifications.

If every task waits sequentially, your server slows down.

Normal Blocking Example

import time

def prepare_order():
    time.sleep(5)
    return "Food Ready"

print(prepare_order())

The program waits completely for 5 seconds.

This is called blocking execution.

Async Version

import asyncio

async def prepare_order():
    await asyncio.sleep(5)
    return "Food Ready"

async def main():
    result = await prepare_order()
    print(result)

asyncio.run(main())

Now Python can work on other tasks while waiting.

Real-Life Analogy

Think of a restaurant waiter.

Bad system:

waiter stands near kitchen doing nothing until food is ready.

Async system:

waiter takes other orders while kitchen cooks.

That’s exactly what async programming does.

Where Async Actually Helps

Async shines when dealing with:

APIs,
databases,
notifications,
sockets,
queues,
AI inference calls,
web scraping.

Not CPU-heavy work.

Combining Async With Classes

import asyncio

class NotificationService:

    async def send_sms(self, user: str):
        await asyncio.sleep(2)
        print(f"SMS sent to {user}")

async def main():
    service = NotificationService()

    await service.send_sms("Ali")

asyncio.run(main())

This pattern is extremely common in FastAPI systems.

Add Type Hints for Cleaner APIs

class NotificationService:

    async def send_sms(self, user: str) -> None:
        print(f"SMS sent to {user}")

Type hints become very useful in async-heavy codebases.

Using Decorators With Async Functions

Suppose you want request timing.

import time

def timer(func):
    async def wrapper(*args, **kwargs):
        start = time.time()

        result = await func(*args, **kwargs)

        end = time.time()

        print(f"Execution Time: {end - start}")

        return result

    return wrapper

Usage:

class PaymentService:

    @timer
    async def process_payment(self):
        await asyncio.sleep(2)
        print("Payment completed")

Why Modern Backend Frameworks Prefer Async

Frameworks like FastAPI became popular because async allows:

better scalability,
lower server costs,
high concurrent request handling.

This matters massively in:

AI apps,
chat systems,
trading systems,
live dashboards,
realtime analytics.

Final Thoughts

Async/await feels difficult initially because it changes how we think about execution.

But once you understand:

“waiting without blocking”

everything clicks.

And in modern backend engineering, async is no longer optional knowledge.

It’s becoming foundational.

From Rails to Python: Why Python Classes Feel Simpler in Real Backend Projects

M.T.Ramkrushna — Tue, 19 May 2026 03:06:33 +0000

If you’re coming from Ruby or Rails, Python classes can feel surprisingly lightweight.
You still get object-oriented programming, encapsulation, reusable code, and clean architecture — but with less “magic”.

In this article, we’ll build a small real-world backend example using:

Python classes
Type hints
Decorators
Generators

And we’ll model something most developers understand instantly: an order processing system.

Real-Life Scenario

Imagine you are building a backend for:

an ecommerce store,
Food delivery system,
SaaS billing engine,
or warehouse management app.

You’ll likely have:

Orders
Customers
Inventory
Event logs

This is where Python classes become extremely practical.

Basic Python Class Example

class Order:
    def __init__(self, order_id: int, customer: str):
        self.order_id = order_id
        self.customer = customer
        self.status = "pending"

    def complete_order(self):
        self.status = "completed"

order = Order(101, "Ali")

print(order.customer)
print(order.status)

order.complete_order()

print(order.status)

Output:

Ali
pending
completed

Why This Feels Cleaner Than Many OOP Systems

Python removes unnecessary ceremony.

You don’t need:

getters/setters everywhere,
verbose constructors,
interfaces for everything,
complex inheritance chains.

Most backend systems only need:

simple models,
service classes,
utility layers.

Python excels here.

Add Type Hints for Production Readability

Now let’s make this production-friendly.

class Order:
    def __init__(self, order_id: int, customer: str):
        self.order_id: int = order_id
        self.customer: str = customer
        self.status: str = "pending"

    def complete_order(self) -> None:
        self.status = "completed"

Why type hints matter

In large teams:

they improve autocomplete,
reduce bugs,
help onboarding,
make APIs self-documenting.

Especially useful when building:

FastAPI apps,
AI systems,
async services,
internal SDKs.

Using Decorators for Logging

Real systems need observability.

Suppose you want to log every important action.

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

Use it inside the class:

class Order:
    def __init__(self, order_id: int):
        self.order_id = order_id

    @log_action
    def ship(self):
        print("Order shipped")

Output:

Running: ship
Order shipped

Real Backend Use Cases of Decorators

Decorators are heavily used in:

authentication,
rate limiting,
retries,
caching,
logging,
monitoring,
API routing.

Example:

@app.get("/orders")

That FastAPI route itself is a decorator.

Generators: Secret Weapon for Large Data

Suppose your warehouse has 10 million orders.

Returning all data at once is memory-heavy.

Generators solve this elegantly.

def order_ids():
    for i in range(1, 1000000):
        yield i

Usage:

for order_id in order_ids():
    print(order_id)

The values are generated lazily.

Real-Life Generator Use Cases

Generators are perfect for:

CSV processing,
log streaming,
AI dataset pipelines,
Kafka consumers,
ETL jobs,
background workers.

Instead of loading everything into RAM, Python streams data efficiently.

Final Thoughts

Python classes are practical because they focus on:

readability,
maintainability,
developer speed.

When combined with:

decorators,
generators,
type hints,

you can build production-grade systems that remain surprisingly simple.

That’s one reason Python dominates:

AI engineering,
backend systems,
automation,
data infrastructure.

PYTHON ESSENTIALS FOR AI/ML (Virtual Environment)

M.T.Ramkrushna — Sat, 29 Nov 2025 07:44:37 +0000

🚀 What is a Virtual Environment?

A virtual environment is like giving each project its own private room with its own:

Python version
Installed packages
Dependencies

Real-life analogy:

Imagine you have:

A gym bag
A college bag
A travel bag

Each has its own items, and adding something to one doesn’t disturb the others.

Virtual environments do the same for your projects.

🚀 Why Do We Need Virtual Environments?

1️⃣ Avoid Version Conflicts

Project A needs:

numpy 1.20

Project B needs:

numpy 1.26

If you install globally, they fight.
With virtual environments → no conflict.

2️⃣ Consistent Setups

Your project can be reproduced anywhere:

same Python version
same packages
same environment

This is crucial for:

AI/ML experiments
production apps
teamwork

3️⃣ Keeps System Clean

No messing up your global Python installation.

Real-life analogy:
Don’t mix all spices in one big jar — keep separate boxes.

🚀 Virtual Environment Options

Two standard ways:

✔ venv

Built-in, lightweight, perfect for normal Python dev.

✔ conda

Comes with Anaconda/Miniconda.
Great for AI/ML, because it handles:

Python versions
C dependencies
ML libraries (TensorFlow / PyTorch)
GPU packages

🚀 Using venv (Built-in Python)

🛠 Step 1: Create venv

python3 -m venv myenv

This creates:

myenv/
    bin/
    lib/
    include/

🛠 Step 2: Activate

Windows

myenv\Scripts\activate

Mac/Linux

source myenv/bin/activate

After activation you’ll see:

(myenv) $

🛠 Step 3: Install packages

pip install numpy

🛠 Step 4: Deactivate

deactivate

🚀 Using Conda Environments (Recommended for ML)

🛠 Step 1: Create environment

conda create -n myenv python=3.11

🛠 Step 2: Activate

conda activate myenv

🛠 Step 3: Install packages

conda install numpy

or mix pip:

pip install pandas

🛠 Step 4: Deactivate

conda deactivate

🚀 Visual Explanation (ASCII)

How system looks WITHOUT virtual env:

Global Python
 ├── numpy 1.20
 ├── pandas 1.2
 ├── django 2.2
 └── tensorflow 1.0

→ If you update one, everything breaks.

How system looks WITH virtual env:

projectA_env
   ├── numpy 1.20
   └── pandas 1.2

projectB_env
   ├── numpy 1.26
   └── django 4.0

ml_env
   ├── tensorflow 2.15
   └── torch 2.3

Each one is independent.

🚀 Real-Life Examples

✔ Example 1: Working on 2 AI Projects

Chatbot project uses Python 3.9 + TensorFlow
LLM fine-tuning uses Python 3.11 + PyTorch

With conda:

conda create -n chatbot python=3.9 tensorflow
conda create -n llm python=3.11 pytorch

✔ Example 2: Deploying a Backend Using venv

For Django/Flask apps:

python3 -m venv backend_env
source backend_env/bin/activate
pip install django gunicorn

✔ Example 3: Keeping experiments isolated

ML experimentation often means:

Trying different library versions
Custom builds
GPU-compatible wheels

Conda helps you switch quickly:

conda create -n test_torch python=3.10 pytorch=2.2
conda activate test_torch

🚀 Bonus: Requirements Files

To share or reproduce your environment:

pip freeze > requirements.txt

Install from it:

pip install -r requirements.txt

🚀 Quick Summary

Virtual environments = isolated sandboxes
venv → simple projects
conda → ML/AI, CUDA, heavy libs
Prevent conflicts
Clean, reproducible environments

PYTHON ESSENTIALS FOR AI/ML(Error Handling)

M.T.Ramkrushna — Sat, 29 Nov 2025 07:08:38 +0000

⚡ What is Error Handling?

Error handling means predicting, catching, and responding to errors so your program doesn’t crash.

Real-life analogy:
Imagine you’re ordering food online. If the restaurant is closed, the app doesn’t crash — it shows “Restaurant unavailable”.
That’s error handling.

⚡ Types of Errors in Python

1️⃣ Syntax Errors

Mistakes in code structure.
Program won't run until fixed.

Example:

print("hello"

Missing ) → syntax error.

2️⃣ Runtime Errors (Exceptions)

Code is syntactically correct but fails during execution.

Example:

10 / 0   # ZeroDivisionError

Real-life example:
Trying to withdraw ₹2000 when your wallet has ₹500.

3️⃣ Logical Errors

No crash, but wrong output due to incorrect logic.

Example:

# Intended: average of two numbers
avg = (a + b) / 2   # correct
avg = a + b / 2     # wrong → no error but wrong logic

Real-life example:
Setting an alarm for 6 PM instead of 6 AM — phone doesn’t complain, but logic is wrong.

⚡ The `try / except` Block

Basic structure:

try:
    # code that might fail
except:
    # what to do if it fails

⚡ Catching Specific Exceptions (best practice)

Why specific?
It’s like telling the delivery app what to do for each issue:

Restaurant closed
Payment failed
Wrong address

Example:

try:
    num = int(input("Enter number: "))
    result = 10 / num
except ValueError:
    print("Please enter a valid number.")
except ZeroDivisionError:
    print("Number cannot be zero.")

⚡ `else` Block (runs when no error occurs)

Real-life analogy:
If payment is successful, THEN show “Order confirmed”.

try:
    f = open("data.txt")
except FileNotFoundError:
    print("File missing!")
else:
    print("File opened successfully!")
    f.close()

⚡ `finally` Block (ALWAYS runs)

Real-life analogy:
After cooking, you always turn off the gas — whether food is burnt, undercooked, or perfect.

try:
    f = open("data.txt")
    content = f.read()
except FileNotFoundError:
    print("File not found")
finally:
    print("Cleaning up...")

⚡ Raising Your Own Errors (`raise`)

You can trigger errors when invalid data is detected.

Real-life example:
If someone tries to book 12 tickets (but limit is 10), you show an error.

def book_tickets(n):
    if n > 10:
        raise ValueError("Cannot book more than 10 tickets")
    return "Tickets booked!"

book_tickets(12)

⚡ Custom Exceptions

Useful in large applications (AI pipelines, payment apps, etc):

Real-life example:
You create a custom error: LowBatteryError.

class LowBatteryError(Exception):
    pass

def start_camera(battery):
    if battery < 10:
        raise LowBatteryError("Battery too low!")
    print("Camera started.")

start_camera(5)

⚡ Real-Life Relatable Examples

✔ Example 1: ATM Machine

ATM checks:

Card validity → ValueError
Wrong pin → AuthenticationError (custom)
Low balance → InsufficientFundsError

class InsufficientFundsError(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError("Balance too low.")
    return balance - amount

try:
    new_balance = withdraw(500, 1000)
except InsufficientFundsError as e:
    print(e)

✔ Example 2: AI Model Loading (ML Example)

try:
    model = load_model("model.pkl")
except FileNotFoundError:
    print("Model missing! Download it again.")

✔ Example 3: Reading JSON Config

import json

try:
    data = json.loads('{"name": "Ali"')   # missing ending }
except json.JSONDecodeError:
    print("Invalid config file format!")

⚡ Quick Summary (for memory)

try → attempt
except → recovery
else → success block
finally → cleanup
raise → throw custom error
Custom Exceptions → your own meaningful error types

PYTHON ESSENTIALS FOR AI/ML(Working With Files)

M.T.Ramkrushna — Sat, 29 Nov 2025 07:06:11 +0000

📂 1. Why File Handling Matters

In real life you constantly work with files:

reading config files
storing logs
loading training data (CSV/JSON)
saving model outputs
writing results into text files

Python makes this very easy.

📄 2. Opening a File (`open()`)

Basic syntax:

file = open("filename.txt", "mode")

Modes you must know:

Mode	Meaning
`"r"`	read (file must exist)
`"w"`	write (overwrite existing file)
`"a"`	append (add to existing file)
`"x"`	create file (error if exists)
`"b"`	binary mode (images, audio, etc.)
`"t"`	text mode (default)

Real-life analogy

Mode = how you enter a room

r: you can only look
w: you can rewrite everything
a: you add more items without removing old ones

✍️ 3. Writing to a File

Example: saving user notes

file = open("notes.txt", "w")
file.write("Remember to practice Python daily!")
file.close()

This creates/overwrites the file.

Append mode

file = open("notes.txt", "a")
file.write("\nToday's progress: Learned file handling.")
file.close()

📖 4. Reading a File

Reading the whole file

file = open("notes.txt", "r")
content = file.read()
print(content)
file.close()

Reading line by line

file = open("notes.txt", "r")
for line in file:
    print(line.strip())
file.close()

🔐 5. Important: Always Close the File

Not closing files can lock them or waste system resources.

Best practice: use `with` (autoclose)

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

This automatically closes the file — ML/data engineers use this always.

📦 6. Real-Life Examples

🧾 Example 1: Saving user logs

with open("logs.txt", "a") as f:
    f.write("User logged in at 9:00 PM\n")

📊 Example 2: Saving model predictions

predictions = [0.8, 0.2, 0.65]

with open("preds.txt", "w") as f:
    for p in predictions:
        f.write(str(p) + "\n")

🙋 Example 3: Counting how many lines in a dataset

with open("data.txt") as f:
    count = len(f.readlines())
print("Lines:", count)

🧃 7. Reading CSV Files (Without Pandas)

Real-life use: loading small datasets

with open("data.csv") as f:
    for line in f:
        values = line.strip().split(",")
        print(values)

🧱 8. Writing to CSV Files

rows = [
    ["name", "age"],
    ["Ali", 25],
    ["Sara", 22]
]

with open("people.csv", "w") as f:
    for r in rows:
        f.write(",".join(map(str, r)) + "\n")

📜 9. Working With JSON Files (Super Useful in ML)

Write JSON

import json

data = {"name": "Ali", "skills": ["py", "ml"]}

with open("info.json", "w") as f:
    json.dump(data, f, indent=4)

Read JSON

with open("info.json") as f:
    content = json.load(f)
print(content)

Real-life use:

saving model configs
storing hyperparameters
reading APIs

🖼️ 10. Working With Binary Files (Images, audio)

with open("photo.jpg", "rb") as f:
    data = f.read()

with open("copy.jpg", "wb") as f:
    f.write(data)

🏁 11. Useful File-Related Operations (os module)

Check if file exists

import os

print(os.path.exists("notes.txt"))

Delete a file

os.remove("notes.txt")

List all files

print(os.listdir("."))

🧪 12. Mini Exercises (Do these!)

Send your answers and I’ll check them.

Exercise 1

Write a note "Learning Python Files!" into learning.txt

Exercise 2

Read a file and print only lines that contain the word "error".

Exercise 3

Given a list of names, save each name on a new line in users.txt.

Exercise 4

Create a JSON file details.json containing:

name
age
skills (list)

Exercise 5

Copy an image a.jpg into backup/a_backup.jpg.

4. PYTHON ESSENTIALS FOR AI/ML (Advanced OOP)

M.T.Ramkrushna — Thu, 27 Nov 2025 12:34:39 +0000

1. Class Methods (`@classmethod`)

What it is

A method that belongs to the class, not an individual object.
It receives cls instead of self.

When it's used

Creating alternative constructors
Tracking class-level data

Example

class Employee:
    company = "OpenAI"
    count = 0

    def __init__(self, name):
        self.name = name
        Employee.count += 1

    @classmethod
    def total_employees(cls):
        return cls.count

print(Employee.total_employees())  # 0
e1 = Employee("Ali")
e2 = Employee("Sara")
print(Employee.total_employees())  # 2

2. Static Methods (`@staticmethod`)

What it is

A method inside the class but does NOT access class or instance data.

When used?

Utility/helper methods
Math or formatting functions

Example

class MathTool:
    @staticmethod
    def add(a, b):
        return a + b

print(MathTool.add(3, 4))

3. Dunder (Magic) Methods

These are special methods starting with __.
They let you customize how your object behaves.

Common ones

Magic method	Purpose
`__init__`	constructor
`__str__`	object to string
`__len__`	length
`__add__`	overloading + operator
`__getitem__`	indexing
`__call__`	make object callable

Example: custom print

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

    def __str__(self):
        return f"Person: {self.name}"

p = Person("Ali")
print(p)  # Person: Ali

4. Operator Overloading

Allows objects to behave like integers, lists, etc.

Example: add 2 bank accounts

class Account:
    def __init__(self, balance):
        self.balance = balance

    def __add__(self, other):
        return Account(self.balance + other.balance)

a1 = Account(500)
a2 = Account(700)

a3 = a1 + a2
print(a3.balance)  # 1200

5. Property Decorator (`@property`)

Allows you to create getter/setter like in Java but more elegant.

Example

class Product:
    def __init__(self, price):
        self._price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value >= 0:
            self._price = value
        else:
            raise ValueError("Price can't be negative")

Usage:

p = Product(100)
p.price = 200   # calls setter
print(p.price)  # calls getter

6. Inheritance + MRO (Method Resolution Order)

What MRO means

If a class inherits from multiple parents, Python follows a specific order to find methods.

Example

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

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

class C(A, B):
    pass

c = C()
c.show()  # A
print(C.mro())

C.mro() shows:

[C, A, B, object]

7. Abstract Classes (Interfaces in Python)

Used to force child classes to implement certain methods.

Example

from abc import ABC, abstractmethod

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

class CardPayment(Payment):
    def pay(self):
        print("Payment via card")

8. Composition (HAS-A relationship)

Instead of inheritance (IS-A), we combine objects.

Real-life

A Car has an Engine.

Example

class Engine:
    def start(self):
        print("Engine starting...")

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

    def start(self):
        self.engine.start()

c = Car()
c.start()

9. Duck Typing

Python doesn’t care about the type — only if the object has the required behavior.

Example

class Dog:
    def speak(self): print("Woof")

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

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

If it acts like a duck, Python treats it as a duck.

10. Making Objects Callable — `call`

Allows objects to be used like functions.

Example

class Multiply:
    def __init__(self, n):
        self.n = n

    def __call__(self, x):
        return x * self.n

double = Multiply(2)
print(double(10))  # 20

PyTorch uses this heavily for layers & transforms.

11. Metaclasses (Advanced-Advanced)

Metaclasses = classes that create classes.

For example:

class Meta(type):
    def __new__(cls, name, bases, dct):
        print("Creating class:", name)
        return super().__new__(cls, name, bases, dct)

class Test(metaclass=Meta):
    pass

This prints when the class is created.
You rarely need metaclasses until deep framework work.

12. Practical Real-World Example (ML Style)

Here’s how PyTorch builds neural network layers using OOP:

class LinearLayer:
    def __init__(self, input_dim, output_dim):
        self.weights = [[0]*output_dim for _ in range(input_dim)]
        self.bias = [0]*output_dim

    def __call__(self, x):
        # forward pass (simplified)
        return "output vector"

This uses:

constructor
composition
magic method (__call__)

⭐ Mini Exercises (Advanced)

Send your answers and I’ll review.

1. Create a class `Rectangle`

attributes: width, height
property: area (read-only using @property)
overload + to add two rectangles by area

2. Create a class `Temperature`

stores Celsius
provide setter/getter
convert to Fahrenheit using a method

3. Create a class `Logger`

keep count of total logs (use @classmethod)
method: log(message) → prints message
property: total_logs

4. Show an example where composition is better than inheritance.

5. PYTHON ESSENTIALS FOR AI/ML (List & Dictionary Comprehensions)

M.T.Ramkrushna — Thu, 27 Nov 2025 12:34:16 +0000

🛒 1. What Are Comprehensions?

Comprehensions are a compact and expressive way to create lists and dictionaries.

Instead of writing long loops, you write everything in one clean line.

Classic loop vs comprehension

Without comprehension:

squares = []
for n in range(1, 6):
    squares.append(n*n)

With comprehension:

squares = [n*n for n in range(1, 6)]

Cleaner, faster, more readable.

🍫 2. List Comprehension (Core Formula)

General pattern

[new_item   for item in iterable   if condition]

Visual

Imagine you have a conveyor belt of items.
Comprehension → picks items → maybe filters → transforms → outputs a new list.

🥤 3. Real-Life Examples (Very Relatable)

🍟 Example 1: Filter items from a food list

Suppose you ordered a mixed snack bundle and want to keep only healthy items.

foods = ["chips", "salad", "pizza", "fruits"]

healthy = [f for f in foods if f in ["salad", "fruits"]]
print(healthy)   # ['salad', 'fruits']

🎧 Example 2: Increase volume of all songs

Imagine a music app increases the volume of every song by 10%.

volumes = [40, 60, 80]
new_volumes = [v + 10 for v in volumes]

🛍️ Example 3: Add “₹” symbol to all prices

You grab prices from a website:

prices = [200, 450, 1200]

formatted = [f"₹{p}" for p in prices]

🚗 Example 4: Extract only electric cars

cars = [
    {"model": "Tesla", "type": "EV"},
    {"model": "BMW", "type": "Petrol"},
    {"model": "Tata Nexon", "type": "EV"}
]

ev_models = [car["model"] for car in cars if car["type"] == "EV"]
print(ev_models)  # ['Tesla', 'Tata Nexon']

🧮 4. Nested List Comprehension

🎒 Example: Flatten a list of student groups

groups = [[1, 2], [3, 4], [5, 6]]

flat = [student for group in groups for student in group]
print(flat)  # [1, 2, 3, 4, 5, 6]

Think of unzipping multiple packets into one tray.

🗃️ 5. Dictionary Comprehensions

Structure:

{key: value   for item in iterable   if condition}

🧾 6. Real-Life Dictionary Examples

📦 Example 1: Price after discount

You have a price list and want to apply 10% discount.

prices = {"shoes": 2000, "shirt": 1200, "watch": 5000}

discounted = {item: price*0.9 for item, price in prices.items()}

📱 Example 2: Count lengths of all usernames

users = ["ali", "coder_123", "sara"]

length_map = {u: len(u) for u in users}

⭐ Example 3: Create mapping of product → “In Stock”/“Low Stock”

stock = {"laptop": 5, "mouse": 0, "keyboard": 2}

status = {
    item: ("In Stock" if qty > 0 else "Out of Stock")
    for item, qty in stock.items()
}

🧩 7. Combined Example

(Super realistic & used in ML/Data)

🧪 Convert a list of temperatures into a dict

temps = [28, 31, 36]

weather = {t: "Hot" if t > 30 else "Cool" for t in temps}

🏁 8. When to Use Comprehensions

✔ transforming data
✔ filtering data
✔ flattening lists
✔ building dicts from large datasets
✔ feature preprocessing in ML

Avoid when:
✘ The logic becomes too long or unreadable
✘ Multiple if/loops make it messy
(then use normal loops)

🧪 9. Mini Exercises (Try These!)

Send me your answers — I’ll check and correct if needed.

Exercise 1

Create a new list of squares from 1 to 20 only for even numbers.

Exercise 2

Given a list of names, create a dict → name → uppercase version.

Exercise 3

You have this dict:

products = {"mouse": 500, "laptop": 60000, "usb": 200}

Create a new dict where:

items > 1000 become “Expensive”
else “Cheap”

Exercise 4

Flatten this list using comprehension:

matrix = [[1,2,3], [4,5,6]]