DEV Community: M.T.Ramkrushna

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]]

3. PYTHON ESSENTIALS FOR AI/ML (OOP)

M.T.Ramkrushna — Wed, 26 Nov 2025 14:10:34 +0000

🟦 1. What is OOP?

OOP = a way of organizing code around “objects.”
Objects = things that have properties (data) and behaviors (functions).

Real-life analogy

A Car:

Properties → color, speed, brand
Behaviors → start(), stop(), accelerate()

In OOP, you'd define a Car class and create many cars (objects/instances) from it.

🟦 2. Class & Object

✔ Class

A class is a blueprint — like a recipe.

✔ Object

An object is the actual thing created from that blueprint.

Example:

class Car:
    pass

my_car = Car()   # object

🟦 3. Attributes (Variables inside objects)

Attributes store data about the object.

Example:

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

my_car = Car("Tesla", "Red")
print(my_car.brand)   # Tesla
print(my_car.color)   # Red

Real-life analogy

__init__() = when you build a car at the factory → you set brand, color, model.

🟦 4. Methods (Functions inside a class)

Methods define behaviors of objects.

class Car:
    def __init__(self, brand):
        self.brand = brand

    def start(self):
        print(self.brand, "is starting...")

tesla = Car("Tesla")
tesla.start()

🟦 5. The `self` keyword

self refers to the current object.

Real-life analogy:
Think of “my own” — my color, my brand, my speed.

🟦 6. Encapsulation (Hiding data)

We keep some data private to protect it.

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # private

    def get_balance(self):
        return self.__balance

You cannot directly access __balance from outside.
This prevents accidental misuse — like ATM preventing direct access to internal cash counters.

🟦 7. Inheritance (Child class getting features of parent class)

Just like:

Dog 🐶 and Cat 🐱 inherit from Animal

Example:

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

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

d = Dog()
d.speak()    # Dog barks

Real-life analogy:
A child inherits features from parent → height, hair color, etc.

🟦 8. Polymorphism (Same method name, different behavior)

Example:

class Bird:
    def fly(self):
        print("Bird is flying")

class Airplane:
    def fly(self):
        print("Airplane is flying")

for obj in [Bird(), Airplane()]:
    obj.fly()

Real life:
“drive()” means different things for:

car
bike
truck

🟦 9. Abstraction (Show only important things, hide details)

Real-life example:
When you drive a car, you don’t see the engine or circuits — only steering & pedals.

In code, abstraction hides complexity.

Example using abstract class:

from abc import ABC, abstractmethod

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

🟦 10. Full Real-Life Example — ATM System

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
            return "Withdraw successful"
        return "Insufficient funds"

    def get_balance(self):
        return self.__balance


# Creating objects
ali_acc = BankAccount("Ali", 5000)
sara_acc = BankAccount("Sara", 7000)

print(ali_acc.withdraw(2000))
print(sara_acc.deposit(1000))
print(ali_acc.get_balance())

This example uses:
✔ attributes
✔ private variables
✔ methods
✔ constructor
✔ encapsulation

🟦 11. Mini Exercises (Your turn!)

💡 Send me your code and I’ll review it!

1. Create a class `Student`

With attributes:

name
age
marks

Add method:

is_pass() → returns True if marks > 40.

2. Create a class `Car`

Attributes: brand, speed
Methods: accelerate(), brake()

3. Create two classes

Animal (parent)
Dog (child) — override a speak() method

2. PYTHON ESSENTIALS FOR AI/ML (Data Types)

M.T.Ramkrushna — Tue, 25 Nov 2025 17:19:44 +0000

🚀 1. Basic Data Types

🔹 int → Whole numbers

age = 25

Real-life analogy

Counting cricket runs: 1, 2, 4, 6.

ML use-case

Storing epochs, batch size, etc.

🔹 float → Decimal numbers

learning_rate = 0.001

Real-life analogy

Measuring petrol in liters: 1.5 L.

ML use-case

Model metrics: accuracy = 92.57, loss = 0.024

🔹 bool → True/False

is_training = True

Real-life analogy

Switch ON/OFF.

ML use-case

Checking if model is in training or evaluation mode.

🔹 str → Text

name = "Ali"

Real-life analogy

Your WhatsApp message.

ML use-case

Text datasets for NLP models.

🚀 2. List → Ordered, changeable (mutable), allows duplicates

fruits = ["apple", "banana", "mango"]

✔ Properties

Ordered
Mutable (you can change elements)
Allows duplicates

✔ Real-life analogy

A shopping list → you can rearrange, add, remove items.

✔ Operations

fruits.append("orange")
fruits[1] = "grapes"
print(fruits)

✔ ML use-case

Storing multiple predictions:

preds = [0.1, 0.4, 0.8, 0.3]

