Python Projects for Beginners: 15 Ideas to Build

Many lists of beginner Python projects are unordered: a calculator next to a web scraper next to a chatbot. That makes it hard to know what to build first, or why a project feels impossible. The fifteen projects below are ordered as a ladder. Each one needs what the previous ones taught plus one new idea, named in the table. Work from the top and you will rarely hit a project that needs three things you haven't met yet.

Every project uses only Python's standard library, except where noted, so there is nothing to install until project 13. Each comes with a "done when" test and a stretch goal. Stop at "done when" if you are short of time. The stretch goals are where much of the learning happens, so come back to them.

The ladder at a glance

If you are still learning the language itself, our Python learning roadmap teaches the concepts in the same order.

Projects 1–4: getting comfortable

1. Bill splitter

Ask for a bill total, a tip percentage and the number of people, and print each person's share.

Done when: it prints a share rounded to two decimal places and refuses zero people instead of crashing. Stretch: try round(2.675, 2). Python prints 2.67, not 2.68, because 2.675 cannot be stored exactly as a binary float; the documentation for round() explains this. Then redo the calculation with the decimal module and see the difference.

2. Number-guessing game

The program picks a number from 1 to 100 with random.randint, and the player guesses until they get it, with "higher" or "lower" hints.

Done when: it counts attempts and handles a guess that isn't a number. Stretch: add difficulty levels that change the range and the number of guesses allowed.

3. Rock, paper, scissors

Play against the computer, best of five.

Done when: the winner of each round is decided by looking up a dictionary such as {"rock": "scissors", ...} (what beats what) rather than a chain of nine if statements. Stretch: add "lizard" and "Spock" and notice how little code changes. That is the payoff of storing rules as data.

4. Timed times-table quiz

Ask ten random multiplication questions and report the score and the total time taken.

Done when: it uses time.perf_counter() to measure the time and re-asks, rather than crashes, on non-numeric answers. Stretch: keep a list of the questions the player got wrong and repeat them at the end.

Projects 5–8: working with data in memory

5. Word counter

Read a text file and print its ten most common words. Build it first with a plain dictionary, then again with collections.Counter, and compare.

Done when: "The" and "the" count as the same word and punctuation doesn't create fake words like "end.". Stretch: ignore common words such as "a" and "the", loaded from a second file.

6. To-do list

A menu loop: add a task, list tasks, mark one done, delete one, quit.

Done when: deleting a task that doesn't exist prints a clear message. Stretch: add due dates and list overdue tasks first.

7. Contact book

Store names, phone numbers and emails, and search by partial name.

Done when: searching "pri" finds "Priya" and "Supriya", regardless of case. Stretch: reject an email address without an "@" and a phone number with letters in it.

8. Password generator

Generate passwords of a chosen length from letters, digits and symbols. This project teaches a real security lesson. Python's random module must not be used for security; the documentation directs you to the secrets module instead.

import secrets
import string

alphabet = string.ascii_letters + string.digits + string.punctuation

def make_password(length=16):
    return "".join(secrets.choice(alphabet) for _ in range(length))

print(make_password())   # different every run

Done when: the user chooses the length and whether to include symbols. Stretch: guarantee at least one digit and one symbol in every password without making the result predictable.

Projects 9–12: programs that remember and automate

9. Expense tracker

Add expenses with a category and amount, list them, and show totals per category. Save everything to a JSON file so the data survives a restart.

Done when: closing and reopening the program keeps every expense, and a missing or empty file on first run causes no error. Stretch: add a monthly summary. This is also the project to split your code into small functions, one per menu option.

10. CSV report

Take a CSV export, such as a bank statement or a sales list, and produce a summary: totals by category and month, and the largest single entry.

Done when: it reads the file with the csv module, not by splitting lines on commas, because quoted fields can contain commas. Stretch: write the summary to a new CSV file.

11. File organiser

