Python Indentation and Syntax Explained — Rules, Errors and Best Practices

Most programming languages use curly braces {} to group blocks of code together. Python threw that convention out the window and said: let's use whitespace instead. That sounds wild at first — but it's actually one of the smartest design decisions in Python's history, because it forces every Python developer on the planet to write code that looks consistent and readable, whether they're a beginner or a 20-year veteran.

The problem indentation solves is this: without some way of grouping lines together, Python would have no idea which lines should run inside an if-statement, which lines belong to a loop, or where a function's body begins and ends. In languages like JavaScript or Java, those curly braces do that job. In Python, the indentation level IS the signal. Add it correctly, and Python understands your intentions perfectly. Get it wrong, and Python throws an IndentationError before your program even starts running.

By the end of this article, you'll understand exactly how Python's indentation system works, why it exists, what the golden rules are, and — most importantly — how to avoid the two mistakes that trip up virtually every beginner in their first week of Python. You'll be able to read and write properly structured Python code with confidence.

How Python Reads Your Code — Blocks, Colons and Indentation

Every time Python sees a colon (:) at the end of a line, it's expecting the next line to be indented. That colon is Python's way of saying 'a new block is about to begin.' This applies to if-statements, for loops, while loops, function definitions, class definitions — anything that introduces a group of related instructions.

A 'block' is just a chunk of code that belongs together and runs as a unit. Think of it like a folder on your computer. The colon opens the folder, the indented lines are the files inside, and the moment you stop indenting, you've closed the folder.

The standard in Python is to use 4 spaces per indentation level. This is defined in PEP 8 — Python's official style guide. You can technically use 2 spaces or even a tab, but 4 spaces is what the entire Python community agreed on, and mixing different amounts will cause errors. Most modern code editors (VS Code, PyCharm) automatically insert 4 spaces when you press the Tab key in a Python file, so you rarely have to count manually.

# This script demonstrates how indentation creates blocks in Python.
# We're checking if a student has passed their exam.

student_score = 78
passing_score = 60

# The colon at the end of the 'if' line opens a new block.
# Everything indented beneath it belongs to that block.
if student_score >= passing_score:
    print("Congratulations, you passed!")   # This line is INSIDE the if-block (4 spaces in)
    print("Your score:", student_score)      # This line is also INSIDE the if-block

# This line has NO indentation — it's back at the top level.
# It runs regardless of whether the student passed or not.
print("Exam results have been processed.")

Nested Indentation — Blocks Inside Blocks

Here's where things get really interesting. Blocks can live inside other blocks — this is called nesting. Each level of nesting adds another 4 spaces of indentation. Think of it like Russian nesting dolls: each doll sits inside a larger one, and the indentation tells Python exactly which doll you're currently looking at.

Nesting is extremely common in real Python code. You'll have loops that contain if-statements, functions that contain loops, and so on. Python tracks the indentation level precisely to know which block each line belongs to.

The key rule to remember: all lines at the SAME indentation level belong to the SAME block. The moment a line steps back to a previous indentation level, that block is finished. Python doesn't need a closing brace or an 'end' keyword — the indentation tells the whole story.

# Real-world example: checking a list of students and awarding grades.
# This shows two levels of nesting — a loop containing an if/elif/else block.

student_scores = [92, 55, 74, 88, 40]

for score in student_scores:               # Level 1 block starts here (4 spaces)
    if score >= 90:                        # Level 2 block starts here (8 spaces)
        grade = "A"                        # Level 3 block — inside the 'if' (12 spaces)
    elif score >= 70:
        grade = "B"                        # Level 3 block — inside the 'elif'
    elif score >= 60:
        grade = "C"                        # Level 3 block — inside the second 'elif'
    else:
        grade = "F"                        # Level 3 block — inside the 'else'

    # Back to level 2 — still inside the for loop, but outside the if/elif/else
    print(f"Score: {score} | Grade: {grade}")

# Back to level 0 — outside everything
print("All grades have been assigned.")

Common IndentationError and SyntaxError Messages — What They Mean