🚀 3. Tuple → Ordered, NOT changeable (immutable), allows duplicates

point = (3, 5)

✔ Properties

Ordered
Immutable
Fast
Allows duplicates

✔ Real-life analogy

Your Aadhaar details — once fixed, cannot modify easily.

✔ ML use-case

Coordinates in feature space (x, y), image pixel shape:

shape = (224, 224, 3)

✔ Why use tuple?

Faster than list
Safe from accidental modification

🚀 4. Set → Unordered, unique elements only, no duplicates

unique_ids = {101, 102, 103}

✔ Properties

Unordered
Only unique items
Super fast for membership test (in)

✔ Real-life analogy

Your Instagram followers list automatically removes duplicates.

✔ ML use-case

Getting unique labels/class names:

labels = set(["cat", "dog", "cat", "mouse"])

Output:

{'cat', 'dog', 'mouse'}

🚀 5. Dictionary (dict) → Key–value pairs

student = {"name": "Ali", "age": 22}

✔ Properties

Key–value mapping
Fast lookup
Ordered (Python 3.7+)

✔ Real-life analogy

A contact list:

"Maa" → 9876543210
"Papa" → 1234567890

✔ Operations

student["age"] = 23
student["city"] = "Nashik"

✔ ML use-case

Hyperparameters:

config = {
    "learning_rate": 0.001,
    "batch_size": 32,
    "optimizer": "adam"
}

🔥 Side-by-side summary table

Type	Ordered	Mutable	Allows duplicates	Example
list	✔	✔	✔	`[1, 2, 3]`
tuple	✔	✘	✔	`(1, 2, 3)`
set	✘	✔	✘	`{1, 2, 3}`
dict	✔ (keys)	✔	Keys unique	`{"a":1}`

🧠 Mini Exercises (Try these)

Q1

Create a list of 5 movies and replace the 3rd one.

Q2

Convert this list to a set:

nums = [1, 2, 2, 3, 4, 4, 5]

Q3

Create a dictionary for a model config with keys:

model_name
epochs
lr
optimizer

Q4

Why would you use a tuple instead of a list?

1. 🚀 PYTHON ESSENTIALS FOR AI/ML (Variables Loops Functions)

M.T.Ramkrushna — Tue, 25 Nov 2025 17:17:16 +0000

1️⃣ Variables

✔ Quick explanation

A variable is a name that stores a value in memory so you can reuse it.

✔ Real-life analogy

Think of a tiffin box with a label:

Label = variable name
Food inside = value

You can change the food anytime; the label stays.

✔ Syntax

x = 10
name = "Ali"
price = 99.5
is_active = True

✔ Real-life ML example

When training a model:

learning_rate = 0.001
epochs = 20
batch_size = 32

✔ Important note

Python decides the data type automatically.

2️⃣ Loops

Loops help you repeat tasks without writing repeated code.

🔹 for loop

Used when you know how many times to repeat.

Example

fruits = ["apple", "banana", "mango"]
for f in fruits:
    print(f)

Output:

apple
banana
mango

Real-life analogy

You check every message in WhatsApp one by one → a loop.

ML example

Looping through data batches:

for batch in data_loader:
    train(batch)

🔹 while loop

Used when you don’t know how many times but want to repeat until a condition becomes false.

Example

count = 1
while count <= 5:
    print(count)
    count += 1

Real-life analogy

You keep scrolling Instagram until your battery is dead.
"Bhai jab tak battery > 0, loop chalta rahega."

3️⃣ Functions

Functions are reusable blocks of code.

✔ Why functions?

Avoid repeating code
Keep logic clean & modular
Essential for ML pipeline (data cleaning, model training, evaluation)

✔ Syntax

def greet(name):
    return "Hello " + name

Using it:

print(greet("Ali"))

Real-life example

You cook maggi in a fixed process:

Boil water
Add masala
Add noodles
Serve

This whole process is a function.

ML example

def train_model(model, data, epochs):
    for epoch in range(epochs):
        model.train(data)

🔥 Putting it all together

def square_numbers(nums):
    result = []                 # variable (list)
    for n in nums:              # for loop
        result.append(n*n)
    return result               # function output

numbers = [2, 3, 5]
print(square_numbers(numbers))

Output:

[4, 9, 25]

⚠ Common Mistakes

Missing indentation (Python is strict).
Forgetting : after loops & function definitions.
Wrong variable names like 1var (names cannot start with a number).
Infinite while loops (while True: without break).

🧠 Mini Quiz

Try to answer mentally.

Q1

What will this print?

x = 5
while x < 8:
    print(x)
    x = x + 1

Q2

Write a function that returns the cube of a number.

Q3

What type of loop would you use to train a model until loss < 0.01?