DEV Community: Akhilesh

Build a Data Processor: Your First Real Python Project

Akhilesh — Wed, 22 Apr 2026 05:34:05 +0000

You have been learning individual tools for fourteen posts.

Variables. Loops. Functions. Classes. Files. Error handling. Modules. All separate. All practiced in isolation.

Now you stop practicing in isolation.

This post is a real project. Not a toy example. A complete data processing program that reads student records from a CSV file, cleans the data, calculates statistics, finds the top performers, flags who failed, and writes a summary report. Every piece of Python you learned gets used here.

This is what it feels like when the tools click together.

What We Are Building

A student grade processor. Here is exactly what it does:

Reads a CSV file with student names and exam scores. Cleans it by removing invalid entries, empty rows, scores that are not numbers. Calculates the class average, highest score, lowest score, and pass rate. Identifies top performers (above 85) and students who failed (below 40). Writes a clean summary report to a text file. Handles any file errors gracefully.

By the end you will have a program you could actually hand to a teacher and they could use it.

Step 1: Create the Data File

First create students.csv in your project folder. Copy this exactly:

name,score
Alex,92
Priya,78
Sam,
Jordan,61
Lisa,45
Ravi,88
null,55
Tom,102
Maya,73
Arjun,34
Zara,91
Ben,abc
Carlos,67
Nina,39
Oscar,85

This data is intentionally messy. Sam has no score. The name "null" is clearly not a real student. Tom's score of 102 is impossible (assume max is 100). Ben's score is "abc" which is not a number. Your program needs to handle all of this without crashing.

Step 2: Build the Loader

Create grade_processor.py.

Start with the function that reads the file.

import csv
import json
from datetime import datetime


def load_students(filename):
    students = []

    try:
        with open(filename, "r") as file:
            reader = csv.DictReader(file)
            for row in reader:
                students.append({
                    "name": row["name"],
                    "score": row["score"]
                })
    except FileNotFoundError:
        print(f"Error: {filename} not found.")
        return []

    print(f"Loaded {len(students)} raw records.")
    return students

csv.DictReader reads each row as a dictionary where column names are the keys. So each row becomes {"name": "Alex", "score": "92"}. Notice scores come in as strings. You will convert them in the next step.

Step 3: Clean the Data

Raw data is never trustworthy. Write a function that rejects bad records and explains why.

def clean_students(students):
    clean = []
    rejected = []

    for student in students:
        name = student["name"].strip()
        score_raw = student["score"].strip()

        if not name or name.lower() == "null":
            rejected.append(f"Skipped: invalid name '{name}'")
            continue

        if not score_raw:
            rejected.append(f"Skipped: {name} has no score")
            continue

        try:
            score = float(score_raw)
        except ValueError:
            rejected.append(f"Skipped: {name} has non-numeric score '{score_raw}'")
            continue

        if score < 0 or score > 100:
            rejected.append(f"Skipped: {name} has out-of-range score {score}")
            continue

        clean.append({"name": name, "score": score})

    print(f"\nCleaning complete:")
    print(f"  Valid records: {len(clean)}")
    print(f"  Rejected: {len(rejected)}")
    for reason in rejected:
        print(f"  {reason}")

    return clean

Every rejection has a reason. You are not silently dropping bad data. You are tracking what got removed and why. In real data work, you always want to know what you lost.

Step 4: Analyze the Data

Now that the data is clean, calculate everything useful.

def analyze(students):
    if not students:
        print("No valid students to analyze.")
        return None

    scores = [s["score"] for s in students]

    total = len(scores)
    average = sum(scores) / total
    highest = max(scores)
    lowest = min(scores)
    passed = [s for s in students if s["score"] >= 40]
    failed = [s for s in students if s["score"] < 40]
    top_performers = [s for s in students if s["score"] >= 85]

    results = {
        "total_students": total,
        "average_score": round(average, 2),
        "highest_score": highest,
        "lowest_score": lowest,
        "pass_count": len(passed),
        "fail_count": len(failed),
        "pass_rate": round((len(passed) / total) * 100, 1),
        "top_performers": sorted(top_performers, key=lambda s: s["score"], reverse=True),
        "failed_students": sorted(failed, key=lambda s: s["score"]),
        "all_students": sorted(students, key=lambda s: s["score"], reverse=True)
    }

    return results

List comprehensions, lambda sorting, basic math, all from previous posts, all working together here doing real work.

Step 5: Display the Results

Print a clean, readable summary to the terminal.

def display_results(results):
    if not results:
        return

    print("\n" + "=" * 45)
    print("        STUDENT GRADE REPORT")
    print("=" * 45)

    print(f"\nTotal Students : {results['total_students']}")
    print(f"Class Average  : {results['average_score']}")
    print(f"Highest Score  : {results['highest_score']}")
    print(f"Lowest Score   : {results['lowest_score']}")
    print(f"Pass Rate      : {results['pass_rate']}%")
    print(f"Passed         : {results['pass_count']}")
    print(f"Failed         : {results['fail_count']}")

    print("\n--- Top Performers (85+) ---")
    if results["top_performers"]:
        for s in results["top_performers"]:
            print(f"  {s['name']:<15} {s['score']}")
    else:
        print("  None")

    print("\n--- Students Who Failed (<40) ---")
    if results["failed_students"]:
        for s in results["failed_students"]:
            print(f"  {s['name']:<15} {s['score']}")
    else:
        print("  None")

    print("\n--- Full Rankings ---")
    for i, s in enumerate(results["all_students"], 1):
        status = "PASS" if s["score"] >= 40 else "FAIL"
        print(f"  {i}. {s['name']:<15} {s['score']:<8} {status}")

    print("=" * 45)

{s['name']:<15} left-aligns the name in a 15-character field. Columns line up. Output looks professional, not like a pile of print statements.

Step 6: Save the Report

Write everything to a file so it can be shared.

def save_report(results, filename="report.txt"):
    if not results:
        return

    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    try:
        with open(filename, "w") as file:
            file.write(f"Grade Report - Generated {timestamp}\n")
            file.write("=" * 45 + "\n\n")
            file.write(f"Total Students : {results['total_students']}\n")
            file.write(f"Class Average  : {results['average_score']}\n")
            file.write(f"Highest Score  : {results['highest_score']}\n")
            file.write(f"Lowest Score   : {results['lowest_score']}\n")
            file.write(f"Pass Rate      : {results['pass_rate']}%\n\n")

            file.write("Top Performers:\n")
            for s in results["top_performers"]:
                file.write(f"  {s['name']}: {s['score']}\n")

            file.write("\nFull Rankings:\n")
            for i, s in enumerate(results["all_students"], 1):
                status = "PASS" if s["score"] >= 40 else "FAIL"
                file.write(f"  {i}. {s['name']}: {s['score']} - {status}\n")

        print(f"\nReport saved to {filename}")

    except IOError as e:
        print(f"Could not save report: {e}")

Step 7: Wire It All Together

The main block that runs when you execute the file.

def main():
    print("Starting Grade Processor...")
    print("-" * 45)

    raw_students = load_students("students.csv")

    if not raw_students:
        print("Nothing to process.")
        return

    clean = clean_students(raw_students)

    if not clean:
        print("No valid data after cleaning.")
        return

    results = analyze(clean)
    display_results(results)
    save_report(results)

    print("\nDone.")


if __name__ == "__main__":
    main()

if __name__ == "__main__": means: only run main() if this file is executed directly. If another file imports this file, main() will not run automatically. This is a standard Python pattern you will see everywhere.

Run It

python grade_processor.py

Output should look like:

Starting Grade Processor...
---------------------------------------------
Loaded 15 raw records.

Cleaning complete:
  Valid records: 11
  Rejected: 4
  Skipped: Sam has no score
  Skipped: invalid name 'null'
  Skipped: Tom has out-of-range score 102.0
  Skipped: Ben has non-numeric score 'abc'

=============================================
        STUDENT GRADE REPORT
=============================================

Total Students : 11
Class Average  : 68.36
Highest Score  : 92.0
Lowest Score   : 34.0
Pass Rate      : 81.8%
Passed         : 9
Failed         : 2

--- Top Performers (85+) ---
  Alex            92.0
  Zara            91.0
  Ravi            88.0
  Oscar           85.0

--- Students Who Failed (<40) ---
  Arjun           34.0
  Nina            39.0

--- Full Rankings ---
  1. Alex            92.0     PASS
  2. Zara            91.0     PASS
  3. Ravi            88.0     PASS
  ...
=============================================

Report saved to report.txt

Done.

Now Break It and Extend It

This is where real learning happens. Try all of these:

Delete students.csv and run it. Does it handle the missing file gracefully?

Add five more students directly to the CSV, some with valid scores, some without.

Change the pass mark from 40 to 50 and see who moves from pass to fail.

Add a new function called get_grade_letter that converts a numeric score to A, B, C, D, or F and include the letter grade in the report.

Add a function that groups students by grade letter and shows how many are in each group.

What Just Happened

You used every major concept from Phase 1 in one project.

Functions to organize logic. Classes were not needed here but the project structure mirrors how you would use them. File I/O to read the CSV and write the report. Error handling to catch bad files and bad data. List comprehensions to filter and transform. Lambda for sorting. Modules for csv, datetime, json. f-strings throughout.

Nothing in this project was new. It was all tools you already had. The project just showed you what they look like when they work together.
It starts with the most important question: what does math actually do in AI, and how much of it do you really need to know?

