Enable JavaScript for interactive exercises and progress tracking.

Python9 topics410+ exercises

Python Syntax Practice

Write Python from memory, not from Stack Overflow.

Short daily reps. Spaced repetition automatically brings back what you keep forgetting.

You know Python. You just can't always remember it on demand. Was it extend or append? Does *args come before **kwargs? What's the f-string syntax for padding again?

These blanks slow you down more than you'd think. A short diagnostic session shows you exactly which patterns you keep forgetting—comprehensions, function signatures, string methods, whatever it is. Then the algorithm brings those back right before you'd forget them again.

This isn't another tutorial. It's targeted practice based on what your memory actually needs. Ten minutes a day, no setup, and you stop reaching for Stack Overflow.

Popular topics include Python Comprehensions Practice: List, Dict, Set & Generator Expressions, Python Function Arguments Practice: defaults, *args, keyword-only, **kwargs, Python Loops Practice: range(), enumerate(), zip(), break/continue, for-else.

Built for Python Learners

Great for

Prepping for Python or data science interviews.
Devs who know the language but still google basic syntax.
Students who want to actually retain what they learn.
Anyone writing Python for data, scripting, or automation.

You'll be able to

Reach for the right comprehension syntax on the first try.
Get function signatures, defaults, and *args/**kwargs right without checking.
Parse and format strings without a docs tab open.
Write try/except blocks and class definitions from memory.

Practice by Topic

Pick a concept and train recall with small, focused reps.

37 exercisesGotchas included

Python Comprehensions Practice

Stop blanking on where the if goes—filter vs ternary, nested for order, dict/set syntax.

Show 3 gotchas

Filter if goes at the end ([x for x in xs if cond]), ternary goes at the start ([a if cond else b for x in xs]).
Nested for-clauses match nested loop order—leftmost is outer.
(expr for x in xs) is a generator, not a tuple.

58 exercisesGotchas included

Python Functions Practice

Get parameter order right the first time—positional-only, *args, keyword-only, **kwargs.

Show 3 gotchas

Mutable defaults (like []) are evaluated once and shared across calls—use None sentinel.
Everything after bare * is keyword-only.
/ marks positional-only parameters (Python 3.8+).

70 exercisesGotchas included

Python Loops Practice

Stop off-by-one errors with range() and zip() truncation bugs.

Show 3 gotchas

range(5) gives 0-4, not 0-5—stop is always excluded.
zip() silently truncates to shortest—use strict=True (3.10+) to catch length mismatches.
for-else runs when there's no break, not when condition is false.

35 exercisesGotchas included

Python Conditionals Practice

Know when if x betrays you—0, "", and [] are all falsy.

Show 3 gotchas

if x fails when 0 or "" are valid values—use if x is not None.
and/or return operands, not booleans—0 or default replaces 0.
Use is None not == None for identity checks.

53 exercisesGotchas included

Python Strings Practice

Master split() vs split(" "), the strip() character-set trap, and f-string formatting.

Show 3 gotchas

split() groups whitespace and strips ends; split(" ") splits on literal space only.
rstrip(".txt") removes any of t, x, period—use removesuffix(".txt").
join() requires all strings—use map(str, items) for mixed types.

86 exercisesGotchas included

Python Collections Practice

Stop confusing append vs extend, and know when dict.get() saves you from KeyError.

Show 3 gotchas

append(x) adds one item (even if x is a list); extend(xs) adds each element.
Use get(key, default) when missing keys are expected, d[key] when they're bugs.
list.sort() returns None (in-place); sorted(list) returns a new list.

31 exercisesGotchas included

Python Error Handling Practice

Write try/except/else/finally correctly and stop losing context with raise.

Show 3 gotchas

Bare except: catches KeyboardInterrupt—use except Exception: at minimum.
else runs only if no exception—keeps try block minimal.
Use raise NewError() from original to preserve traceback context.

31 exercisesGotchas included

Python OOP Practice

Get self, super().__init__(), and class vs instance attributes right.

Show 3 gotchas

Mutable class attributes (items = []) are shared across all instances.
Forgetting super().__init__() means parent attributes don't get set.
Implement __repr__ before __str__—debuggers use it as fallback.

9 exercisesGotchas included

Python Decorators Practice

Understand the wrapper pattern and stop forgetting @functools.wraps.

Show 3 gotchas

@g above @f means f = g(f(original))—bottom decorator wraps first.
Without @wraps(func), debuggers show wrapper name, not original.
Decorators with arguments need three layers: factory → decorator → wrapper.

Python Cheat Sheets

Copy-ready syntax references for quick lookup

String Methods List Comprehensions Dictionary Methods f-strings Decorators File I/O Error Handling Loops OOP Regex (re module)

What You'll Practice

Real Python patterns you'll type from memory

Function parameter order

def example(pos_only, /, pos_or_kw, *args, kw_only, **kwargs):

Nested comprehension (flatten)

flat = [x for row in matrix for x in row]

f-string padding

f"{name:>10}"  # right-align in 10 chars

try/except/else/finally

try:
    result = parse(data)
except ValueError:
    result = default
else:
    save(result)
finally:
    cleanup()

Walrus operator

if (match := pattern.search(text)):
    print(match.group())

Safe mutable default

def add(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

Exception chaining

except DatabaseError as e:
    raise AppError("Query failed") from e

Decorator with wraps

from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        ...
    return wrapper

Sample Exercises

Example 1Difficulty: 2/5

Create a list of squares from 1 to 5 using a list comprehension

[x**2 for x in range(1, 6)]

Example 2Difficulty: 1/5

Write the function header for `add_item` with one parameter named `item`

def add_item(item):

Done Googling Python syntax?

Ten minutes a day. No setup. The syntax sticks.

Why this works

You forget things on a curve: fast at first, then slower. The algorithm schedules reviews right before each pattern fades. A few cycles of that and the syntax just stays.

What to expect

Week 1: You'll see your weak spots clearly—maybe f-string formatting, maybe the difference between *args and kwargs. The algorithm surfaces patterns you blank on.

Week 2-4: Intervals start stretching. Things you got right move to 2-day, 4-day, then weekly reviews. You're not re-learning—you're locking in.

Month 2+: Most syntax you need daily is automatic. Reviews take 10 minutes. You still practice, but now it's maintenance, not catch-up.

FAQ

Is this for beginners or experienced developers?

Both. If you are learning Python, this builds your foundation faster. If you already know Python but keep looking things up, this fixes that.

How long are sessions?

About 10 minutes. Short enough for a coffee break.

Do I need to install anything?

No. Everything runs in the browser.

Sources

Python Tutorial: Data Structures Python Tutorial: Defining Functions Format Specification Mini-Language Built-in Exceptions

Try it. It takes two minutes.

Free daily exercises with spaced repetition. No credit card required.