Python Code Blocks Explained

A code block is a group of statements that belong together. In Python, blocks are not marked with curly braces or special keywords like begin and end. Instead, Python uses indentation: the amount of whitespace at the start of a line determines which block that line belongs to. This is different from most other programming languages, and understanding it is essential before you start writing loops, conditionals, and functions.

You have already seen blocks in action if you have followed the earlier articles on Python syntax and indentation. Every time you write a colon at the end of a line and then indent the next line, you are creating a code block. The colon says "a block is about to start," and the indented lines that follow are the body of that block. When you stop indenting and return to the previous level, the block ends.

How Python recognizes blocks

Python's parser processes your file line by line. When it encounters a colon at the end of a statement, it expects the next line to be indented more than the current line. This increase in indentation creates an INDENT token internally, marking the beginning of a new block. When a line appears with less indentation than the current block, Python generates DEDENT tokens to close the block.

This means a block is defined entirely by its indentation relative to the line that introduced it. The line with the colon is the block header, and every indented line after it belongs to the block. A block ends when a line returns to the same indentation level as the header, or when the file ends. There is no closing marker to write and no closing brace to forget.

Here is a small example that shows a block inside an if statement:

python

if temperature > 30:
    print("It is hot outside.")
    print("Drink water.")
print("Weather check complete.")

The two print calls are indented under the if line, so both run only when the condition is true. The third print sits at the left margin, outside the block, and runs regardless of the condition. This visual relationship between indentation and logic is the defining feature of Python's syntax.

Nesting blocks inside blocks

Blocks can contain other blocks, and each level of nesting adds another four spaces of indentation. This is how you express compound logic: a loop inside a function, a conditional inside a loop, a loop inside another loop. Python tracks the indentation stack as it parses your file, and it enforces strict consistency at every level.

Consider a function that contains a loop, which in turn contains a conditional:

python

def check_scores(results):
    for score in results:
        if score >= 90:
            print(score, "is excellent.")
        else:
            print(score, "is passing.")

The body of the function is indented once. Inside it, the for loop body is indented again. Inside the loop, the if and else bodies are indented a third time. Each line's position tells you exactly which block owns it, with no ambiguity. If you misalign even one line by a single space, Python raises an IndentationError and refuses to run the code until the indentation is consistent.

The pass statement: an empty block placeholder

Python does not allow an empty block. If you write a colon at the end of a line, the next line must contain at least one statement at the increased indentation level. This rule catches a common mistake: writing a block header and then forgetting to write the body. When you genuinely need an empty block, perhaps while sketching out the structure of a program before filling in the details, you can use the pass statement. The pass keyword does nothing at all, but it satisfies the requirement that a block must not be empty.

This is common when you are planning the structure of a function or a class before implementing the logic. You write the header with a colon, then indent and write pass on the next line. Python accepts it, and you can replace pass with real code later. This pattern is also useful when you are learning and want to test that your indentation structure is valid before filling in the details.

Why Python's block rules matter

Enforcing indentation as syntax eliminates an entire category of bugs that plague languages with brace-based blocks. In a brace language, you can indent code in a way that misleads the reader about which block a line belongs to. Python makes this impossible because the indentation is the block structure. The code always looks like what it does.

The tradeoff is that you must be disciplined about whitespace. Mixing tabs and spaces causes a TabError. Using three spaces in one block and four in another causes an IndentationError. These errors are frustrating at first, but they train you to write consistently formatted code from the very beginning. Most editors now handle Python indentation automatically, inserting four spaces when you press Enter after a colon and dedenting when you finish a block. If you have already read about Python syntax and indentation, the block concept extends those rules into the practical structures you will use in every program.

Blocks in the bigger picture

Every major Python feature uses blocks. Loops use blocks to repeat code. Conditional statements use blocks to make decisions. Functions use blocks to group reusable logic. Classes use blocks to define objects. Even context managers with the with statement use blocks to manage resources. Understanding blocks is like understanding paragraphs in writing: once you know where one ends and the next begins, you can focus on the content instead of the structure.

As you continue through this learning path, you will encounter blocks constantly. The next article covers Python source files and scripts, where you will see how blocks work across an entire file. After that, learning to read error messages will help you quickly fix indentation mistakes when they happen.