Decorators: The Python Feature That Looks Like Magic

Akhilesh — Tue, 21 Apr 2026 10:41:22 +0000

Something has been quietly happening in code you have never written yet.

Every time you use FastAPI to build an endpoint, you will write this:

@app.get("/users")
def get_users():
    return users

Every time you time how long a function takes, people write this:

@timer
def train_model():
    ...

Every time Flask defines a route, every time you cache a result, every time you check if a user is logged in before running a function, that @ symbol is right there at the top.

You have probably seen it and moved past it. Today you stop moving past it.

Start With a Problem

Imagine you have three functions and you want to print how long each one takes to run.

import time

def load_data():
    time.sleep(1)
    print("Data loaded")

def train_model():
    time.sleep(2)
    print("Model trained")

def save_results():
    time.sleep(0.5)
    print("Results saved")

The obvious approach: add timing code to each function.

def load_data():
    start = time.time()
    time.sleep(1)
    print("Data loaded")
    end = time.time()
    print(f"load_data took {end - start:.2f} seconds")

Repeat that for all three. Now your timing logic is copy-pasted everywhere. If you want to change the format of the timer message, you change it in three places. When you add a fourth function, you copy it again.

There is a better way.

Functions Can Receive Other Functions

Before decorators make sense, you need to see one thing. In Python, functions are just values. You can pass a function to another function the same way you pass a number or a string.

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

def run_twice(func):
    func()
    func()

run_twice(say_hello)

Output:

Hello!
Hello!

say_hello got passed into run_twice as an argument. run_twice called it twice. The function is just a value that happens to be callable.

Functions Can Return Other Functions

This is the piece that makes decorators possible.

def make_greeting(language):
    def greet(name):
        if language == "english":
            print(f"Hello, {name}!")
        elif language == "hindi":
            print(f"Namaste, {name}!")
    return greet

english_greet = make_greeting("english")
hindi_greet = make_greeting("hindi")

english_greet("Alex")
hindi_greet("Priya")

Output:

Hello, Alex!
Namaste, Priya!

make_greeting returns a function. Not the result of calling a function. The function itself. english_greet is now a function that says hello in English. hindi_greet is a function that says hello in Hindi.

A function that creates and returns another function. Hold that thought.

Building a Decorator by Hand

Now combine both ideas. Take a function in. Create a new function that wraps it. Return the new function.

import time

def timer(func):
    def wrapper():
        start = time.time()
        func()
        end = time.time()
        print(f"{func.__name__} took {end - start:.2f} seconds")
    return wrapper

timer takes a function. Creates wrapper which runs the original function sandwiched between timing code. Returns wrapper.

Use it:

def load_data():
    time.sleep(1)
    print("Data loaded")

load_data = timer(load_data)
load_data()

Output:

Data loaded
load_data took 1.00 seconds

load_data = timer(load_data) replaces the original load_data with the wrapped version. Now every call to load_data runs the timer automatically.

This is manually decorating a function. Works perfectly.

The @ Syntax Is Just Shorthand

Python gives you a cleaner way to write exactly that.

@timer
def load_data():
    time.sleep(1)
    print("Data loaded")

This is identical to:

def load_data():
    time.sleep(1)
    print("Data loaded")

load_data = timer(load_data)

The @timer above the function is Python saying: take this function, pass it through timer, and replace it with whatever comes back. Same operation, cleaner syntax.

Now apply it to all three functions:

@timer
def load_data():
    time.sleep(1)
    print("Data loaded")

@timer
def train_model():
    time.sleep(2)
    print("Model trained")

@timer
def save_results():
    time.sleep(0.5)
    print("Results saved")

load_data()
train_model()
save_results()

Output:

Data loaded
load_data took 1.00 seconds
Model trained
train_model took 2.00 seconds
Results saved
save_results took 0.50 seconds

Timing logic written once. Applied to three functions with one line each. Change the timer format once and it updates everywhere.

Handling Functions With Arguments

The timer above only works on functions with no arguments. Real functions take parameters.

import time
from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

*args captures any positional arguments. **kwargs captures any keyword arguments. Together they handle any function signature. Whatever you pass to the decorated function gets forwarded to the original.

@wraps(func) preserves the original function's name and documentation. Without it, every decorated function would show up as wrapper when you inspect it.

return result passes back whatever the original function returned.

This is the proper production-ready decorator shape. Use this version always.

@timer
def add_numbers(a, b):
    time.sleep(0.1)
    return a + b

result = add_numbers(5, 3)
print(f"Result: {result}")

Output:

add_numbers took 0.1002 seconds
Result: 8

A Decorator You Will Actually Use

Logging. Know when a function was called and with what arguments.

from functools import wraps

def log(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args={args} kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

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

multiply(4, 5)
multiply(10, 3)

Output:

Calling multiply with args=(4, 5) kwargs={}
multiply returned 20
Calling multiply with args=(10, 3) kwargs={}
multiply returned 30

Add @log to any function and you instantly see every call with its inputs and outputs. Remove it and all the logging disappears. The function is untouched.

This is the real power. Behavior added and removed without touching the original function.

Try This

Create decorators_practice.py.

Write a decorator called validate_positive that checks all the arguments passed to a function. If any argument is zero or negative, it prints an error message and returns None without calling the original function. If all arguments are positive, it calls the function normally and returns the result.

Test it on a function called calculate_area(length, width) that returns length * width.

Then write a second decorator called repeat that calls the decorated function three times in a row.

Apply repeat to a function called say_something(message) that just prints the message. Call it once and watch it print three times.

Phase 1 Is Done

That is all fifteen core Python concepts. Variables, types, conditions, loops, functions, lists, dictionaries, classes, files, errors, modules, comprehensions, lambda, map, filter, and now decorators.

You know enough Python to follow anything that comes next.

Phase 2 starts now. The math behind AI. Not theory for its own sake. The exact concepts your models use when they learn, the ones you need to understand so you know what is actually happening when you train a neural network.

Lambda, Map, and Filter: Functional Python Explained

Akhilesh — Tue, 21 Apr 2026 10:40:13 +0000

You know how to build lists with comprehensions now.

doubled = [n * 2 for n in numbers]
evens = [n for n in numbers if n % 2 == 0]

Clean. Readable. Good.

Now you are going to see the older way Python does the same things. Not because it is better. Because you will absolutely see this code in tutorials, libraries, and other people's projects. If you do not know what lambda, map, and filter are, that code will confuse you.

Lambda: A Function With No Name

A regular function needs a name, a def, parameters, a body, a return.

def double(n):
    return n * 2

A lambda is a function stripped to its bare minimum. No def. No name. No return keyword. Just the parameters and the expression.

double = lambda n: n * 2

Same thing. One line.

Call it exactly like a regular function.

print(double(5))
print(double(10))

Output:

10
20

The syntax is lambda parameters: expression. Whatever the expression evaluates to gets returned automatically.

Multiple parameters work too.

add = lambda a, b: a + b
print(add(3, 4))

Output:

When Lambda Makes Sense

Storing a lambda in a variable like double = lambda n: n * 2 is actually considered bad practice. If you are naming it, just use def. It is clearer.

Lambda earns its place when you need a small function right now, inline, without giving it a name. The most common case is passing a function as an argument to another function.

names = ["Priya", "Alex", "Jordan", "Sam"]
names.sort(key=lambda name: len(name))
print(names)

Output:

['Sam', 'Alex', 'Priya', 'Jordan']

sort accepts a key argument. It calls that function on each item and sorts by the result. The lambda lambda name: len(name) says: use the length of each name as the sort key.

You could write a named function for this. But why? The lambda is short, it is only used once, and it sits right where it is needed. This is exactly what lambdas are for.

Map: Transform Every Item

map applies a function to every item in an iterable and gives you back the transformed items.

numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda n: n * 2, numbers))
print(doubled)

Output:

[2, 4, 6, 8, 10]

map(function, iterable) takes a function and an iterable. It calls the function on each item. You wrap it in list() because map returns a lazy object, not a list directly. More on lazy evaluation another time.

Compare to the comprehension version:

doubled = [n * 2 for n in numbers]

Same result. Most Python developers today prefer the comprehension. It reads more naturally. But map shows up in older code and in some specific situations where it is genuinely cleaner.

names = ["alex", "priya", "sam"]
capitalized = list(map(str.capitalize, names))
print(capitalized)

Output:

['Alex', 'Priya', 'Sam']

Notice str.capitalize with no parentheses and no lambda. When the transformation is already a method, you can pass it directly without wrapping it. Clean.

Filter: Keep Only What Passes

filter keeps items where the function returns True and drops the rest.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = list(filter(lambda n: n % 2 == 0, numbers))
print(evens)

Output:

[2, 4, 6, 8, 10]

filter(function, iterable) calls the function on each item. Items where the function returns True make it through. Items where it returns False get dropped.

Comprehension equivalent:

evens = [n for n in numbers if n % 2 == 0]

Again, same result, different syntax. The comprehension is preferred in modern Python. But filter is there, it works, and you will see it.

Using a Real Function Instead of Lambda

Lambda is not required. Any function works.

def is_passing(score):
    return score >= 60

scores = [45, 92, 78, 34, 61, 88, 55]
passing = list(filter(is_passing, scores))
print(passing)

Output:

[92, 78, 61, 88]

