You finish the tutorial. You type every line, run every example, watch it all work. Then you open a blank editor to build something of your own – and nothing comes. Not one idea.
Almost every beginner hits the tutorial trap (usually right after their first Python course). You can read about for-loops all day, but the moment no one tells you what to type, your brain freezes.
Knowing what code looks like and writing it yourself are two different skills. The way to go from one to the other is to build stuff. On your own.
And no, it doesn't have to be useful. You're not shipping an app or helping out on open source. You just need small, silly programs that run – one after another – until your brain stops freezing.
That's what this post is for. Below are 13 easy Python projects, each one finishable in 10 minutes to an hour. Each teaches one or two things, no more. And each ends with a file that runs on your machine, written by you.
Not quite ready to build just yet? No worries at all! Every great journey starts with the fundamentals. Learn the computer basics and build a rock-solid foundation before you take the next step.
Why Build instead of Watching Tutorials?
Because tutorials feel like learning, but they do the thinking for you. Building makes you decide. You have to name the variable, pick the right loop, work out why your code printed None instead of the number you wanted.
Small projects beat the motivation problem too. A two-week project sounds impressive, right up until you stall and never come back. A 30-minute project finishes today. You get a working file and a small win, and that win is what gets you to open the editor again tomorrow.
1. Number Guessing Game
The classic. The computer picks a number between 1 and 100, you guess, and it tells you "too high" or "too low" until you crack it. Most coders' first real program, and for good reason.
import random
secret = random.randint(1, 100)
guesses = 0
while True:
guess = int(input("Guess a number (1-100): "))
guesses += 1
if guess < secret:
print("Too low")
elif guess > secret:
print("Too high")
else:
print(f"Got it in {guesses} guesses")
break
What you pick up: while loops, conditionals, the random module, and turning input into a number. Once it works, add a max-guesses limit so the game ends if you don't crack it in time.
2. Mad Libs Generator
Ask the user for a few words – a noun, a verb, an adjective – drop them into a silly sentence, and print the result. Ten minutes, start to finish.
noun = input("Noun: ")
verb = input("Verb: ")
adjective = input("Adjective: ")
place = input("A place: ")
story = f"Yesterday I went to the {place} and saw a {adjective} {noun} that started to {verb}."
print(story)
3. Dice Roller
Roll one die. Roll two. Roll a 20-sided die for game night. Two lines of logic, and whatever you want to wrap around them.
import random
def roll(sides=6, count=1):
return [random.randint(1, sides) for _ in range(count)]
print(roll(6, 2)) # rolls two six-sided dice
print(roll(20)) # rolls one d20
What you pick up: functions with default values, list comprehensions, and calling the same function with different inputs. Once it works, add a tiny menu so the user picks the sides and count when they run it.
4. Simple Calculator
Add, subtract, multiply, divide. Two numbers, one operator. Yes, calculators already exist. That's not the point. The point is wiring the pieces together yourself and noticing what you forgot the first time round.
def calc(a, b, op):
if op == "+": return a + b
if op == "-": return a - b
if op == "*": return a * b
if op == "/":
if b == 0:
return "Can't divide by zero"
return a / b
a = float(input("First number: "))
op = input("Operator (+, -, *, /): ")
b = float(input("Second number: "))
print(calc(a, b, op))
What you pick up: writing a function, branching with if, and handling that one tricky edge case (divide by zero). Want a challenge? Add chained operations.
5. Rock, Paper, Scissors
You pick one, the computer picks one, the rules decide who wins. Great for practicing a small game loop, and for getting comfy with a dictionary used as a lookup table.
import random
options = ["rock", "paper", "scissors"]
wins_against = {"rock": "scissors", "paper": "rock", "scissors": "paper"}
you = input("Pick rock, paper, or scissors: ").lower()
cpu = random.choice(options)
print(f"Computer picked {cpu}.")
if you == cpu:
print("Tie")
elif wins_against[you] == cpu:
print("You win")
else:
print("Computer wins")
What you pick up: dictionaries for fast lookups, random.choice, and comparing strings. Wrap it in a while loop and keep score across rounds – you've built a tiny game in an afternoon.
6. Password Generator
Make a random password of N characters using letters, numbers, and symbols. Useful, easy, done in 15 minutes. The kind of thing you might actually keep around.
import random
import string
def make_password(length=12):
pool = string.ascii_letters + string.digits + string.punctuation
return "".join(random.choice(pool) for _ in range(length))
print(make_password(16))
What you pick up: the string module, joining characters into one string, and pulling random characters from a pool. Add a switch to skip symbols, for the systems that hate punctuation – and there are more of those than you'd think.
7. To-Do List in the Terminal
A simple add / list / remove menu, right in the terminal. No database, no setup, just a Python list that lives until you quit. That's enough to learn from.
todos = []
while True:
cmd = input("Command (add/list/remove/quit): ")
if cmd == "add":
todos.append(input("Task: "))
elif cmd == "list":
for i, t in enumerate(todos, 1):
print(f"{i}. {t}")
elif cmd == "remove":
idx = int(input("Index to remove: ")) - 1
if 0 <= idx < len(todos):
todos.pop(idx)
elif cmd == "quit":
break
What you pick up: a menu-driven program, changing a list, enumerate, and the little trick for 1-based numbering. The next version saves your tasks to a text file so they survive between runs. That's when it starts feeling like a real app.
Coddy turns Python practice into a daily habit with gamified streaks, XP, and bite-sized lessons that keep you opening the app even when motivation drops.
8. Word and Character Counter
Paste in text, get back the word count, character count, and most common word. Handy when you're writing for tight word limits – and there are a lot of those once you start looking.
from collections import Counter
text = input("Paste your text: ")
words = text.split()
chars = len(text)
most_common = Counter(words).most_common(1)
print(f"Words: {len(words)}")
print(f"Characters: {chars}")
print(f"Most common word: {most_common[0][0]} ({most_common[0][1]} times)")
What you pick up: the collections module, .split(), and reading values out of what Counter returns. Try skipping short words like "the" and "and" for better results – otherwise your top word is always "the", which tells you nothing.
9. Tip Calculator
Bill total, tip percentage, split between people. The kind of small tool you'll actually reach for years from now, long after you've forgotten you wrote it.
bill = float(input("Bill total: "))
tip_pct = float(input("Tip percentage (e.g., 18): "))
people = int(input("How many people: "))
tip = bill * (tip_pct / 100)
total = bill + tip
per_person = total / people
print(f"Tip: {tip:.2f}")
print(f"Total: {total:.2f}")
print(f"Per person: {per_person:.2f}")
What you pick up: math operators, turning input to numbers, and rounding to two decimals with :.2f. Extend it by rounding the per-person amount up, so nobody at the table gets short-changed.
10. Countdown Timer
You type how many seconds, the program counts down to zero. Tiny, satisfying, and actually useful for break timers and pomodoros once it's built.
import time
seconds = int(input("Seconds: "))
while seconds >= 0:
mins, secs = divmod(seconds, 60)
print(f"{mins:02d}:{secs:02d}", end="\r")
time.sleep(1)
seconds -= 1
print("Time's up ")
What you pick up: the time module, divmod for splitting numbers into minutes and seconds, and the \r trick for in-place updating the same line. That end="\r" is what makes the timer feel real, instead of dumping a wall of text into your terminal.
11. Random Quote Generator
A list of quotes – motivational, funny, programming-related, whatever you like – and the program prints one at random when you run it. Almost too easy. Do it anyway.
import random
quotes = [
"The only way to learn a new programming language is by writing programs in it.",
"Programs must be written for people to read, and only incidentally for machines to execute.",
"Premature optimization is the root of all evil.",
"Simplicity is the soul of efficiency.",
"Code is like humor. When you have to explain it, it's bad.",
]
print(random.choice(quotes))
What you pick up: list basics, random.choice, and the smallest useful program in the whole language. Hook it into your terminal startup for a fresh quote every time you open a shell – the kind of small, silly thing that quietly makes coding more fun.
12. Hangman (Simplified)
Pick a secret word, show dashes, let the user guess letters, and end after six wrong tries. Heavier than the others here, but still doable in about an hour if you keep it simple.
import random
words = ["python", "syntax", "variable", "function", "module"]
secret = random.choice(words)
guessed = set()
wrong = 0
while wrong < 6:
display = "".join(c if c in guessed else "_" for c in secret)
print(display)
if "_" not in display:
print("You won")
break
letter = input("Guess a letter: ").lower()
if letter in secret:
guessed.add(letter)
else:
wrong += 1
print(f"Wrong. {6 - wrong} tries left.")
else:
print(f"You lost. The word was {secret}.")
What you pick up: sets, building a string with a condition inside it, and the lesser-known while-else – the else runs only when the loop ends without a break. Tired of those five words? Read them from a file instead. (You will get tired of them. Soon.)
13. Unit Converter
Convert between common units: Celsius to Fahrenheit, kilometres to miles, kilograms to pounds. Practical, quick to finish, and the kind of thing you'll catch yourself reaching for later.
def c_to_f(c):
return c * 9/5 + 32
def km_to_mi(km):
return km * 0.621371
def kg_to_lb(kg):
return kg * 2.20462
print("1. Celsius to Fahrenheit")
print("2. Kilometers to miles")
print("3. Kilograms to pounds")
choice = input("Pick a converter: ")
value = float(input("Value: "))
if choice == "1":
print(c_to_f(value))
elif choice == "2":
print(km_to_mi(value))
elif choice == "3":
print(kg_to_lb(value))
What you pick up: several small functions in one file, a basic menu, and branching on what the user types. Once the forward versions work, add the reverse ones (F to C, miles to km). Same idea, half the effort, double the practice.
How to Make These Projects Stick
Building one project is a moment. Building one a day for two weeks is a habit. And the difference between people who get past beginner Python and people who don't isn't talent or time. It's whether the practice keeps happening.
A few things that help, roughly in order:
-
Type the code, don't copy paste it! Boring and repetitive, sure. Also the only way the patterns get into your hands instead of just your eyes. The first time you type
import randomfrom memory, something clicks. -
Break it on purpose. Once it works, delete a line, comment out a function, or rename a variable, and watch what happens. Fixing it teaches you more than building it did. (That one isn't obvious until you've tried it.)
-
Build the same project twice. A week later, try the number guessing game again from scratch. The second time shows you what you actually kept, which can be less than you'd hope. And that's fine!
-
Add one thing. Take any project above and bolt on a small extra. Save the to-do list to a file. Make the dice roller print its results one by one. The extra bit is where the learning is, because nobody has written down exactly how to do your version.
If daily practice is the part you keep losing, that's the whole reason Coddy exists. Short, five-minute Python lessons, a streak system that pulls you back when motivation dips, and AI hints from Bugsy right inside the lesson when you get stuck.
Every course is free to start, Python included. We built it for the exact spot you're in: done with tutorials, not yet sure of yourself, and looking for reps that don't eat your whole evening.
What Should You Build Next?
When the projects above start to feel too easy, you've already crossed the line you were trying to cross. Nice work! The next stop is medium-tier projects – the kind that pull in a library or two and a bit of file or network input/output. A few that step things up:
- A weather app using the
requestslibrary and a free weather API - A web scraper with
BeautifulSoupthat grabs headlines from a site you read - A text-based adventure game with a few rooms and an inventory list
- A pomodoro timer that logs your sessions to a CSV file
- A simple Flask app that serves one page with a random joke
None of these are advanced. They stack two or three things you already know, plus one new module. Pick whichever sounds the most fun, because that's the one you'll actually finish.
Tutorials fall apart at the moment they hand you off and ask you to think for yourself. Projects, even silly ones, force the thinking. Do enough of them and the tutorial trap stops being a trap.
Coddy gets you out of passive watching and into actual coding with five-minute Python lessons, daily streaks, and Bugsy, an AI assistant that hints instead of spoiling the answer.
Share this article
About the Author
Coddy Team
Editorial Team
Frequently Asked Questions
What's the easiest Python project for a beginner?
The number guessing game is the standard answer. Short, uses inputs, loops, and conditionals in a single program, and it feels like an actual game when it runs. Most people can finish it in 20 minutes, even if they've only just learned what a while loop does.
How long should easy Python projects take?
Anywhere from ten minutes to an hour. If you're spending three hours on one, it's either too hard for where you are right now, or you've fallen into a debugging rabbit hole that's worth pulling out of. Pick a smaller one, finish it, come back.
Do I need to install anything to do these projects?
Yes if you want to run them locally, no if you don't. Installing Python from python.org takes about five minutes. Or skip the install entirely and run them in an in-browser playground like the one inside Coddy, which is the no-setup option.
Are these Python projects good for a resume?
Not on their own, no. A resume project usually needs more depth, like a small web app, a script you used to automate something real at work, or a contribution to an open-source project. The 13 here are confidence-building stepping stones, not portfolio pieces. They get you ready to build the resume-worthy stuff later.
What Python concepts will I learn from these projects?
Across the 13, you'll touch variables, input and output, conditionals, loops, functions, lists, dictionaries, sets, the random module, the time module, f-strings, list comprehensions, and a couple of standard library modules like collections and string. That's a solid working chunk of the language.
What if my code doesn't work?
Read the error message. Most beginner errors say almost exactly what went wrong, usually on the line right above where you started panicking. Google the error message, ask an AI assistant like Bugsy to explain it, or paste it into a forum. Debugging is a skill that builds the same way coding does, through reps.
Can I do these projects on a phone?
Yep. Python runs in mobile coding environments, including the Coddy app, which has a code playground built in. You won't write enterprise software on a screen the size of your hand, but small practice projects work fine that way, and a lot of people get more practice in on a phone than they ever would on a laptop.
What's the next step after easy Python projects?
Medium projects that combine more concepts: a small web scraper, an API client, a Flask or Django app that serves a page, a script that processes files in a folder. Anything that pulls in a new library and connects to something external is a useful next layer. Pick one that solves a small problem in your own life. That's the one you'll finish.
