Python Syntax & Indentation
The Rules That Make Python Readable

🧱 Statements and Expression Statements

A statement is a single line of code that does something: assigns a value, calls a function, imports a module, or defines a class. Most statements occupy exactly one line.

x = 42
print("Hello")
import math
return x

Notice that Python does not require a semicolon at the end of a statement. The end of the line is the end of the statement. This is one of the most immediately visible differences from C-style languages.

🔤 Keywords and Identifiers

Python reserves a set of keywords — words with special meaning to the interpreter. You cannot use them as variable names or function names.

import keyword
print(keyword.kwlist)

The current keyword list (Python 3.13) includes: False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield.

🔡 Identifiers — Naming Things

An identifier is a name you give to a variable, function, class, or module. Python has strict rules:

• ✓Must start with a letter (a–z, A–Z) or underscore (_)
• ✓Can contain letters, digits, and underscores after the first character
• ✓Cannot be a keyword
• ✓Case-sensitive — Name, name, and NAME are three different identifiers
• ✗Cannot start with a digit — 2var is invalid, but var2 is fine
• ✗Cannot contain special characters like @, -, or !

# Valid identifiers:
name = "Alice"
_private = "internal"
counter2 = 5
my_variable_name = True

# Invalid identifiers — will raise SyntaxError:
# 2var = 10
# my-var = 10
# class = 10

🏗️ How Indentation Works

In Python, indentation defines which statements belong to which block. Unlike other languages that use curly braces, Python relies entirely on leading whitespace.

def greet(name):
    # This line is indented — it's inside the function
    print(f"Hello, {name}")
    if name:
        # More indented — inside the if block
        print("Name was provided")
    # Back to one level — inside the function, outside the if
    print("Goodbye")

# Not indented — outside the function
print("Done")

Every line at the same indentation level is considered part of the same block. When indentation changes, Python knows a new block has started or an existing block has ended.

📏 The 4-Space Rule

PEP 8 — Python's official style guide — mandates 4 spaces per indentation level. Not 2, not 3, not 8, and definitely not tabs.

def example():
    # This is 4 spaces — correct
    print("Good")

def bad_example():
  # This is 2 spaces — technically valid, but bad style
  print("Avoid")

⚠️ Tabs vs. Spaces — The Infamous Python Trap

Python 3 forbids mixing tabs and spaces in the same block. This raises a TabError — which is a subclass of IndentationError.

def trap():
    print("indented with spaces")
	print("indented with a tab")

# TabError: inconsistent use of tabs and spaces in indentation

Here's the dangerous part: tabs and spaces look identical in most editors. So you can have visually aligned code that Python considers broken. The fix is simple — configure your editor to insert 4 spaces whenever you press Tab.

• ✓VS Code: bottom-right corner → click "Spaces: 4"
• ✓PyCharm: Settings → Editor → Code Style → Python → Tabs and Indents
• ✓Vim: add set expandtab and set tabstop=4 to your .vimrc

🔍 What Starts a Block?

A code block is a group of statements that logically belong together. In Python, a block is introduced by a line ending with a colon (:). The lines that follow, indented one level deeper, form the block.

if temperature > 30:
    # Block 1 — executed only if the condition is True
    print("It's hot!")
    print("Drink water.")
else:
    # Block 2 — executed only if the condition is False
    print("It's comfortable.")

Every construct in Python that introduces a block uses a colon. Here are the most common ones:

🧪 A Real Example — Nested Blocks

Blocks can be nested. Each level of nesting adds exactly one more level of indentation. Here's a function containing an if block containing a for block:

def classify_scores(scores):
    # Block 1 — function body (4 spaces)
    results = []
    for score in scores:
        # Block 2 — for loop body (8 spaces)
        if score >= 90:
            # Block 3 — if body (12 spaces)
            results.append("A")
        elif score >= 75:
            # Block 3b — elif body (12 spaces)
            results.append("B")
        else:
            # Block 3c — else body (12 spaces)
            results.append("C")
    # Back to Block 1 (4 spaces) — after the loop ends
    return results

print(classify_scores([95, 82, 70, 88]))

The visual structure of the code is the logical structure. Reading the code left-to-right, the indentation tells you exactly how the blocks nest.

🤷 The pass Statement

Every block must contain at least one statement. If you want to create an empty block — as a placeholder while you're writing code — use pass, which does nothing.

def future_feature():
    pass  # placeholder — will fill in later

class EmptyClass:
    pass

if condition:
    pass  # do nothing for now
else:
    print("action taken")

🔗 Implicit Continuation Inside Brackets

The cleanest way to split a long statement is to wrap part of it in parentheses, brackets, or braces. Python continues the statement automatically as long as the delimiter isn't closed.

# Long function call — split across lines
total = sum([
    12.99,
    4.50,
    8.75,
    15.00,
])

# Long conditional expression
status = (
    "active"
    if user_logged_in and account_verified
    else "inactive"
)

# Long dictionary literal
config = {
    "host": "localhost",
    "port": 8080,
    "debug": True,
}

🔙 Explicit Continuation with Backslash

Outside of brackets, you can split a statement with a backslash at the end of a line. This tells Python the statement continues on the next line.