When the condition is more than a one-liner, write a proper function and pass it in. Lambda is only convenient when the logic is simple enough to fit on one line.

Combining Map and Filter

You can chain them. Filter first to keep only the relevant items, then map to transform them.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

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

Output:

[4, 16, 36, 64, 100]

Filter keeps the even numbers. Map squares them. But honestly, look at that line. It is getting hard to read.

The comprehension version is cleaner:

result = [n ** 2 for n in numbers if n % 2 == 0]

Same output. One read. This is why most Python developers reach for comprehensions over map and filter by default.

Sorted With a Key

One place where lambda genuinely shines is sorted with a custom key.

students = [
    {"name": "Alex", "score": 92},
    {"name": "Priya", "score": 78},
    {"name": "Sam", "score": 85},
    {"name": "Jordan", "score": 61}
]

by_score = sorted(students, key=lambda s: s["score"], reverse=True)

for student in by_score:
    print(f"{student['name']}: {student['score']}")

Output:

Alex: 92
Sam: 85
Priya: 78
Jordan: 61

Sorting a list of dictionaries by one of the dictionary keys. The lambda grabs the score from each student dictionary. reverse=True puts highest first. This pattern comes up constantly in data work.

The Honest Summary

Lambda, map, and filter come from a style of programming called functional programming. Python supports this style but was not built around it the way some languages are.

In practice:

Use list comprehensions for most transformations and filters. They are more readable and more Pythonic.

Use lambda when you need a small throwaway function as an argument, especially for sorted, sort, max, and min with a custom key.

Use map and filter when you encounter them in existing code or when working with streams of data where the lazy evaluation matters.

Know all three because you will see all three.

Try This

Create functional_practice.py.

Start with this data:

products = [
    {"name": "Laptop", "price": 75000, "category": "Electronics"},
    {"name": "Shirt", "price": 800, "category": "Clothing"},
    {"name": "Headphones", "price": 3500, "category": "Electronics"},
    {"name": "Jeans", "price": 1500, "category": "Clothing"},
    {"name": "Phone", "price": 45000, "category": "Electronics"},
    {"name": "Jacket", "price": 4000, "category": "Clothing"}
]

Do all of this, once with lambda and map or filter, then again with a comprehension, and print both results to confirm they match:

Get a list of just the product names.

Get a list of products that cost more than 3000.

Get a list of all prices with a 10 percent discount applied.

Sort the entire products list by price from lowest to highest using sorted and a lambda key.

What's Next

One more post in Phase 1. Decorators. They look strange the first time you see them but the concept behind them is simple and they show up constantly in web frameworks, logging, authentication, and ML code. After that, Phase 1 is done and we move into the math that makes AI work.

Write a List in One Line (List Comprehensions)

Akhilesh — Mon, 20 Apr 2026 02:59:58 +0000

You have been building lists the long way.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
squares = []

for n in numbers:
    squares.append(n * n)

print(squares)

Output:

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Four lines. A variable, a loop, an operation, an append. This works perfectly. Nothing wrong with it.

But Python has a shorter way. One line instead of four.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
squares = [n * n for n in numbers]

print(squares)

Output:

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Same result. One line. This is a list comprehension.

Reading It Out Loud

The trick to understanding list comprehensions is reading them left to right like a sentence.

[n * n for n in numbers]

"Give me n * n for each n in numbers."

That's literally what it says. The expression comes first. Then the loop. Your brain wants the loop first because that's how you think about it as code. But the comprehension puts the result first, then explains where it comes from.

Take a minute with that. Once it clicks, it stays clicked.

The Basic Shape

[expression for variable in iterable]

expression is what you want in the new list. Can be anything. A calculation, a function call, a transformation.

variable is the loop variable. Same as for n in ....

iterable is what you're looping over. A list, a range, a string, anything.

names = ["alex", "priya", "sam", "jordan"]
upper_names = [name.upper() for name in names]
print(upper_names)

Output:

['ALEX', 'PRIYA', 'SAM', 'JORDAN']

lengths = [len(name) for name in names]
print(lengths)

Output:

[4, 5, 3, 6]

numbers = range(1, 6)
doubled = [n * 2 for n in numbers]
print(doubled)

Output:

[2, 4, 6, 8, 10]

Adding a Condition

You can filter which items make it into the new list.

[expression for variable in iterable if condition]

The if at the end acts as a filter. Only items where the condition is True get included.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = [n for n in numbers if n % 2 == 0]
print(evens)

Output:

[2, 4, 6, 8, 10]

Read it: "Give me n for each n in numbers, but only if n is even."

scores = [45, 92, 78, 61, 34, 88, 55, 97]
passing = [s for s in scores if s >= 60]
print(passing)

Output:

[92, 78, 61, 88, 97]

Six lines of loop code, one line of comprehension. Both do exactly the same thing. The comprehension just says it more directly.

Combining Both

Transform and filter at the same time.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
squared_evens = [n * n for n in numbers if n % 2 == 0]
print(squared_evens)

Output:

[4, 16, 36, 64, 100]

"Give me n * n for each n in numbers, but only if n is even." Even numbers are 2, 4, 6, 8, 10. Their squares are 4, 16, 36, 64, 100.

With Strings

List comprehensions work on anything iterable. Including strings themselves, since a string is just a sequence of characters.

sentence = "Hello World"
letters = [char for char in sentence if char != " "]
print(letters)

Output:

['H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd']

words = ["  hello  ", "  world  ", "  python  "]
cleaned = [w.strip() for w in words]
print(cleaned)

Output:

['hello', 'world', 'python']

Cleaning whitespace from a list of strings in one line. You'll do this constantly when processing real data.

Dictionary Comprehensions

Same idea, curly braces instead of square brackets, and you define both the key and the value.

names = ["Alex", "Priya", "Sam"]
name_lengths = {name: len(name) for name in names}
print(name_lengths)

Output:

{'Alex': 4, 'Priya': 5, 'Sam': 3}

scores = {"Alex": 92, "Priya": 58, "Sam": 75, "Jordan": 44}
passing = {name: score for name, score in scores.items() if score >= 60}
print(passing)

Output:

{'Alex': 92, 'Sam': 75}

Build a new dictionary from an existing one, filtered or transformed. Very clean.

When Not to Use Them

Comprehensions are great. They are not always the right choice.

If the logic inside is getting complex, a regular loop is clearer.

# getting hard to read
result = [process(transform(validate(x))) for x in data if check_one(x) and check_two(x)]

# clearer as a loop
result = []
for x in data:
    if check_one(x) and check_two(x):
        validated = validate(x)
        transformed = transform(validated)
        result.append(process(transformed))

The rule is readability. If someone can read the comprehension and understand it in three seconds, use it. If they have to stop and decode it, write a loop.

Try This

Create comprehensions_practice.py.

Start with this data:

temperatures_c = [0, 10, 20, 30, 40, 100]
words = ["Python", "is", "great", "for", "AI", "and", "ML"]
students = [
    {"name": "Alex", "score": 88},
    {"name": "Priya", "score": 52},
    {"name": "Sam", "score": 76},
    {"name": "Jordan", "score": 91},
    {"name": "Lisa", "score": 43}
]

Do all of this using comprehensions only, no regular loops:

Convert every temperature to Fahrenheit and store in a new list.

Build a list of words that are longer than 3 characters.

Build a list of just the names from the students list.

Build a list of just the names of students who passed (score 60 or above).

Build a dictionary mapping each student's name to their score.

What's Next

List comprehensions make your code shorter. The next post is about lambda functions and map and filter, which are different tools for similar problems. They come from a style of programming called functional programming and they show up constantly in data science code.

How Python Borrows Other People's Work

Akhilesh — Sun, 19 Apr 2026 18:43:46 +0000

You have been writing everything yourself from scratch.

Every function, every loop, every piece of logic. That is exactly right for learning. But out in the real world, nobody builds everything from zero.

Python has been around since 1991. In that time, developers have written and shared hundreds of thousands of packages. Tools for working with data. Tools for making web requests. Tools for generating random numbers. Tools for working with dates. Tools for training neural networks.

All of it free. All of it one command away.

Knowing how to find, install, and use other people's code is one of the most valuable skills you will develop. This post is where that starts.

The Standard Library: Already Installed

Python ships with a large collection of built-in modules called the standard library. You do not need to install them. They are already there.

import brings a module into your file.

import math

print(math.pi)
print(math.sqrt(16))
print(math.ceil(4.2))
print(math.floor(4.9))

Output:

3.141592653589793
4.0
5
4

math is a module. A module is just a Python file with useful functions inside it. When you write import math, Python finds that file and makes everything in it available under the math. prefix.

More Standard Library Modules Worth Knowing

import random

print(random.randint(1, 10))        # random integer between 1 and 10
print(random.choice(["a", "b", "c"]))   # random item from a list
numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)                       # list in random order

