Forem: M.T.Ramkrushna

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?

🚀 The Only Git Cheat Sheet Every Developer Should Know (With One-Line Use Cases)

M.T.Ramkrushna — Mon, 24 Nov 2025 12:45:35 +0000

🔧 Getting Started

git init — Create a new Git repository in the current folder.
git clone <url> — Download a repository from GitHub/GitLab to your machine.
git config --global user.name "Your Name" — Set your Git username.
git config --global user.email "example@mail.com" — Set your Git email.

📌 Daily Workflow Commands

git status — Show which files are modified or staged.
git add <file> — Stage a specific file for commit.
git add . — Stage all modified files.
git commit -m "message" — Save staged changes with a message.
git push — Upload your commits to the remote repository.
git pull — Fetch & merge the latest changes from remote.

🌿 Branching Essentials

git branch — List all local branches.
git branch <name> — Create a new branch.
git checkout <branch> — Switch to a specific branch.
git checkout -b <branch> — Create a branch and switch to it.
git merge <branch> — Merge the given branch into your current branch.

✂️ Deleting Branches

git branch -d <branch> — Delete a branch that’s fully merged.
git branch -D <branch> — Force delete an unmerged branch.

♻️ Fixing Mistakes & Undoing Changes

🔄 Undo Changes

git restore <file> — Discard local modifications in a file.
git restore --staged <file> — Unstage a file while keeping changes.

🛑 Abort a Merge

git merge --abort — Cancel an ongoing merge and revert to previous state.

✏️ Edit Last Commit Message

git commit --amend — Modify the message of the latest commit.

⏪ Undoing Commits (Reset, Revert)

🔙 Reset (Go Back in History)

git reset --soft HEAD~1 — Undo last commit but keep changes staged.
git reset --mixed HEAD~1 — Undo last commit, keep changes unstaged.
git reset --hard HEAD~1 — Undo last commit and delete changes forever.
git reset --hard origin/<branch> — Reset your local branch to match remote.

🔄 Revert (Safe Undo)

git revert <commit> — Create a new commit that reverses a previous one.

🧽 Squashing & Cleaning Commit History

Squash Multiple Commits

git rebase -i HEAD~<n>

→ Then change pick → squash for the commits you want to merge into one.

Quick Squash Last 2 Commits

git reset --soft HEAD~2
git commit -m "single squashed commit"

This is perfect when you want to clean your history before pushing a feature branch.

📜 Viewing History & Differences

git log — Show full commit history.
git log --oneline — Display a compact commit list.
git diff — View uncommitted changes.
git diff --staged — See diff for staged changes.

🌐 Working with Remote Repositories

git remote -v — View linked remotes.
git remote add origin <url> — Connect your local repo to a remote.
git push -u origin <branch> — Push a new branch and set tracking.

💡 Bonus: Life-Saving Commands You’ll Use Often

git stash — Save your changes temporarily without committing.
git stash pop — Restore the stashed changes.
git cherry-pick <commit> — Copy a specific commit onto current branch.
git pull --rebase — Pull updates without creating merge commits.
git fetch — Get updates from remote without merging.

Forem: M.T.Ramkrushna

PYTHON ESSENTIALS FOR AI/ML (Virtual Environment)

🚀 What is a Virtual Environment?

Real-life analogy:

🚀 Why Do We Need Virtual Environments?

1️⃣ Avoid Version Conflicts

2️⃣ Consistent Setups

3️⃣ Keeps System Clean

🚀 Virtual Environment Options

✔ venv

✔ conda

🚀 Using venv (Built-in Python)

🛠 Step 1: Create venv

🛠 Step 2: Activate

Windows

Mac/Linux

🛠 Step 3: Install packages

🛠 Step 4: Deactivate

🚀 Using Conda Environments (Recommended for ML)

🛠 Step 1: Create environment

🛠 Step 2: Activate

🛠 Step 3: Install packages

🛠 Step 4: Deactivate

🚀 Visual Explanation (ASCII)

How system looks WITHOUT virtual env:

How system looks WITH virtual env:

🚀 Real-Life Examples

✔ Example 1: Working on 2 AI Projects

✔ Example 2: Deploying a Backend Using venv

✔ Example 3: Keeping experiments isolated

🚀 Bonus: Requirements Files

🚀 Quick Summary

PYTHON ESSENTIALS FOR AI/ML(Error Handling)

⚡ What is Error Handling?

⚡ Types of Errors in Python

1️⃣ Syntax Errors

2️⃣ Runtime Errors (Exceptions)

3️⃣ Logical Errors

⚡ The try / except Block

⚡ Catching Specific Exceptions (best practice)

⚡ else Block (runs when no error occurs)

⚡ finally Block (ALWAYS runs)

⚡ Raising Your Own Errors (raise)

⚡ Custom Exceptions

⚡ Real-Life Relatable Examples

✔ Example 1: ATM Machine

✔ Example 2: AI Model Loading (ML Example)

✔ Example 3: Reading JSON Config

⚡ Quick Summary (for memory)

PYTHON ESSENTIALS FOR AI/ML(Working With Files)

📂 1. Why File Handling Matters

📄 2. Opening a File (open())

Basic syntax:

Modes you must know:

Real-life analogy

✍️ 3. Writing to a File

Example: saving user notes

Append mode

📖 4. Reading a File

Reading the whole file

Reading line by line

🔐 5. Important: Always Close the File

Best practice: use with (autoclose)

📦 6. Real-Life Examples

🧾 Example 1: Saving user logs

📊 Example 2: Saving model predictions

🙋 Example 3: Counting how many lines in a dataset

🧃 7. Reading CSV Files (Without Pandas)

Real-life use: loading small datasets

🧱 8. Writing to CSV Files

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

Write JSON

Read JSON

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

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

Check if file exists

Delete a file

List all files

🧪 12. Mini Exercises (Do these!)

Exercise 1

⚡ The `try / except` Block

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

⚡ `finally` Block (ALWAYS runs)

⚡ Raising Your Own Errors (`raise`)

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

Best practice: use `with` (autoclose)

1. Class Methods (`@classmethod`)

2. Static Methods (`@staticmethod`)

5. Property Decorator (`@property`)

10. Making Objects Callable — `call`

1. Create a class `Rectangle`

2. Create a class `Temperature`

3. Create a class `Logger`