What Is a Block in Python? Absolute Beginners Tutorial

A block is a group of Python statements that belong together. Python uses indentation — not curly braces — to define where a block starts and ends. Understanding blocks is fundamental to reading and writing any Python code.

If you have written code in languages like JavaScript, Java, or C, you are used to curly braces { } marking where a section of code begins and ends. Python takes a different approach: it uses indentation — the whitespace at the start of a line — to communicate structure. That structure is built from blocks.

What Is a Block?

In Python, a block is a sequence of one or more statements that are grouped together and treated as a unit. The Python interpreter runs all the statements in a block together, in order, when that block is reached during execution.

Every block in Python is attached to a header line — a statement that tells Python what to do with the block. The block is always written on the lines immediately below that header line, indented inward from it.

Here is the most minimal example: a function definition with a one-line block as its body.

def greet():               # header line — ends with colon
    print("Hello, world!")  # block — indented 4 spaces

greet()                     # back at column 0 — outside the block

The print call on line 2 is the block. It is indented four spaces beneath the def header. Everything at that indentation level — until the indentation drops back — belongs to the function body.

The Header Line and the Colon

Every block in Python is introduced by a header line. Header lines always end with a colon (:). The colon is Python's way of saying "a block follows." Without the colon, Python raises a SyntaxError.

Header lines appear with several Python keywords:

Blocks in Functions, Conditionals, and Loops

Blocks in function definitions

When you define a function using def, everything indented beneath it is the function body — the block that runs each time the function is called.

def add(a, b):         # header line
    result = a + b      # block starts here
    return result        # still in the block

total = add(3, 7)      # back at module level — block has ended
print(total)           # prints 10

Blocks in if statements

An if statement uses a block to hold the code that should run only when the condition is true. An optional else block holds code that runs when the condition is false.

score = 85

if score >= 80:               # header line
    print("Pass")              # block A — runs when score >= 80
    print("Well done!")        # still in block A
else:                         # else header — at same level as if
    print("Try again")         # block B — runs when score < 80

print("Score recorded.")     # outside both blocks

Blocks in for loops

A for loop uses a block to hold the code that runs on each iteration. The block is executed once for every item in the sequence being iterated over.

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:          # header line
    upper = fruit.upper()     # block — runs 3 times
    print(upper)               # also in the block

print("Done")                 # outside the loop block

Nested Blocks

Blocks can be placed inside other blocks. This is called nesting. Each level of nesting requires one additional level of indentation. Python has no limit on how deeply blocks can be nested, though very deep nesting is generally a sign that code could be simplified.

def check_scores(scores):   # outer block header — level 0
    for score in scores:       # inner block header — level 1
        if score >= 80:         # nested block header — level 2
            print("Pass")        # nested block body — level 3
        else:                   # else header — back at level 2
            print("Fail")        # else block body — level 3

check_scores([90, 72, 85])   # back at level 0

Indentation Rules and Common Errors

Python enforces strict rules about indentation. Breaking those rules produces errors that prevent the program from running.

The four-space standard

PEP 8, the official Python style guide, recommends using 4 spaces per indentation level. Most editors insert 4 spaces automatically when you press Tab in a Python file. You can use a different consistent number of spaces (2 or 8 are sometimes used), but 4 is the universal convention and you should stick to it.

Never mix tabs and spaces

Python 3 treats tabs and spaces as different characters. Mixing them in the same block raises a TabError. Configure your editor to convert tabs to spaces automatically, and you will never encounter this issue.

Every block needs at least one statement

A block cannot be empty. If you need a block that intentionally does nothing — for example, while you plan what to put there later — use the pass statement as a placeholder.

def placeholder_function():
    pass    # valid empty block — does nothing

if True:
    pass    # also valid — useful during development

Block scope

A subtle but important point for beginners: in Python, only def and class blocks create a new scope — a separate namespace for variable names. Blocks created by if, for, while, and with do not create new scopes. Variables assigned inside those blocks are still accessible in the surrounding function or module.

for i in range(3):
    found = True          # assigned inside the for block

print(found)              # prints True — still accessible here

def my_func():
    inner = "secret"     # assigned inside the function block

# print(inner)           # would raise NameError — inner is function-scoped

# Problem: three levels of nesting to reach the real work
def process_order(order):
    if order is not None:
        if order["status"] == "confirmed":
            if order["items"]:
                print("Processing...")

# Solution: guard clauses exit early, main logic stays at one level
def process_order(order):
    if order is None:
        return
    if order["status"] != "confirmed":
        return
    if not order["items"]:
        return
    print("Processing...")  # stays at one level — easy to read

# Loop block — three lines to build a list
scores = [45, 82, 67, 90, 55]
passing = []
for s in scores:
    if s >= 60:
        passing.append(s)

# Comprehension — one line, same result, clearer intent
passing = [s for s in scores if s >= 60]

# Generator — memory-efficient when you only need to iterate once
total = sum(s for s in scores if s >= 60)

# Before: the loop body is doing too much
def send_reports(users):
    for user in users:
        if user["active"]:
            subject = f"Report for {user['name']}"
            body = f"Your score: {user['score']}"
            print(f"Sending to {user['email']}: {subject}")

# After: extracted helper — outer block reads like a summary
def send_report_to_user(user):
    subject = f"Report for {user['name']}"
    body = f"Your score: {user['score']}"
    print(f"Sending to {user['email']}: {subject}")

def send_reports(users):
    for user in users:
        if user["active"]:
            send_report_to_user(user)

# Long elif chain — repetitive and hard to extend
def describe_grade(grade):
    if grade == "A":
        return "Excellent"
    elif grade == "B":
        return "Good"
    elif grade == "C":
        return "Satisfactory"
    else:
        return "Needs improvement"

# Solution A: match statement (Python 3.10+)
def describe_grade(grade):
    match grade:
        case "A": return "Excellent"
        case "B": return "Good"
        case "C": return "Satisfactory"
        case _: return "Needs improvement"

# Solution B: dictionary dispatch — no block chain at all
_GRADE_LABELS = {"A": "Excellent", "B": "Good", "C": "Satisfactory"}

def describe_grade(grade):
    return _GRADE_LABELS.get(grade, "Needs improvement")

# Nested with blocks — two levels of indentation
with open("input.txt") as src:
    with open("output.txt", "w") as dst:
        dst.write(src.read())

# Single with block — one level, cleaner (Python 3.1+)
with open("input.txt") as src, open("output.txt", "w") as dst:
    dst.write(src.read())

# Parenthesised form for long lines (Python 3.10+)
with (
    open("input.txt", encoding="utf-8") as src,
    open("output.txt", "w", encoding="utf-8") as dst,
):
    dst.write(src.read())

# Dangerous: catches everything and hides all errors
try:
    value = int(user_input)
except:
    pass

# Correct: catch only what you can handle, surface the rest
try:
    value = int(user_input)
except ValueError:
    print(f"Expected a number, got: {user_input!r}")
    value = None

# pass: valid but tells readers nothing
def calculate_tax(amount, rate):
    pass

# Docstring stub: satisfies the block, documents intent
def calculate_tax(amount, rate):
    """Return amount * rate. TODO: handle zero-rate and negative values."""