Output (yours will differ, it's random):

7
b
[3, 1, 5, 2, 4]

import datetime

today = datetime.date.today()
print(today)

now = datetime.datetime.now()
print(now)

Output:

2024-11-15
2024-11-15 14:32:07.482910

import os

print(os.getcwd())              # current working directory
files = os.listdir(".")         # list files in current folder
print(files)

os is important for file system work. Checking if paths exist, creating folders, listing directory contents. You'll use it a lot when building data pipelines.

Importing Specific Things

Sometimes you only need one function from a module. No need to import the whole thing.

from math import sqrt, pi

print(sqrt(25))
print(pi)

Output:

5.0
3.141592653589793

Now you call sqrt directly without math. in front. Cleaner for functions you use constantly.

You can also give imports a shorter name.

import numpy as np
import pandas as pd

You haven't installed these yet but when you do, this is how every single tutorial and professional uses them. np for NumPy. pd for Pandas. It is so universal that using any other name would confuse people reading your code.

pip: Installing Packages From the Internet

The standard library is big but it doesn't have everything. The Python Package Index, PyPI, hosts over 500,000 additional packages contributed by developers worldwide.

pip is the tool that downloads and installs them.

Open your terminal. Not inside Python. Your regular terminal or VS Code's integrated terminal.

pip install requests

That's it. Python downloads the requests package and installs it. Now you can use it in any Python file on your machine.

Try a few packages that you'll use constantly in this series.

pip install requests
pip install numpy
pip install pandas
pip install matplotlib

Each one downloads and installs. Takes a few seconds each.

Now use requests to make a real web request.

import requests

response = requests.get("https://api.github.com")
print(response.status_code)
print(type(response.json()))

Output:

200
<class 'dict'>

Your Python code just talked to GitHub's server and got a response back. Status code 200 means success. The response came back as a dictionary. Real data from the real internet.

Virtual Environments: Keep Projects Separate

Here is a problem that will bite you eventually.

Project A needs version 1.0 of some package. Project B needs version 2.0 of the same package. If you install packages globally, one of those projects breaks.

Virtual environments solve this. Each project gets its own isolated space with its own packages.

python -m venv myenv

This creates a folder called myenv with a complete isolated Python installation inside.

Activate it:

# Windows
myenv\Scripts\activate

# Mac and Linux
source myenv/bin/activate

Your terminal prompt changes to show the environment name. Now any pip install goes into that environment only, not the global Python.

When you're done:

deactivate

For every serious project you start from this series onward, create a virtual environment first. It is a small habit that prevents big headaches.

requirements.txt: Sharing Your Setup

When you share a project with someone or deploy it to a server, they need to know which packages to install.

requirements.txt is the standard way.

pip freeze > requirements.txt

This saves every installed package and its version to a text file. Open it and it looks like this:

numpy==1.26.0
pandas==2.1.1
requests==2.31.0
matplotlib==3.8.0

Anyone who gets your project runs one command to install everything at once:

pip install -r requirements.txt

Start doing this now. Even for small projects. It is a professional habit that costs nothing.

Writing Your Own Module

Any Python file you write is a module that other files can import.

Create a file called helpers.py:

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

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

PI = 3.14159

Now in a different file in the same folder:

import helpers

print(helpers.greet("Alex"))
print(helpers.add(5, 3))
print(helpers.PI)

Output:

Hello, Alex!
8
3.14159

Python found helpers.py in the same folder and imported everything from it. Your own reusable code, organized into modules, is how larger programs stay manageable.

Try This

Create modules_practice.py.

Part one: use the random module to build a simple dice roller. Roll two dice, each between 1 and 6. Print the result of each die and the total. Run it five times using a loop to make sure randomness is working.

Part two: use the datetime module to print today's date in a nice readable format like "Today is November 15, 2024." Look up strftime to format it properly. The search term is "python datetime strftime format codes."

Part three: create a file called calculator.py with four functions: add, subtract, multiply, and divide. Import that file in modules_practice.py and use each function at least once.

Part four: if you haven't already, install requests using pip and make a GET request to https://jsonplaceholder.typicode.com/users/1. Print the name and email from the response. It comes back as a dictionary.

What's Next

Phase 1 is almost done. Two more posts left. Next is list comprehensions, a cleaner way to build lists that you will see everywhere in Python code and will want to use immediately once you understand it.

When Code Breaks: How to Handle Errors Like a Pro

Akhilesh — Sun, 19 Apr 2026 02:17:21 +0000

Your program has been running perfectly for ten minutes.

Then someone passes in a string where you expected a number. Or the file you're trying to read got deleted. Or the internet went down mid-request. Or a user typed nothing when your code expected input.

Your program crashes. A wall of red text appears. Everything stops.

This is not bad luck. This is normal. Errors happen in every real program. The question is not how to avoid them entirely. The question is how to catch them before they bring everything down.

What Actually Happens When Code Breaks

When Python hits a problem it cannot resolve, it raises an exception. If nothing catches that exception, the program stops and prints a traceback, that red wall of text.

numbers = [1, 2, 3]
print(numbers[10])

Traceback (most recent call last):
  File "main.py", line 2, in <module>
    print(numbers[10])
IndexError: list index out of range

Three pieces of information here. The file and line where it broke. The exact code that caused it. The type of error and what went wrong.

Read tracebacks from the bottom up. The last line is the actual error. Everything above it is the path Python took to get there.

Try and Except

Wrap risky code in a try block. Tell Python what to do if something goes wrong in the except block.

numbers = [1, 2, 3]

try:
    print(numbers[10])
except IndexError:
    print("That index doesn't exist in the list.")

Output:

That index doesn't exist in the list.

Program keeps running. No crash. No red text.

Python tries the code inside try. If an IndexError happens, it jumps to except IndexError and runs that block instead. If no error happens, the except block is skipped entirely.

Catching Different Error Types

Different problems raise different error types. You can handle each one differently.

def divide(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("Cannot divide by zero.")
        return None
    except TypeError:
        print("Both inputs must be numbers.")
        return None

print(divide(10, 2))
print(divide(10, 0))
print(divide(10, "five"))

Output:

5.0
Cannot divide by zero.
Both inputs must be numbers.

Each except catches a specific error type. ZeroDivisionError when someone divides by zero. TypeError when the wrong type gets passed in. Both get handled cleanly without crashing.

The Errors You'll See Most Often

# NameError: used a variable that doesn't exist
print(username)   # username was never defined

# TypeError: wrong type for the operation
result = "hello" + 5

# ValueError: right type, wrong value
number = int("hello")   # "hello" can't become an integer

# IndexError: index out of range
items = [1, 2, 3]
print(items[99])

# KeyError: key doesn't exist in dictionary
data = {"name": "Alex"}
print(data["age"])

# FileNotFoundError: file doesn't exist
open("missing.txt", "r")

# ZeroDivisionError: dividing by zero
result = 10 / 0

These seven cover probably 80% of the errors you'll encounter in the next few months. When you see one, you now know the category of problem.

Getting the Error Message

Sometimes you want to know exactly what went wrong, not just that something went wrong.

try:
    number = int("not a number")
except ValueError as e:
    print(f"Something went wrong: {e}")

Output:

Something went wrong: invalid literal for int() with base 10: 'not a number'

as e captures the error object. e contains the full error message. Useful for logging problems or showing the user something specific.

Else and Finally

Two optional additions to try/except that come up in real code.

else runs only if no error happened.

try:
    number = int("42")
except ValueError:
    print("That's not a valid number.")
else:
    print(f"Successfully converted: {number}")

Output:

Successfully converted: 42

finally runs no matter what. Error or no error.

try:
    file = open("data.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("File not found.")
finally:
    print("This always runs.")

finally is useful for cleanup code that needs to run regardless of what happened. Closing database connections. Releasing locks. Logging that an operation completed. Even if an exception occurred and was not caught, finally still runs before Python propagates the error.

Raising Your Own Errors

You can raise errors intentionally. Useful when someone uses your function in a way that doesn't make sense.

def set_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative.")
    if age > 150:
        raise ValueError("That age is not realistic.")
    return age

try:
    set_age(-5)
except ValueError as e:
    print(f"Invalid input: {e}")

Output:

Invalid input: Age cannot be negative.

raise ValueError("message") creates and throws an error. The caller's try/except catches it. Your function refuses to work with bad data and tells you exactly why.

This is how professional code is written. Functions validate their inputs and raise clear errors when something is wrong. Far better than silently producing wrong answers.

A Real Pattern: Retrying on Failure

This shows up in data pipelines and API calls constantly.

def load_number(value):
    try:
        return int(value)
    except ValueError:
        return None

raw_data = ["42", "hello", "99", "abc", "17", "?"]
clean_numbers = []

for item in raw_data:
    result = load_number(item)
    if result is not None:
        clean_numbers.append(result)
    else:
        print(f"Skipped invalid value: {item}")

print(f"Clean numbers: {clean_numbers}")

Output:

Skipped invalid value: hello
Skipped invalid value: abc
Skipped invalid value: ?
Clean numbers: [42, 99, 17]

Real data is messy. Some values won't convert. Some files won't exist. Some network calls will fail. Handle the failures, keep the successes, move on.

The One Mistake to Avoid

Catching everything silently.

try:
    some_complicated_code()
except:
    pass

This catches every possible error and does nothing about it. Your code fails silently. You have no idea what went wrong or where. Bugs become invisible. Do not do this.

At minimum, print the error. Better, log it. Best, handle specific error types and let unexpected ones crash loudly so you know they exist.

try:
    some_complicated_code()
except Exception as e:
    print(f"Unexpected error: {e}")

That bare except: with no type and no message is a trap. Avoid it.

Try This

Create errors_practice.py.

Write a function called safe_divide that takes two numbers and returns the result of dividing the first by the second. Handle the case where the second number is zero. Handle the case where either input is not a number. Return None for invalid inputs and print a clear message explaining what went wrong.

Then write a function called load_profile that takes a filename, opens it, reads the JSON inside using json.load, and returns the data as a dictionary. Handle the case where the file doesn't exist. Handle the case where the file exists but is not valid JSON. Return None for failures.

Test both functions with inputs that work and inputs that should fail. Make sure your program never crashes, just handles problems cleanly and keeps going.

What's Next

Your code now handles failure gracefully. Next is modules and packages, how Python lets you use code that other people wrote, which is how you'll eventually use NumPy, Pandas, PyTorch, and every other library in this series.

Reading Files Without Breaking Everything

Akhilesh — Sun, 19 Apr 2026 02:11:39 +0000

Every program you have written so far forgets everything the moment it stops running.

You store names in variables. You calculate scores. You build lists. Then the program ends and all of it is gone. Next time you run it, you start from zero again.

Files are how programs remember things between runs. Files are also how programs talk to the outside world. Real data lives in files. CSV files full of numbers. Text files full of sentences. JSON files full of structured data. Your AI models will read thousands of files. You need to know how this works.

Opening and Reading a File

First, create a file to practice with. Make a new file called notes.txt in the same folder as your Python files. Put this inside it:

Alex
Priya
Sam
Jordan
Lisa

Just five names, one per line. Save it.

Now read it with Python.

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

print(content)

Output:

Alex
Priya
Sam
Jordan
Lisa

Three steps. Open the file. Do something with it. Close it.

The "r" means read mode. You're opening the file to read it, not change it.

file.read() grabs the entire file content as one big string.

file.close() is important. An open file uses system resources. If you forget to close it, you can run into problems, especially if your program opens many files.

The Better Way: with

Forgetting file.close() is a common mistake. Python has a cleaner approach that closes the file automatically, no matter what happens.

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

print(content)

Same result. But now you don't need to call .close(). When the with block ends, Python closes the file automatically. Even if your code crashes inside the block. Even if an error happens. The file always gets closed.

Use with every time you work with files. It's the standard way.

Reading Line by Line

Sometimes you don't want the whole file as one string. You want each line separately.

with open("notes.txt", "r") as file:
    lines = file.readlines()

print(lines)

Output:

['Alex\n', 'Priya\n', 'Sam\n', 'Jordan\n', 'Lisa\n']

.readlines() gives you a list where each item is one line. But notice the \n at the end of each name. That's the newline character, the invisible marker that tells Python where one line ends and the next begins.

Strip it off with .strip().

with open("notes.txt", "r") as file:
    lines = file.readlines()

names = [line.strip() for line in lines]
print(names)

Output:

['Alex', 'Priya', 'Sam', 'Jordan', 'Lisa']

Clean list. No newline characters. This is the pattern you'll use constantly when loading data from text files.

Or loop directly through the file line by line, which is more memory-efficient for large files.

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

Output:

Alex
Priya
Sam
Jordan
Lisa

Writing to a File

with open("output.txt", "w") as file:
    file.write("Hello from Python\n")
    file.write("This is a second line\n")
    file.write("And a third\n")

Run this. Check your folder. A new file called output.txt appeared with those three lines inside.

The "w" means write mode. Here is the dangerous part about "w". If output.txt already existed, Python deleted all its old content and started fresh. No warning. No confirmation. Just gone.

If you want to add to an existing file without destroying what's already there, use "a" for append mode.

with open("output.txt", "a") as file:
    file.write("This line gets added at the end\n")

Run this a few times. Open the file. You'll see the new line added each time without losing the original content.

Writing Multiple Lines at Once

names = ["Alex", "Priya", "Sam", "Jordan"]

with open("names.txt", "w") as file:
    for name in names:
        file.write(name + "\n")

Loop through a list, write each item as its own line. You'll use this shape when saving results, exporting data, logging outputs.

Working With JSON

Plain text files are useful but JSON is where things get interesting. JSON is a format for storing structured data, basically Python dictionaries and lists, saved as text.

import json

person = {
    "name": "Alex",
    "age": 25,
    "city": "Mumbai",
    "skills": ["Python", "Machine Learning", "SQL"]
}

with open("person.json", "w") as file:
    json.dump(person, file, indent=4)

Open person.json in your editor. It looks like this:

{
    "name": "Alex",
    "age": 25,
    "city": "Mumbai",
    "skills": [
        "Python",
        "Machine Learning",
        "SQL"
    ]
}

indent=4 makes it readable with nice formatting. Without it, everything is on one line.

Now read it back.

with open("person.json", "r") as file:
    data = json.load(file)

print(data["name"])
print(data["skills"])

Output:

Alex
['Python', 'Machine Learning', 'SQL']

json.dump() converts Python to JSON and saves it. json.load() reads JSON and converts it back to Python. The dictionary comes back exactly as you saved it.

This matters enormously in AI work. Model configurations are JSON. API responses are JSON. Dataset metadata is JSON. You'll read and write JSON constantly.

When the File Doesn't Exist

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

FileNotFoundError: [Errno 2] No such file or directory: 'missing.txt'

Your program crashes. Handle it properly.

try:
    with open("missing.txt", "r") as file:
        content = file.read()
    print(content)
except FileNotFoundError:
    print("That file doesn't exist.")

Output:

That file doesn't exist.

Program keeps running. You'll learn more about try/except in the next post. For now, just know this pattern exists and use it whenever opening a file that might not be there.

File Paths

So far you've used just a filename like "notes.txt". That works only when the file is in the same folder as your Python script.

For files in other locations, you need the full path.

# Windows
with open("C:\\Users\\Alex\\Documents\\data.txt", "r") as file:
    content = file.read()

# Mac and Linux
with open("/home/alex/documents/data.txt", "r") as file:
    content = file.read()

The double backslash on Windows is because \ has special meaning in Python strings. You need \\ to mean a literal backslash. On Mac and Linux, forward slashes work fine.

A cleaner approach that works on all systems is using Python's pathlib module. But that's a more advanced topic. For now, keeping files in the same folder as your script keeps things simple.

Try This

Create files_practice.py.

Part one: write a list of at least eight cities to a file called cities.txt, one city per line.

Part two: read cities.txt back. Clean up the newline characters. Print how many cities are in the file.

Part three: create a dictionary with information about yourself, at least five keys. Save it to profile.json using json.dump. Then read it back and print each key and value on its own line.

Part four: try to open a file called doesnt_exist.txt and handle the error gracefully so the program prints a helpful message instead of crashing.

What's Next

Files can fail. Networks can fail. Users can type the wrong thing. Programs break in all kinds of ways. The next post is about handling errors properly so your code fails gracefully instead of crashing at the worst moment.

Build Your Own Types: Classes Explained Simply

Akhilesh — Sun, 19 Apr 2026 02:06:57 +0000

You have been using types this whole time.

Strings. Integers. Lists. Dictionaries. Every one of those is a type. And they don't just hold data. They also come with built-in behaviors. Strings have .upper(). Lists have .append(). Dictionaries have .get().

Now here is the question. What if the type you need doesn't exist yet? What if you want a Student type that holds a name, age, and scores, and also knows how to calculate its own average?

That is exactly what classes let you build.

The Cookie Cutter Idea

A class is a blueprint. It describes what something looks like and what it can do. By itself it's just a description, it doesn't actually exist yet.

An object is what you get when you use the blueprint to create something real. You can create as many objects from one class as you want. Same structure, different data.

Cookie cutter is the class. The cookies are the objects.

Your First Class

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

class Student: defines a new type called Student.

def __init__ is a special method that runs automatically when you create a new Student. Think of it as the setup instructions.

self refers to the specific object being created. When you make a Student named Alex, self is that Alex object. When you make a Student named Priya, self is that Priya object. Same class, different self.

self.name = name stores the name on this specific object. Without self., the value disappears when __init__ finishes.

Now create some students.

student1 = Student("Alex", 25)
student2 = Student("Priya", 22)

print(student1.name)
print(student2.name)
print(student1.age)

Output:

Alex
Priya
25

Two objects. Same blueprint. Different data.

Adding Methods

Methods are functions that belong to a class. They define what the object can do.

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

    def greet(self):
        print(f"Hi, I'm {self.name} and I'm {self.age} years old.")

    def birthday(self):
        self.age = self.age + 1
        print(f"Happy birthday {self.name}! You are now {self.age}.")

student1 = Student("Alex", 25)
student1.greet()
student1.birthday()
student1.greet()

Output:

Hi, I'm Alex and I'm 25 years old.
Happy birthday Alex! You are now 26.
Hi, I'm Alex and I'm 26 years old.

birthday() changed self.age on that specific object. student1 is now 26. Any other Student object you created is still whatever age they were. The change only affected student1.

A More Real Example

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

    def deposit(self, amount):
        self.balance = self.balance + amount
        print(f"Deposited {amount}. New balance: {self.balance}")

    def withdraw(self, amount):
        if amount > self.balance:
            print("Not enough money.")
        else:
            self.balance = self.balance - amount
            print(f"Withdrew {amount}. New balance: {self.balance}")

    def show_balance(self):
        print(f"{self.owner}'s balance: {self.balance}")

account = BankAccount("Alex", 1000)
account.show_balance()
account.deposit(500)
account.withdraw(200)
account.withdraw(2000)

Output:

Alex's balance: 1000
Deposited 500. New balance: 1500
Withdrew 200. New balance: 1300
Not enough money.

Notice how the object remembers its state between method calls. self.balance keeps updating. Each call to deposit or withdraw works with the current balance, not some starting value. That persistent memory is what makes objects powerful.

Multiple Objects, Independent State

account1 = BankAccount("Alex", 1000)
account2 = BankAccount("Priya", 5000)

account1.deposit(200)
account2.withdraw(1000)

account1.show_balance()
account2.show_balance()

Output:

Deposited 200. New balance: 1200
Withdrew 1000. New balance: 4000
Alex's balance: 1200
Priya's balance: 4000

Two completely separate accounts. Operations on one never touch the other. That independence is the whole point of objects.

The str Method

When you print an object, Python normally shows something ugly like <__main__.Student object at 0x10b3f2a90>. You can fix that.

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

    def __str__(self):
        return f"Student: {self.name}, Age: {self.age}"

student1 = Student("Alex", 25)
print(student1)

Output:

Student: Alex, Age: 25

__str__ is another special method like __init__. Python calls it automatically whenever it needs to display your object as text. Return a string from it and that's what gets printed.

Three Things That Confuse Everyone

Forgetting self in method definitions.

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

TypeError: Student.__init__() takes 2 positional arguments but 3 were given

Every method in a class must have self as the first parameter. Every single one. Even if you don't use self inside the method. Python passes the object automatically as the first argument, so self has to be there to receive it.

Forgetting self when storing data.

def __init__(self, name):
    name = name       # wrong, this just creates a local variable

def __init__(self, name):
    self.name = name  # correct, this stores it on the object

Without self., the data exists only while __init__ is running and then vanishes. Always use self. to store anything you need to keep.

Using the class itself instead of creating an object.

Student.greet()      # wrong, Student is the blueprint
student1.greet()     # correct, student1 is the actual object

Try This

Create classes_practice.py.

Build a class called Product for an online store.

It should store: name, price, and quantity in stock.

It should have these methods:

show_info() that prints all the product details neatly
sell(quantity) that reduces the stock by that amount, but prints "not enough stock" if the quantity requested is more than what's available
restock(quantity) that adds to the stock
apply_discount(percent) that reduces the price by that percentage and prints the new price

Create two different products. Call different methods on each. Make sure the state changes correctly and the two products stay independent.

What's Next

Objects are great for organizing data and behavior together. But Python also needs to work with data that lives in files, not just in memory. Next post is about reading and writing files, which is how your programs start talking to the real world.

Dictionaries: When a List Just Isn't Enough

Akhilesh — Sun, 19 Apr 2026 02:05:31 +0000

You have a list of five numbers.

person = ["Alex", 25, "Mumbai", True, "alex@email.com"]

Quick question. What is person[3]?

You have to count. Index 0 is the name. Index 1 is age. Index 2 is city. Index 3 is... the boolean? What does True mean here? Is that married? Is that a student? Is that something else entirely?

You wrote this code yourself and you already can't remember what index 3 means.

Now imagine coming back to this code three weeks later.

This is the exact problem dictionaries solve. Instead of accessing data by position, you access it by name. Instead of person[3] you write person["is_student"]. The name tells you everything.

What a Dictionary Looks Like

Curly braces. Key and value pairs separated by colons. Pairs separated by commas.

person = {
    "name": "Alex",
    "age": 25,
    "city": "Mumbai",
    "is_student": True,
    "email": "alex@email.com"
}

Now access any value by its key.

print(person["name"])
print(person["age"])
print(person["is_student"])

Output:

Alex
25
True

No counting. No guessing. person["age"] tells you exactly what you're getting.

Adding, Changing, Removing

A dictionary is not frozen after you create it. You can change it freely.

person = {"name": "Alex", "age": 25}

person["city"] = "Mumbai"        # add new key
person["age"] = 26               # update existing key
del person["city"]               # delete a key

print(person)

Output:

{'name': 'Alex', 'age': 26}

Assigning to a key that exists updates it. Assigning to a key that doesn't exist creates it. Clean and consistent.

The Safe Way to Get Values

What happens when you ask for a key that doesn't exist?

person = {"name": "Alex", "age": 25}
print(person["city"])

KeyError: 'city'

Your program crashes. Not ideal.

Use .get() instead. It returns None if the key doesn't exist instead of crashing.

city = person.get("city")
print(city)                         # None

city = person.get("city", "Unknown")
print(city)                         # Unknown

The second argument to .get() is a default value. If the key exists, you get the real value. If it doesn't, you get the default. Your program keeps running.

Use .get() whenever the key might not be there. Use person["key"] only when you're certain the key exists.

Looping Through a Dictionary

Three ways. Each one useful for different situations.

scores = {"Alex": 92, "Priya": 88, "Sam": 75, "Jordan": 95}

for key in scores:
    print(key)

Output:

Alex
Priya
Sam
Jordan

Just the keys. Now both:

for key, value in scores.items():
    print(f"{key}: {value}")

Output:

Alex: 92
Priya: 88
Sam: 75
Jordan: 95

.items() gives you each key-value pair as a tuple. The for key, value unpacks it. This is the one you'll use most.

Just the values if you need them:

for value in scores.values():
    print(value)

Output:

Checking If a Key Exists

Before you access a key, sometimes you need to know if it's there.

person = {"name": "Alex", "age": 25}

if "city" in person:
    print(person["city"])
else:
    print("No city found")

Output:

No city found

in works with dictionaries just like with lists. Checks keys, not values.

Dictionaries Inside Lists

This is the pattern you will see constantly in real data work.

students = [
    {"name": "Alex", "score": 92, "passed": True},
    {"name": "Priya", "score": 58, "passed": False},
    {"name": "Sam", "score": 75, "passed": True},
    {"name": "Jordan", "score": 44, "passed": False}
]

for student in students:
    if student["passed"]:
        print(f"{student['name']} passed with {student['score']}")
    else:
        print(f"{student['name']} needs to retake the exam")

Output:

Alex passed with 92
Priya needs to retake the exam
Sam passed with 75
Jordan needs to retake the exam

A list of dictionaries. Every item in the list is a dictionary with the same keys. This is exactly how JSON data looks. This is how APIs return data. This is how database records get processed in Python.

Get comfortable with this shape. You'll work with it for the rest of your programming life.

Counting Things With a Dictionary

One classic use case. Count how many times each item appears.

words = ["python", "is", "fun", "python", "is", "great", "python"]

counts = {}

for word in words:
    if word in counts:
        counts[word] = counts[word] + 1
    else:
        counts[word] = 1

print(counts)

Output:

{'python': 3, 'is': 2, 'fun': 1, 'great': 1}

Walk through what happens. First time Python sees "python", it's not in counts yet. So counts["python"] = 1. Second time it sees "python", it IS in counts. So counts["python"] = counts["python"] + 1 which is 1 + 1 = 2. Third time, 2 + 1 = 3.

This exact pattern, counting occurrences, shows up in text analysis, data cleaning, building histograms, and more.

The One Thing That Catches Everyone

Dictionary keys must be unique. If you add the same key twice, the second value overwrites the first. Silently. No error.

data = {
    "name": "Alex",
    "age": 25,
    "name": "Alexander"      # duplicate key
}

print(data["name"])

Output:

Alexander

"Alex" is gone. "Alexander" replaced it without any warning. Python doesn't complain. This causes bugs that are genuinely hard to find because nothing crashes.

Double check your keys when creating a dictionary manually.

Dictionary vs List: When to Use Which

Use a list when order matters and you're dealing with a sequence of similar things. A list of names. A list of scores. A sequence of steps.

Use a dictionary when you want to label your data. A user profile. A config file. Anything where you need to look something up by name instead of by position.

In data science and AI, you'll use both constantly, often together. Models output dictionaries. Datasets are lists of dictionaries. Configuration is a dictionary. Results are stored in dictionaries.

Try This

Create dictionaries_practice.py.

Build a dictionary for a product in an online store. It should have at least six keys: name, price, category, in_stock (boolean), rating, and number of reviews.

Then write code that does all of this:

Print a nicely formatted product description using the values from your dictionary.

Add a "discount_percent" key with a value of 10.

Calculate and print the discounted price using the values already in the dictionary.

Write a loop that goes through the dictionary and prints every key and value on its own line.

Finally, try accessing a key that doesn't exist using .get() with a sensible default value.

What's Next

Lists and dictionaries store collections of data. But what if you want to create your own custom data type, something that bundles both data and behavior together? That's what classes and objects are for, and that's exactly where we're heading.

Lists: The Most Useful Thing in Python

Akhilesh — Sun, 19 Apr 2026 02:05:11 +0000

Every program you will ever write works with collections of things.

A list of users. A list of prices. A list of predictions your model made. A list of words in a sentence. A list of images to process.

You cannot avoid lists. They are everywhere. Learn them well now and everything else gets easier.

Making a List

Square brackets. Items separated by commas.

fruits = ["apple", "banana", "mango", "grape"]
scores = [95, 82, 67, 54, 71]
mixed = ["Alex", 25, True, 3.14]
empty = []

A list can hold anything. Strings, numbers, booleans, even other lists. And yes, mixing types in one list is allowed, though in practice most lists hold one type of thing.

Getting Items Out

Every item in a list has a position number called an index. And here is the thing that trips up almost everyone at the start.

Indexes start at 0, not 1.

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

print(fruits[0])   # apple
print(fruits[1])   # banana
print(fruits[2])   # mango
print(fruits[3])   # grape

Output:

apple
banana
mango
grape

First item is index 0. Second is index 1. Always one less than you expect.

Negative indexes count from the end. -1 is always the last item.

print(fruits[-1])   # grape
print(fruits[-2])   # mango

Incredibly useful when you need the last item and don't know how long the list is.

Try to access an index that doesn't exist and Python tells you clearly.

print(fruits[10])

IndexError: list index out of range

The list has 4 items. Index 10 does not exist.

Changing Items

Lists are mutable. That means you can change them after creating them.

fruits = ["apple", "banana", "mango", "grape"]
fruits[1] = "orange"
print(fruits)

Output:

['apple', 'orange', 'mango', 'grape']

Banana is gone. Orange took its place at index 1.

Adding and Removing

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

fruits.append("grape")        # adds to the end
print(fruits)

fruits.insert(1, "orange")    # inserts at index 1
print(fruits)

fruits.remove("banana")       # removes by value
print(fruits)

last = fruits.pop()           # removes and returns last item
print(last)
print(fruits)

Output:

['apple', 'banana', 'mango', 'grape']
['apple', 'orange', 'banana', 'mango', 'grape']
['apple', 'orange', 'mango', 'grape']
grape
['apple', 'orange', 'mango']

append is the one you'll use most. Every time you build a list dynamically, you start with an empty list and append to it.

Useful Things to Know About Your List

numbers = [4, 2, 8, 1, 9, 3, 7]

print(len(numbers))       # 7, how many items
print(min(numbers))       # 1, smallest
print(max(numbers))       # 9, largest
print(sum(numbers))       # 34, total
print(sorted(numbers))    # [1, 2, 3, 4, 7, 8, 9], sorted copy
print(7 in numbers)       # True, is 7 in the list?
print(5 in numbers)       # False

Output:

7
1
9
34
[1, 2, 3, 4, 7, 8, 9]
True
False

in is one of the cleaner bits of Python. Check if something exists in a list in plain English.

Slicing: Getting a Chunk

You can grab a section of a list using slicing. Start index and end index separated by a colon inside brackets.

numbers = [10, 20, 30, 40, 50, 60, 70]

print(numbers[1:4])    # index 1 up to but not including 4
print(numbers[:3])     # from the start up to index 3
print(numbers[4:])     # from index 4 to the end
print(numbers[-3:])    # last three items

Output:

[20, 30, 40]
[10, 20, 30]
[50, 60, 70]
[50, 60, 70]

Same rule as range: the end number is not included. [1:4] gives you indexes 1, 2, and 3.

Looping Over a List

You saw this in the loops post. Now it makes more sense.

names = ["Alex", "Priya", "Sam", "Jordan"]

for name in names:
    print(f"Hello, {name}!")

Output:

Hello, Alex!
Hello, Priya!
Hello, Sam!
Hello, Jordan!

If you also need the index, use enumerate.

for index, name in enumerate(names):
    print(f"{index}: {name}")

Output:

0: Alex
1: Priya
2: Sam
3: Jordan

enumerate gives you both the position and the value on every pass. You'll use this more than you think.

Building a List Dynamically

The most common real-world pattern. Start empty, add things as you go.

scores = [45, 92, 78, 61, 88, 55, 97]
passing = []

for score in scores:
    if score >= 60:
        passing.append(score)

print(passing)

Output:

[92, 78, 61, 88, 97]

Start with an empty list. Loop through the original. Check the condition. Append if it passes. End up with a filtered list. This pattern is everywhere in data processing.

One Mistake That Gets Everyone

Copying a list the wrong way.

original = [1, 2, 3]
copy = original          # this is NOT a copy

copy.append(4)
print(original)          # [1, 2, 3, 4] -- original changed too!

When you do copy = original, you're not creating a second list. Both variables point to the exact same list in memory. Change one, both change.

To make a real copy:

original = [1, 2, 3]
copy = original.copy()   # actual copy

copy.append(4)
print(original)          # [1, 2, 3] -- original unchanged
print(copy)              # [1, 2, 3, 4]

This trips people up badly in data work. Always use .copy() when you need an independent copy of a list.

Try This

Create lists_practice.py.

Start with this list of temperatures in Celsius:

temps = [38, 22, 41, 19, 35, 27, 44, 16, 30, 23]

Write code that does all of these without using any built-in shortcut functions where noted:

First: print the highest and lowest temperature using max() and min().

Second: build a new list containing only temperatures above 30. Use a loop and append.

Third: convert every temperature to Fahrenheit and store in a new list. Formula: (c * 9/5) + 32. Use the function you wrote in post 5 if you saved it.

Fourth: print how many temperatures are above 30 without using len() on your filtered list. Count them with a counter variable inside a loop.

Run it. Check the outputs make sense.

What's Next

Lists hold items in order with a numeric index. But sometimes you need to label your data with names instead of numbers. That's what dictionaries are for and they're coming up next.

Functions: Stop Writing the Same Code Twice

Akhilesh — Sat, 18 Apr 2026 13:34:46 +0000

You have written the same print(f"Hello, {name}!") line three times in your code already.

Not a big deal with one line. But what happens when the thing you keep repeating is 15 lines long? What happens when you find a bug in it and have to fix it in six different places? What happens when you forget to fix one of them?

This is not a hypothetical. This is what happens in real codebases when people don't use functions. Code gets copied, pasted, modified slightly, and then something breaks and nobody knows which copy is the right one.

Functions solve this. Write the code once, use it anywhere.

The Simplest Function Possible

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

def tells Python you're defining a function.

greet is the name you're giving it. You choose the name, same rules as variable names.

() is where parameters go. Empty for now.

: ends the line, same as if and for.

The indented block is the function body. The code that runs when you call the function.

But here's the thing. Running that code does nothing visible. You defined the function. You haven't used it yet.

To actually run the code inside, you call the function.

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

greet()
greet()
greet()

Output:

Hello, welcome!
Hello, welcome!
Hello, welcome!

Three calls, three outputs. The function ran three times. You wrote the print statement once.

Parameters: Giving the Function Information

A function that always does the exact same thing is useful but limited. Parameters let you pass different information to the function each time you call it.

def greet(name):
    print(f"Hello, {name}! Welcome.")

name inside the parentheses is a parameter. It's a variable that exists only inside the function and gets its value when you call the function.

greet("Alan")
greet("Priya")
greet("Sam")

Output:

Hello, Alan! Welcome.
Hello, Priya! Welcome.
Hello, Sam! Welcome.

Same function. Three different results. The parameter is what makes it flexible.

You can have multiple parameters. Separate them with commas.

def introduce(name, age, city):
    print(f"My name is {name}. I am {age} years old and I live in {city}.")

introduce("Alan", 25, "Mumbai")
introduce("Priya", 30, "Delhi")

Output:

My name is Alan. I am 25 years old and I live in Mumbai.
My name is Priya. I am 30 years old and I live in Delhi.

Order matters here. When you call the function, Python matches your arguments to the parameters left to right. First argument goes to first parameter, second to second, and so on.

Return: Getting Something Back

So far every function just prints something. But often you want a function to calculate something and give you the result back, not just display it.

That's what return does.

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

total = add(10, 5)
print(total)

Output:

The function takes two numbers, adds them, and returns the answer. You can store that answer in a variable, use it in another calculation, pass it to another function, anything.

Here's the key difference. print() inside a function just displays text. The value disappears after that. return sends the value back to whoever called the function so they can do something with it.

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

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

x = add(3, 4)       # x is now 7
y = multiply(x, 2)  # y is now 14

print(y)

Output:

The output of one function fed straight into another. This is how real programs are built. Small functions, chained together.

Default Parameters

Sometimes you want a parameter to have a default value if the caller doesn't provide one.

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alan")
greet("Priya", "Good morning")
greet("Sam", "Hey")

Output:

Hello, Alan!
Good morning, Priya!
Hey, Sam!

When you call greet("Alan") without a second argument, greeting falls back to "Hello". When you provide one, that value is used instead.

Default parameters must always come after non-default ones. This doesn't work:

def greet(greeting="Hello", name):   # wrong

Python needs to know which argument is which. Put defaults last.

Variables Inside Functions Stay Inside

This one surprises people.

def calculate():
    result = 100
    print(f"Inside function: {result}")

calculate()
print(result)   # this breaks

Output:

Inside function: 100
NameError: name 'result' is not defined

The variable result was created inside the function. It only exists while the function is running. Once the function finishes, result is gone. Code outside the function cannot see it.

This is called scope. Variables have a scope, which is the region of code where they exist.

The fix is to return the value.

def calculate():
    result = 100
    return result

answer = calculate()
print(answer)

Output:

Now result is returned and stored in answer. answer lives outside the function, so the outside code can use it.

A Function That Does Something Real

Let's write a function that calculates a grade based on a score. You built something similar with if/else in post 3. Now let's make it reusable.

def get_grade(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

scores = [95, 82, 67, 54, 71]

for score in scores:
    grade = get_grade(score)
    print(f"Score {score}: Grade {grade}")

Output:

Score 95: Grade A
Score 82: Grade B
Score 67: Grade D
Score 54: Grade F
Score 71: Grade C

Look at how clean this is. The grading logic lives in one place. The loop just calls the function for each score. If you ever need to change how grades are calculated, you change it in one function and it updates everywhere.

That's the real reason functions exist. Not just to avoid repetition. To keep related logic together so your code is easier to read, fix, and change.

Two Mistakes Everyone Makes

Mistake 1: Forgetting to return and wondering why you get None

def add(a, b):
    result = a + b     # calculated but never returned

total = add(5, 3)
print(total)

Output:

None

The function calculated 8. But it never sent that value back. Python functions that don't explicitly return something return None automatically. None means nothing. Not zero. Literally nothing.

Fix: add return result at the end.

Mistake 2: Calling before defining

greet("Alan")       # call happens first

def greet(name):    # definition comes after
    print(f"Hello, {name}")

Error:

NameError: name 'greet' is not defined

Python reads top to bottom. When it hits greet("Alan"), it hasn't seen the definition yet. Define functions before you call them.

Try This

Create a file called functions_practice.py.

Write three separate functions.

First one: takes a temperature in Celsius and returns it converted to Fahrenheit. The formula is (celsius * 9/5) + 32.

Second one: takes a person's name and birth year and prints a message like "Alan was born in 1999 and is 25 years old." Calculate the age inside the function. You'll need to hardcode the current year or store it in a variable.

Third one: takes a list of numbers and returns the largest one without using Python's built-in max() function. Think through how you'd find the largest number by going through the list one item at a time.

Then call each function at least twice with different inputs to make sure they work correctly.

What's Next

You now know how to organize code into reusable blocks. The next post is about lists, which are the most important data structure you'll use in Python. You've seen them briefly but now you'll learn everything: how to add to them, remove from them, search them, sort them, and loop through them in useful ways.

The Loop That Ate My Computer

Akhilesh — Sat, 18 Apr 2026 09:12:53 +0000

Let me tell you what happened the first time I wrote a loop.

I wanted to print numbers from 1 to 10. Simple enough. I had just read about while loops. I thought I understood them. So I wrote this:

number = 1

while number < 10:
    print(number)

I ran it.

Numbers started printing. 1, 2, 3... wait. Same numbers? 1, 1, 1, 1, 1, 1, 1, 1...

The terminal filled up. Lines kept coming. The computer fan started spinning faster. I sat there frozen for three full seconds before I remembered to press Ctrl+C to stop it.

I had created an infinite loop. And I had no idea what I did wrong.

That moment is where this post starts.

What Even Is a Loop

You already know Python runs your code top to bottom, one line at a time. Loops break that rule in a useful way. They say: run this block of code multiple times before moving on.

Without loops, if you wanted to print numbers 1 through 10, you'd write:

print(1)
print(2)
print(3)
print(4)
print(5)
print(6)
print(7)
print(8)
print(9)
print(10)

That's fine for 10. What about 1000? What about a million? What if you don't know the number in advance?

That's where loops come in.

Python has two kinds. The for loop and the while loop. They do similar jobs but in different situations. Learn both.

The For Loop

A for loop goes through a collection of things, one by one, and runs your code for each one.

for number in range(1, 11):
    print(number)

Output:

Ten lines. One instruction. That's the power.

Let's break down what each part means.

for starts the loop.

number is a variable you create right here. It gets a new value on each pass through the loop. You can name it anything. n, i, num, whatever makes sense.

in connects the variable to the collection.

range(1, 11) creates a sequence of numbers starting at 1 and going up to but not including 11. So 1 through 10. The second number is always exclusive. Feels weird at first. You get used to it.

The colon and indentation work the same as if statements. Everything indented under the for line runs on each pass.

Range Has Three Versions

Worth knowing all three now so they don't confuse you later.

range(5)          # 0, 1, 2, 3, 4  (starts at 0 by default)
range(1, 6)       # 1, 2, 3, 4, 5
range(0, 10, 2)   # 0, 2, 4, 6, 8  (third number is the step)

for i in range(0, 10, 2):
    print(i)

Output:

The step can also go backwards.

for i in range(10, 0, -1):
    print(i)

Output:

Looping Over a List

Range isn't the only thing you can loop over. You can loop over any collection, including a list of items.

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

for fruit in fruits:
    print(fruit)

Output:

apple
banana
mango
grape

The variable fruit takes on each value in the list, one by one. First pass it's "apple", second pass "banana", and so on. The loop runs exactly four times because there are four items.

This is something you'll do constantly in real code. Go through a list, do something with each item.

names = ["Alex", "Priya", "Sam", "Jordan"]

for name in names:
    print(f"Hello, {name}!")

Output:

Hello, Alex!
Hello, Priya!
Hello, Sam!
Hello, Jordan!

The While Loop

A while loop is different. Instead of going through a collection, it keeps running as long as a condition stays true.

number = 1

while number <= 10:
    print(number)
    number = number + 1

Output:

Same result as the for loop example. Different mechanism.

The while loop checks the condition before every single pass. Is number <= 10? Yes? Run the block. Check again. Yes? Run again. At some point number becomes 11. Is 11 <= 10? No. Stop.

Now you see my mistake from the opening. I forgot number = number + 1. The number never changed. It stayed 1. The condition 1 < 10 was always true. The loop never stopped.

The golden rule for while loops: always make sure something inside the loop will eventually make the condition false. If nothing changes the condition, you loop forever.

Breaking Out Early

Sometimes you want to stop a loop before it naturally finishes. break does that.

for number in range(1, 20):
    if number == 7:
        print("Found 7, stopping")
        break
    print(number)

Output:

1
2
3
4
5
6
Found 7, stopping

The loop was set to run from 1 to 19. But when it hit 7, the break statement stopped the whole loop immediately. Everything after 7 never ran.

Skipping One Pass

continue is different from break. Instead of stopping the whole loop, it skips only the current pass and moves to the next one.

for number in range(1, 11):
    if number == 5:
        continue
    print(number)

Output:

5 is missing. When number was 5, continue fired and Python jumped straight to the next iteration. The print(number) below it never ran for that one pass.

Keeping Count Inside a Loop

A really common pattern: start a counter at 0, add to it inside the loop.

total = 0

for number in range(1, 11):
    total = total + number

print(f"Sum of 1 to 10: {total}")

Output:

Sum of 1 to 10: 55

The variable total lives outside the loop but gets updated inside it on every pass. After the loop finishes, total holds the final answer.

This pattern shows up everywhere. In real AI code you'll use it to track losses, scores, counts, totals. The shape of the pattern is always the same: set up a variable before the loop, update it inside, use it after.

Nested Loops

You can put a loop inside a loop. The inner one runs completely for every single pass of the outer one.

for row in range(1, 4):
    for col in range(1, 4):
        print(f"Row {row}, Col {col}")

Output:

Row 1, Col 1
Row 1, Col 2
Row 1, Col 3
Row 2, Col 1
Row 2, Col 2
Row 2, Col 3
Row 3, Col 1
Row 3, Col 2
Row 3, Col 3

Outer loop runs 3 times. Each time it runs, the inner loop runs 3 times. Total: 9 lines.

This matters more in AI than you'd expect. When you work with grids, matrices, images, you're often looping over rows and columns exactly like this.

A Practical Example

Let's use loops for something real. A simple number guessing game.

secret = 7
attempts = 0

guesses = [3, 9, 7]

for guess in guesses:
    attempts = attempts + 1

    if guess == secret:
        print(f"Correct! You got it in {attempts} attempt(s)")
        break
    elif guess < secret:
        print(f"Guess {guess}: too low")
    else:
        print(f"Guess {guess}: too high")

Output:

Guess 3: too low
Guess 9: too high
Correct! You got it in 3 attempt(s)

This combines everything you've learned so far. Variables, data types, conditions, and now loops. Notice how the pieces fit together.

When to Use Which

A simple way to decide:

Use for when you know what you're looping over. A list of names. A range of numbers. A known collection of things.

Use while when you don't know how many times you'll loop. Keep going until the user types "quit." Keep going until you find the answer. Keep going until some condition changes.

Most of the time in Python, for is what you want. while is for specific situations where the end condition isn't a fixed number of steps.

The Three Things That Go Wrong

Going infinite. You write a while loop and forget to update the condition. Solution: always find the line inside your while loop that changes the variable being checked. If that line doesn't exist, your loop runs forever.

Off by one. range(1, 10) gives you 1 through 9, not 1 through 10. The end number is not included. This bites everyone at least once. If your loop seems to stop one too early, add 1 to your range end.

Modifying a list while looping over it. This is a sneaky one. If you add or remove items from a list while a for loop is going through it, weird things happen. Loop over a copy instead, or collect your changes and apply them after the loop. You'll see why this matters more once you're working with data.

Try This

Create a file called loops_practice.py.

Write code that does all three of these things separately.

First: use a loop to print a multiplication table for any number you choose. So if you pick 5, it prints "5 x 1 = 5", "5 x 2 = 10" all the way to "5 x 10 = 50".

Second: use a loop to add up all even numbers between 1 and 100 and print the total.

Third: use a loop to go through this list and print only the names longer than 4 characters.

names = ["Alex", "Priya", "Sam", "Jordan", "Li", "Valentina", "Tom"]

Hints: the % operator tells you if a number is even (even numbers have zero remainder when divided by 2). The len() function tells you how long a string is.

What Comes Next

You can print 1000 items with one loop now. But what if you want to take a block of code and run it from different places in your program, with different inputs each time? That's a function. That's next.