Python's error messages around indentation are some of the most beginner-friendly in any language — once you know how to read them. There are three errors you'll encounter regularly, and each one tells you exactly what went wrong.

An 'IndentationError: expected an indented block' means you used a colon but forgot to indent the next line. An 'IndentationError: unexpected indent' means you indented a line when Python wasn't expecting it — usually a stray space somewhere. An 'IndentationError: unindent does not match any outer indentation level' is the sneaky one — it usually means you mixed tabs and spaces, which look identical on screen but are completely different characters to Python.

The fix for almost all of these is the same: make sure you're using 4 spaces consistently, never mixing tabs and spaces. In VS Code, you can see invisible characters (spaces vs tabs) by enabling 'Render Whitespace' in settings. This single setting has saved countless hours of debugging for beginners.

# -------------------------------------------------------
# EXAMPLE 1: IndentationError — expected an indented block
# -------------------------------------------------------

# BROKEN CODE (do not run this — it will crash):
# if temperature > 100:
# print("Too hot!")    <-- ERROR: no indent after the colon

# FIXED CODE:
temperature = 105

if temperature > 100:
    print("Warning: temperature is dangerously high!")  # 4 spaces — correct

# -------------------------------------------------------
# EXAMPLE 2: IndentationError — unexpected indent
# -------------------------------------------------------

# BROKEN CODE (do not run this — it will crash):
# product_price = 29.99
#     print(product_price)   <-- ERROR: indented for no reason

# FIXED CODE:
product_price = 29.99
print(f"Product price: ${product_price}")  # No indent — this is top-level code

# -------------------------------------------------------
# EXAMPLE 3: Mixing tabs and spaces (the silent killer)
# -------------------------------------------------------

# BROKEN CODE conceptually (hard to show here, but explained):
# Line A uses 4 SPACES to indent
# Line B uses 1 TAB to indent
# They look the same on screen but Python sees them as different characters
# Result: TabError or IndentationError

# THE FIX: In your editor, set 'Insert spaces' (not tabs) and use 4 spaces.
# In VS Code: bottom-right corner — click 'Spaces: 4' to confirm your setting.

print("No indentation errors here — this code is clean.") # Runs fine

Python Syntax Rules Beyond Indentation — The Full Picture

Indentation is the most famous part of Python syntax, but there are a few other rules worth knowing from day one. First: Python is case-sensitive. A variable named 'Score' and one named 'score' are completely different things to Python. Second: statements in Python end at the end of the line — no semicolons needed (though Python does allow them, nobody uses them).

For long lines you can't fit on one screen, Python lets you continue onto the next line using a backslash (\) at the end, or by opening any bracket ( [ { — Python knows the statement continues until the bracket is closed. This is called implicit line continuation and it's the cleaner approach.

Comments start with a # symbol and run to the end of that line. Python completely ignores them — they're purely for human readers. Inline comments (on the same line as code) should be separated by two spaces before the # sign, according to PEP 8. These are small rules, but following them from day one means your code will be readable and professional from the very start.

# Demonstrating Python syntax rules beyond indentation

# RULE 1: Case sensitivity
user_name = "Alice"     # This is one variable
User_Name = "Bob"       # This is a COMPLETELY different variable
print(user_name)        # Prints: Alice
print(User_Name)        # Prints: Bob

# RULE 2: No semicolons needed (but allowed — just not Pythonic)
item_count = 10         # Clean Python style
item_price = 4.99       # Each statement on its own line

# RULE 3: Implicit line continuation inside brackets
# Use this when a calculation or list is too long for one line
total_cost = (
    item_count *        # Python knows the statement isn't done
    item_price          # because the bracket hasn't closed yet
)
print(f"Total cost: ${total_cost:.2f}")

# RULE 4: Explicit line continuation with backslash (less preferred)
discount_message = "You saved " \
                   "10% today!"
print(discount_message)

# RULE 5: Comments — single line
# This is a comment. Python ignores everything after the # symbol.
print("Python syntax is clean and readable")  # Inline comment: 2 spaces before #

Frequently Asked Questions