# Long boolean expression, split with a backslash
is_eligible = user_age >= 18 \
    and user_has_id \
    and not user_banned

# Long string split across lines (rare)
message = "This is a very long message \
that continues here."

🎯 The Best Practice — Wrap in Parens

When you need to split a long expression, wrapping it in parentheses is the most idiomatic approach. It's what code formatters produce automatically, and it's less error-prone than backslashes.

result = (
    first_value
    + second_value
    + third_value
)

result = first_value \
    + second_value \
    + third_value

📝 Single-Line Comments

A comment starts with # and continues to the end of the line. Python ignores everything after # until the line break. Use comments to explain why the code exists, not what it does — the code itself should make the "what" clear.

# This comment explains the code below it
tax_rate = 0.08

price_with_tax = price * (1 + tax_rate)  # inline comment

# Comments can also be used to disable code temporarily:
# debug = True

📄 Docstrings — Documentation that Python Understands

A docstring is a special kind of string at the start of a module, function, class, or method. Unlike comments, docstrings become part of the object at runtime — they show up in help(), in IDE tooltips, and in auto-generated documentation.

def calculate_bmi(weight_kg: float, height_m: float) -> float:
    """Calculate Body Mass Index.

    Args:
        weight_kg: Body weight in kilograms.
        height_m: Height in meters.

    Returns:
        The BMI as a float, rounded to two decimal places.

    Raises:
        ValueError: If height_m is zero or negative.
    """
    if height_m <= 0:
        raise ValueError("Height must be positive")
    return round(weight_kg / height_m ** 2, 2)

help(calculate_bmi)

Run help(calculate_bmi) in the REPL and Python prints the docstring in a nicely formatted way — all for free, just by putting a string there.

• ✓Use triple quotes (""") for docstrings — a single-line docstring can use """...""" on one line
• ✓Write docstrings for every public function, class, and module
• ✓The first line should be a one-sentence summary ending in a period
• ✓Leave a blank line between the summary and any extended description

📚 Multi-Line Comments

Python doesn't have a formal multi-line comment syntax. The most common ways to comment out multiple lines are:

1. Prefix each line with # — the standard approach, recommended by PEP 8.
2. Wrap the block in """ — technically a string literal, not a comment, but functionally similar when used inside a block. Most editors support selecting multiple lines and hitting Ctrl+/ to comment them out.

# This is a proper multi-line comment
# using one hash per line — the recommended style.
# Every line is clearly marked.

"""
This is a string literal that acts like a comment.
It's not stored anywhere so it's effectively ignored,
but linters may still warn about it.
"""

🔤 Naming Conventions

PEP 8 defines specific naming styles for each type of identifier. Following these makes your code instantly recognizable to other Python developers.

📏 Line Length

PEP 8 recommends 79 characters maximum per line for code, and 72 characters for docstrings and comments. This keeps code readable on narrow screens and side-by-side diffs.

Many modern teams relax this to 88 or 100 characters — the default of Black, the most popular Python formatter — but 79 is still the PEP 8 standard.

📐 Spacing Rules

• ✓Use one space around binary operators: x = a + b — not x=a+b
• ✓Use no space around the = sign in default arguments: def f(x=0):
• ✓Use no space before a comma or colon: [1, 2, 3] — not [1 , 2 , 3]
• ✓Use one space after a comma: f(a, b) — not f(a,b)
• ✓Surround operators with single spaces — but allow higher precedence to bind tighter: a = 2*x + 3*y
• ✓Two blank lines between top-level functions and classes
• ✓One blank line between methods inside a class

📥 Import Organization

Imports should be grouped and ordered:

1. Standard library imports — os, sys, json, datetime
2. Third-party imports — requests, numpy, pandas, flask
3. Local application imports — from mypackage import mymodule

# Standard library
import json
import os
from datetime import datetime

# Third-party
import requests
import pandas as pd

# Local
from mypackage import mymodule

🛠️ Tools That Enforce PEP 8 Automatically

You don't have to memorize PEP 8 — modern tools will format your code to conform automatically, or flag violations as you type.

❌ Error 1 — Missing Colon After a Block Header

Every line that introduces a block must end with a colon. Forgetting it is the single most common SyntaxError.

if x > 0
    print("positive")

if x > 0:
    print("positive")

❌ Error 2 — Inconsistent Indentation

Every line in a block must be indented by exactly the same amount. Mixing 2 spaces and 4 spaces in the same block causes a TabError or IndentationError.

def greet(name):
  print("Hello")
    print(name)

def greet(name):
    print("Hello")
    print(name)

❌ Error 3 — Empty Block

A block cannot be empty. If you're not ready to write the block yet, use pass as a placeholder.

def future_feature():

# Nothing here yet

def future_feature():
    pass

❌ Error 4 — Using Reserved Keywords as Names

Keywords have special meaning to Python and cannot be used as variable names.

class = "Physics 101"

course_name = "Physics 101"

❌ Error 5 — Unclosed Brackets

Every opening bracket must have a matching closing bracket. Mismatches produce surprisingly cryptic errors because Python tries to continue the statement onto the next line.

numbers = [1, 2, 3
print(numbers)

numbers = [1, 2, 3]
print(numbers)