How a Student Becomes a Python Developer in 6 Months

class InsufficientFunds(Exception):
    pass


class Account:
    def __init__(self, owner: str, balance: float = 0.0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount: float) -> None:
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self.balance += amount

    def withdraw(self, amount: float) -> None:
        if amount > self.balance:
            raise InsufficientFunds(f"Balance is only {self.balance}")
        self.balance -= amount

    def __str__(self) -> str:
        return f"{self.owner}: {self.balance:.2f}"

# Run with:  pip install pytest  &&  pytest -q
import pytest
from account import Account, InsufficientFunds


def test_deposit_increases_balance():
    acc = Account("Asha")
    acc.deposit(500)
    assert acc.balance == 500


def test_negative_deposit_rejected():
    with pytest.raises(ValueError):
        Account("Asha").deposit(-10)


def test_overdraw_raises():
    acc = Account("Asha", 100)
    with pytest.raises(InsufficientFunds):
        acc.withdraw(150)

import csv
import json
from pathlib import Path

import requests

URL = "https://jsonplaceholder.typicode.com/todos"


def fetch_todos():
    resp = requests.get(URL, timeout=10)
    resp.raise_for_status()          # stop on 4xx/5xx
    return resp.json()


def save_summary(todos, out: Path):
    done = sum(1 for t in todos if t["completed"])
    summary = {"total": len(todos), "completed": done}
    out.write_text(json.dumps(summary, indent=2), encoding="utf-8")

    with open(out.with_suffix(".csv"), "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["id", "title", "completed"])
        for t in todos:
            writer.writerow([t["id"], t["title"], t["completed"]])


if __name__ == "__main__":
    save_summary(fetch_todos(), Path("todo_summary.json"))

# tasks/models.py
from django.conf import settings
from django.db import models


class Task(models.Model):
    owner = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    title = models.CharField(max_length=200)
    done = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return self.title

# Then:
#   python manage.py makemigrations
#   python manage.py migrate
# Query: Task.objects.filter(owner=request.user, done=False)

# 1. First non-repeating character
from collections import Counter

def first_unique(s: str):
    counts = Counter(s)
    for ch in s:
        if counts[ch] == 1:
            return ch
    return None

assert first_unique("swiss") == "w"

# 2. Group words that are anagrams
from collections import defaultdict

def group_anagrams(words):
    groups = defaultdict(list)
    for w in words:
        groups["".join(sorted(w))].append(w)
    return list(groups.values())

print(group_anagrams(["eat", "tea", "tan", "ate", "nat"]))
# [['eat', 'tea', 'ate'], ['tan', 'nat']]

# Mutable default argument trap
def add_item(item, bucket=None):
    if bucket is None:      # not bucket=[] in the signature
        bucket = []
    bucket.append(item)
    return bucket

# Generator: values produced lazily, one at a time
def squares(n):
    for i in range(n):
        yield i * i

print(sum(squares(1_000_000)))   # no big list in memory

# Decorator that times a function
import time, functools

def timed(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = fn(*args, **kwargs)
        print(f"{fn.__name__} took {time.perf_counter() - start:.4f}s")
        return result
    return wrapper

DAILY ROUTINE (about 3-4 focused hours)

45 min  Learn one new concept (class, docs, notes)
90 min  Code it yourself: exercise or project feature
20 min  Write or update a test
20 min  One practice problem (strings, lists, dicts)
15 min  Commit, push, and write 3 lines in a log:
        - What I built
        - What broke and why
        - What I will do tomorrow

Weekly: one rest day, one revision day

# Expense Splitter (Django + PostgreSQL)

Live demo: https://your-app.example.com

## What it does
Groups add shared expenses; the app shows who owes whom.

## Tech
Python 3.12, Django, Django REST Framework, PostgreSQL, pytest

## Run locally
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python manage.py migrate
python manage.py runserver

## Tests
pytest -q

## What I learned
- Designing models with foreign keys
- Avoiding N+1 queries with select_related

MONTHLY REVIEW

Month: ____

Topics planned      : ______________________
Topics actually done: ______________________
Projects pushed     : ____  Tests written: ____
Practice problems   : ____

Still weak at       : ______________________
Plan for next month : ______________________

Honest check: could I explain this month's
work to an interviewer for 5 minutes? Y / N