Python Mini Projects to Build in a Weekend

Python mini projects are the best way to turn tutorials into skill, but most weekend projects are never finished. They start too big: a full app, a game with graphics, a website. By Sunday evening there is half a program and a lot of frustration. The fix is scoping.

The scoping method

Split every weekend project into three layers:

• Saturday core: the smallest version that does the main job end to end, on real input, with output you can check. If it takes more than three or four hours, the core is too big.
• Sunday polish: error handling, a cleaner structure, a README, a small test or two.
• Stretch goals: a chart, a command-line interface, a scheduler. Only if time remains.

A project with a finished core and a README is something you can show. A project with ambitious half-features is not.

The three projects below are scoped this way. Each Saturday core was built and run:

import json
import shutil
from datetime import date, timedelta
from pathlib import Path

import pandas as pd

# Project 1 core: does the weather change bike rentals? (UCI Bike Sharing, daily data)
day = pd.read_csv("day.csv")
weather = {1: "clear", 2: "mist or cloud", 3: "light rain or snow"}
print("W1 average daily rentals by weather")
for code, avg in day.groupby("weathersit").cnt.mean().items():
    print(f"   {weather[code]:<20}{avg:>8,.0f}  ({(day.weathersit == code).sum()} days)")
day["temp_c"] = day.temp * 41                                    # dataset stores temperature divided by 41
bands = pd.cut(day.temp_c, [0, 10, 20, 30, 41], labels=["under 10C", "10-20C", "20-30C", "over 30C"])
print("   by temperature: " + " | ".join(f"{b} {v:,.0f}" for b, v in day.groupby(bands, observed=True).cnt.mean().items()))

# Project 2 core: a file organiser that plans before it moves anything
inbox = Path("inbox")
shutil.rmtree(inbox, ignore_errors=True)
inbox.mkdir()
for name in ["report.pdf", "photo.jpg", "data.csv", "notes.txt", "scan.PDF", "song.mp3", "budget.xlsx"]:
    (inbox / name).write_text("x")
kinds = {".pdf": "documents", ".txt": "documents", ".jpg": "images", ".csv": "data", ".xlsx": "data"}
plan = [(f, inbox / kinds.get(f.suffix.lower(), "other") / f.name) for f in sorted(inbox.iterdir()) if f.is_file()]
print("\nW2 dry run: planned moves")
for src, dst in plan:
    print(f"   {src.name:<12} -> {dst.parent.name}/")
for src, dst in plan:                                            # only now act on the plan
    dst.parent.mkdir(exist_ok=True)
    src.rename(dst)
print("   after moving: " + ", ".join(f"{d.name} {len(list(d.iterdir()))}" for d in sorted(inbox.iterdir())))

# Project 3 core: a habit tracker that remembers between runs (JSON file)
store = Path("habits.json")
store.unlink(missing_ok=True)


def log(habit, day_done):
    data = json.loads(store.read_text()) if store.exists() else {}
    data.setdefault(habit, [])
    if day_done.isoformat() not in data[habit]:
        data[habit].append(day_done.isoformat())
    store.write_text(json.dumps(data, indent=1))


def streak(habit, today):
    done = set(json.loads(store.read_text()).get(habit, []))
    n = 0
    while (today - timedelta(days=n)).isoformat() in done:
        n += 1
    return n


start = date(2026, 10, 1)
for offset in [0, 1, 2, 4, 5, 6, 7]:                             # missed day 3
    log("python practice", start + timedelta(days=offset))
log("python practice", start + timedelta(days=7))               # logging twice must not double count
print(f"\nW3 streak on {start + timedelta(days=7)}: {streak('python practice', start + timedelta(days=7))} days | "
      f"days logged: {len(json.loads(store.read_text())['python practice'])}")

W1 average daily rentals by weather
   clear                  4,877  (463 days)
   mist or cloud          4,036  (247 days)
   light rain or snow     1,803  (21 days)
   by temperature: under 10C 1,678 | 10-20C 3,692 | 20-30C 5,662 | over 30C 5,410

W2 dry run: planned moves
   budget.xlsx  -> data/
   data.csv     -> data/
   notes.txt    -> documents/
   photo.jpg    -> images/
   report.pdf   -> documents/
   scan.PDF     -> documents/
   song.mp3     -> other/
   after moving: data 2, documents 3, images 1, other 1

W3 streak on 2026-10-08: 4 days | days logged: 7

Project 1: does the weather change bike rentals?

Saturday core: load two years of daily rentals from Washington D.C.'s bike-sharing system (UCI: Bike Sharing) and compare averages by weather and temperature. On clear days the average was 4,877 rentals; on misty or cloudy days 4,036; on days with light rain or snow 1,803, though only 21 such days exist. Rentals rose with temperature up to 20 to 30 °C (5,662 a day) and dipped slightly above 30 °C.

Sunday polish: a chart for each comparison, a note on the small number of rainy days, and a README explaining the temperature conversion.

Stretch: compare weekdays with weekends, or registered with casual riders.

What it teaches: loading data, grouping, binning and reading results critically, such as noticing that 21 days is a small sample.

Project 2: a file organiser that cannot lose your files

Saturday core: sort the files in a folder into subfolders by type. The key design choice is to plan first and move second: the script printed every planned move as a dry run, then executed the same plan. It handled an upper-case extension (scan.PDF) and sent unknown types to "other" rather than ignoring them. Python's pathlib makes listing, creating and renaming paths straightforward and portable across operating systems (Python docs: pathlib).

Sunday polish: a --dry-run option that is on by default, handling name clashes, and a log of what moved where.

Stretch: an undo command that reads the log and moves files back.

What it teaches: working safely with the file system, a skill every automation job needs.

Project 3: a habit tracker with streaks

Saturday core: record a habit on a date and calculate the current streak, with data saved in a JSON file so it remembers between runs (Python docs: json). In the example, practice was logged on seven days with one missed day, so the streak on the last day was four. Logging the same day twice did not double count it.

Sunday polish: a command-line interface, several habits, and tests for edge cases such as a missed day and duplicate entries.

Stretch: a weekly summary, or exporting to CSV.

What it teaches: persistence, dates and designing small data structures, plus the edge cases that make even tiny programs interesting.

Turn each project into evidence

Finish with a README: what the project does, how to run it, one example of the output and what you would add next. Put it on GitHub. Three finished mini projects with clear READMEs show more than one abandoned large project, and each gives you a short story for interviews about a decision you made, such as planning file moves before executing them.

Traps that eat the weekend

The commonest trap is starting with setup: choosing a framework, designing a database, building a login page, before the core logic exists. Another is chasing a perfect dataset when a good-enough one is available today. A third is polishing the interface of something that does not work yet. Each of these feels productive and leaves you with nothing to show on Sunday night. Write the core first in a single script, even an ugly one, prove it works on real input, and only then make it nicer. Restructuring working code into functions on Sunday is quick; inventing structure for code that does not exist is not.

Choosing your own weekend project

Good weekend projects share three traits: real input you can get on Saturday morning, a result you can check by eye, and an obvious smallest version. Weak ones depend on accounts, approvals or data you have to wait for. If you are not sure, start from data you already have: your own spending export, a public dataset, or files on your computer.

For a longer, graded list of ideas, see Python projects for beginners. When you are ready for something that runs unattended, see Python for automation: a real project.

Projects like these are part of the Python Programming course.

Sources

• Bike Sharing Dataset (UCI Machine Learning Repository) — UCI Machine Learning Repository
• pathlib: Object-oriented filesystem paths (Python documentation) — Python Software Foundation
• json: JSON encoder and decoder (Python documentation) — Python Software Foundation