Sort the files in a folder into subfolders by extension. Because this program moves real files, build it with a dry-run mode that only prints what it would do:

from pathlib import Path
import shutil

def organise(folder, dry_run=True):
    for path in sorted(Path(folder).iterdir()):
        if not path.is_file():
            continue
        target = path.parent / (path.suffix.lstrip(".").lower() or "no-extension")
        print(f"{path.name} -> {target.name}/")
        if not dry_run:
            target.mkdir(exist_ok=True)
            shutil.move(path, target / path.name)

organise("downloads-copy")

On a test folder it prints the plan and leaves the files where they are:

notes.txt -> txt/
photo.jpg -> jpg/
README -> no-extension/
report.PDF -> pdf/

Done when: a dry run on a copy of a real folder shows a plan you agree with, and only then do you run it for real. Stretch: handle two files with the same name arriving in one subfolder.

12. Command-line converter

Turn any earlier calculator into a proper command-line tool with argparse, for example python convert.py 5 km mi.

Done when: python convert.py --help prints usable help, and an unknown unit gives a clear error. Stretch: support converting a whole column of a CSV file.

Projects 13–15: the outside world, databases and tests

13. Weather checker

Fetch the current temperature for your city from a public API and print it. Open-Meteo needs no API key for non-commercial use, which keeps this project simple:

import json
from urllib.request import urlopen
from urllib.error import URLError

URL = ("https://api.open-meteo.com/v1/forecast"
       "?latitude=17.39&longitude=78.49&current=temperature_2m,wind_speed_10m")

def current_weather():
    try:
        with urlopen(URL, timeout=10) as response:
            data = json.load(response)
    except URLError as err:
        return f"Could not reach the weather service: {err.reason}"
    now = data["current"]
    units = data["current_units"]
    return f"{now['temperature_2m']}{units['temperature_2m']}, wind {now['wind_speed_10m']} {units['wind_speed_10m']}"

print(current_weather())

The coordinates are Hyderabad's; change them to your city. The important lines are the timeout and the except. A program that calls a network service has to decide what happens when the service is slow or unreachable.

Done when: it takes a city's coordinates as arguments and still prints a sensible message with the network off. Stretch: switch to the third-party requests library and compare the code.

14. Quiz app with a database

Store quiz questions in SQLite using the built-in sqlite3 module, ask them in random order, and record each attempt's score.

Done when: you insert data with parameterised queries (? placeholders), never by pasting values into the SQL string; the sqlite3 documentation explains why. Stretch: show the player's best score and average per topic using SQL GROUP BY.

15. Habit tracker with tests

Record the days a habit was done and report the current streak. The streak logic is small enough to test properly, so write the tests alongside it:

from datetime import date, timedelta

def current_streak(done_days, today):
    done = set(done_days)
    streak, day = 0, today
    while day in done:
        streak += 1
        day -= timedelta(days=1)
    return streak

def test_current_streak():
    today = date(2026, 9, 24)
    assert current_streak([], today) == 0
    assert current_streak([today], today) == 1
    assert current_streak([today, today - timedelta(days=1)], today) == 2
    # a gap breaks the streak
    assert current_streak([today, today - timedelta(days=2)], today) == 1

Install pytest with python -m pip install pytest, run pytest, and the test passes. Our pytest guide for beginners explains the setup.

Done when: habits are objects (a class or a dataclass), data is saved between runs, and every rule has a test. Stretch: decide what should happen if today isn't done yet but yesterday was. Should the streak still count? Write the test first, then the code.

Making the projects count

A project only helps a job application if someone can see it. Put each one in its own folder in a GitHub repository with a short README: what it does, how to run it, and what you would improve. Projects 9 to 15 are the ones worth showing; the earlier ones are practice. When you are ready for bigger builds, our Python automation scripts are a natural next step. If you want structured practice, the GloryTecks Python Programming course includes projects such as a REST API application and an automation tool.