{"title":"Indentation","description":"","content":"Most languages use curly braces or `begin`/`end` to mark where a block of code starts and ends. Python doesn't. It uses the indentation itself as part of the grammar, which means whitespace at the start of a line is meaningful to the parser, not just to a human reader. This lesson covers how Python reads indentation, what the rules are, the two errors that come from getting it wrong, and the habits that keep code clean.\n\n---\n\n# Why Python Uses Indentation\n\nCompare the same `if` statement in two languages:\n\n\n```shell\n// JavaScript\nif (cart_total > 50) {\n free_shipping = true;\n notify_customer();\n}\n```\n\n\n\n```python\n# Python\nif cart_total > 50:\n free_shipping = True\n notify_customer()\n```\n\n\nJavaScript uses the curly braces to mark the body of the `if`. The indentation is purely cosmetic. The same code written on a single line still works. Python uses the indentation itself. There are no braces. The two lines that belong to the `if` are the ones indented underneath it, and that's how Python knows.\n\nGuido van Rossum, who designed Python, made this choice on purpose. Programmers were already indenting their code to make it readable, then writing braces on top of that to satisfy the compiler. Python skips the braces and uses the indentation. The visible structure and the parsed structure are the same, so code can't look correct while parsing wrong.\n\nThe trade-off is strictness. If indentation is inconsistent, Python refuses to run the file.\n\n---\n\n# How the Parser Reads Indentation\n\nPython's parser walks through source line by line and tracks the **indentation level** of each statement, measured in columns from the left margin. When indentation increases, the parser interprets that as the start of a new block. When it decreases, the block ends.\n\nPython's lexer emits two invisible tokens, called `INDENT` and `DEDENT`, every time the indentation level changes. They behave like the opening and closing braces in other languages, generated from whitespace.\n\nConsider this function:\n\n\n```python\ndef cart_total(prices):\n total = 0\n for price in prices:\n total += price\n return total\n```\n\n\nThe parser sees it as:\n\n\n| Line | Content | Indentation |\n|------|---------|-------------|\n| 1 | `def cart_total(prices):` | 0 |\n| 2 | `total = 0` | 4 (INDENT into function body) |\n| 3 | `for price in prices:` | 4 |\n| 4 | `total += price` | 8 (INDENT into loop body) |\n| 5 | `return total` | 4 (DEDENT out of loop body) |\n\n\nTwo new blocks open, two blocks close. The parser builds the same tree it would if explicit braces were written, but it builds it from the column counts.\n\nThe same structure as a diagram:\n\n\n```mermaid\nflowchart TD\n A[def cart_total
indent 0]:::cyan --> B[total = 0
indent 4]:::orange\n A --> C[for price in prices
indent 4]:::orange\n C --> D[total += price
indent 8]:::teal\n A --> E[return total
indent 4]:::orange\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe function body holds three statements at indent level 4. The loop body holds one statement at indent level 8. Every line inside the same block must share the exact same leading whitespace, character for character.\n\nIndentation tokens are generated at parse time, so the runtime cost is zero. The strictness is at parse time: inconsistent indentation stops the file from running.\n\n---\n\n# Spaces vs Tabs: Use Spaces\n\nThe language allows either spaces or tabs for indentation. PEP 8, the official style guide, says **use four spaces per level**. The Python standard library uses four spaces, popular editors default to four spaces, and code reviews assume it.\n\nTabs and spaces look identical on screen but are different bytes underneath. A tab might render as 4 spaces in one editor, 8 in another, and something else in a code review tool. If a file mixes both, the visual indentation no longer matches what the parser sees, and the code can look correct while parsing wrong.\n\nUse spaces consistently.\n\n\n```python\n# Use four spaces per level\ndef apply_discount(price, percent):\n if percent > 0:\n return price * (1 - percent / 100)\n return price\n```\n\n\nMost editors are set up to insert four spaces when the Tab key is pressed. Enabling \"show whitespace\" or \"show invisibles\" in the editor's view menu confirms this: tabs appear as arrows, spaces as dots.\n\nPython 3 made one change over Python 2: it refuses to mix tabs and spaces in a way the parser would have to guess about. A file that uses a tab on one line and four spaces on the next at the same logical indent level raises `TabError` and stops. The old behavior, where the interpreter picked an interpretation without warning, caused too many bugs.\n\n---\n\n# `IndentationError`: When the Whitespace Doesn't Line Up\n\n`IndentationError` is raised when a line is indented in a way Python can't make sense of. It's a special case of `SyntaxError`, but Python gives it a distinct name because the cause is specific.\n\n**Missing indentation after a block opener:**\n\n\n```python\ndef cart_total(prices):\ntotal = 0\n```\n\n\n\n```shell\nFile \"demo.py\", line 2\n total = 0\n ^\nIndentationError: expected an indented block after function definition on line 1\n```\n\n\nA `def`, `if`, `for`, `while`, `class`, `try`, or any other line that ends in a colon requires a block of code on the following lines. Python expects the next non-empty line to be indented further than the line with the colon. If it isn't, this error is raised.\n\n**Unexpected extra indentation:**\n\n\n```python\nprice = 19.99\n discount = 0.10\n```\n\n\n\n```shell\nFile \"demo.py\", line 2\n discount = 0.10\nIndentationError: unexpected indent\n```\n\n\nThe first line sits at column 0, so the parser is at indent level 0. The second line jumps to column 4 with no block opener above it (no `if`, `def`, or similar). Python can't determine which block this line belongs to, so it stops.\n\n**Inconsistent indentation inside a block:**\n\n\n```python\ndef cart_total(prices):\n total = 0\n for price in prices:\n total += price\n return total\n```\n\n\n\n```shell\nFile \"demo.py\", line 3\n for price in prices:\nIndentationError: unexpected indent\n```\n\n\nThe first statement inside the function indented by 4 spaces. The next jumped to 6. Inside one block, every statement has to start at the same column. Pick a width and use it consistently for that block.\n\n\n```mermaid\nflowchart LR\n A[Line with colon ends a header]:::cyan --> B[Next non-empty
line indented further?]:::orange\n B -->|No| C[IndentationError:
expected indent]:::red\n B -->|Yes| D[Block opens]:::green\n D --> E[Every line in block
shares the same indent?]:::orange\n E -->|No| F[IndentationError:
unexpected indent]:::red\n E -->|Yes| G[Block parses correctly]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n```\n\n\nThe decision the parser is making is small and mechanical, which is why these errors are easy to fix: pick the column where the block starts, and make sure every statement inside the block lines up at that column.\n\n---\n\n# `TabError`: When You Mix Tabs and Spaces\n\n`TabError` is a subclass of `IndentationError`. It's raised when the same block uses a mix of tabs and spaces in a way that's ambiguous.\n\n\n```python\ndef cart_total(prices):\n total = 0\n\treturn total\n```\n\n\nThe first line of the body uses four spaces. The second line uses a tab. They look the same when rendered, but they aren't the same bytes.\n\n\n```shell\nFile \"demo.py\", line 3\n return total\n ^\nTabError: inconsistent use of tabs and spaces in indentation\n```\n\n\nThe fix is to convert every line in the file to use only spaces. Most editors have a \"convert indentation to spaces\" command for this case. Once converted, the file runs.\n\nUseful prevention settings in any editor:\n\n- \"Insert spaces when pressing Tab\" turned on.\n- A configured \"tab width\" of 4.\n- \"Show whitespace\" toggled on, at least when debugging.\n\nThese three settings together prevent introducing a tab where a space was intended.\n\n---\n\n# Indentation in Every Block-Opening Statement\n\nThe same indentation rules apply to every kind of block in Python. The line that ends with a colon is a **block header**. The lines indented beneath it are the **block body**. The same pattern applies across the constructs covered in the rest of this course.\n\n**`if` / `elif` / `else`:**\n\n\n```python\ncart_total = 75\nif cart_total >= 50:\n print(\"Free shipping\")\n print(\"Order qualifies for express delivery\")\nelif cart_total >= 25:\n print(\"Standard shipping\")\nelse:\n print(\"Add more items for free shipping\")\n```\n\n\nEach branch is its own block. The body of `if` doesn't have to be the same length as the body of `elif`, but each body has to be indented consistently within itself.\n\n**`for` and `while` loops:**\n\n\n```python\nprices = [19.99, 4.99, 14.99]\ntotal = 0\nfor price in prices:\n total += price\n print(f\"Running total: {total:.2f}\")\nprint(f\"Final: {total:.2f}\")\n```\n\n\nThe two statements inside the loop are indented by 4 spaces. The final `print` returns to indent level 0, which ends the loop. The result is that the last line runs once, not three times.\n\n**`def` for functions:**\n\n\n```python\ndef line_total(price, quantity):\n subtotal = price * quantity\n return subtotal\n\nprint(line_total(19.99, 3))\n```\n\n\n**`class` for classes:**\n\n\n```python\nclass Product:\n def __init__(self, name, price):\n self.name = name\n self.price = price\n\nmouse = Product(\"Wireless Mouse\", 19.99)\nprint(mouse.name)\n```\n\n\nThe class example shows nesting. The method `__init__` is indented one level inside the class. The body of `__init__` is indented one more level. Each `INDENT` corresponds to a deeper block.\n\n**`try` / `except`:**\n\n\n```python\ntry:\n price = float(\"not a number\")\nexcept ValueError:\n price = 0.0\nprint(price)\n```\n\n\nSame rule again: each clause's body is indented under its header.\n\n---\n\n# Nested Blocks\n\nNesting works by adding one more indentation level for each block that's inside another. Code typically stays at two or three levels deep. Past that, the indentation itself signals that the code is doing too much in one place.\n\nA function that filters in-stock products from a small catalog:\n\n\n```python\ndef in_stock_products(catalog):\n available = []\n for product in catalog:\n if product[\"stock\"] > 0:\n if product[\"price\"] < 100:\n available.append(product[\"name\"])\n return available\n\ncatalog = [\n {\"name\": \"Wireless Mouse\", \"stock\": 5, \"price\": 19.99},\n {\"name\": \"HDMI Cable\", \"stock\": 0, \"price\": 9.99},\n {\"name\": \"Webcam\", \"stock\": 3, \"price\": 79.99},\n {\"name\": \"4K Monitor\", \"stock\": 2, \"price\": 299.99},\n]\n\nprint(in_stock_products(catalog))\n```\n\n\nThe function body is indent 4. The `for` body is indent 8. The outer `if` body is indent 12. The inner `if` body is indent 16. Four levels deep, and the content drifts away from the left margin.\n\nFlatten by combining conditions:\n\n\n```python\ndef in_stock_products(catalog):\n available = []\n for product in catalog:\n if product[\"stock\"] > 0 and product[\"price\"] < 100:\n available.append(product[\"name\"])\n return available\n```\n\n\nNow the deepest indent is 12, and the code is easier to read. The PEP 8 line length limit (79 characters) combined with deep nesting often forces refactoring like this, which is part of why the rule exists.\n\nDeeply nested code isn't slow at runtime, but it's harder to follow, harder to test, and harder to change without breaking. A function that reaches four levels of indentation usually benefits from extracting a helper or combining conditions.\n\n---\n\n# Empty Blocks: `pass`\n\nPython doesn't allow an empty block. The parser sees a header with a colon and expects something indented under it. For a placeholder, use `pass`, which is a statement that does nothing.\n\n\n```python\ndef calculate_tax(subtotal):\n pass\n\nclass Wishlist:\n pass\n\nif cart_total > 100:\n pass\n```\n\n\nThese three uses all parse, run, and do nothing. The `pass` statement satisfies the requirement that a block contain at least one statement. Drop it once you replace it with real code.\n\nWithout `pass`, the same definitions raise `IndentationError`:\n\n\n```python\ndef calculate_tax(subtotal):\n\nclass Wishlist:\n```\n\n\n\n```shell\nFile \"demo.py\", line 1\n def calculate_tax(subtotal):\nIndentationError: expected an indented block after function definition on line 1\n```\n\n\n`pass` is most often a temporary placeholder while sketching the structure of a module or class. It's also useful in `except` clauses where the intent is to ignore an error.\n\n---\n\n# Line Continuation: When a Single Statement Spans Several Lines\n\nIndentation rules are about which lines belong to which block. A single statement that's too long for one line is a separate question, and it doesn't change the indentation rules.\n\nA long expression wrapped in parentheses, brackets, or braces can spread across several physical lines. The continuation lines don't have to follow indentation rules, but the convention is to align them for readability.\n\n\n```python\ntotal = (\n item_one_price\n + item_two_price\n + item_three_price\n + shipping_fee\n)\n```\n\n\nThe parser sees one assignment statement here, not four. The whitespace inside the parentheses is formatting, not block structure.\n\nFor lines without brackets, a backslash `\\` at the end of the line acts as a continuation:\n\n\n```python\ntotal = item_one_price \\\n + item_two_price \\\n + item_three_price\n```\n\n\nThis works, but parenthesized continuation is preferred. A stray space after the backslash breaks it without warning, and the syntax doesn't read as cleanly. Save the backslash for cases where parentheses don't fit, like long `with` statements in older Python versions.\n\nContinuation lines aren't new blocks. They're the same statement, written across multiple lines. The block-structure indentation rules only fire when a new statement begins.\n\n---\n\n# Common Mistakes\n\nA short tour of the mistakes that produce the indentation errors above.\n\n**What's wrong with this code?**\n\n\n```python\ndef apply_discount(price, percent):\nreturn price * (1 - percent / 100)\n```\n\n\nThe body of the function isn't indented. Python expects the lines inside the function to be indented past the `def` line. The fix is to indent `return` by four spaces.\n\n**What's wrong with this code?**\n\n\n```python\nif cart_total > 50:\n print(\"Free shipping\")\n print(\"Express delivery available\")\n print(\"Bonus reward points\")\n```\n\n\nThe third `print` jumps to a deeper indent level than the previous two, but there's no new block to start. Inside one block, every line shares the same column. Drop the third `print` back to align with the others.\n\n**What's wrong with this code?**\n\n\n```python\nfor product in catalog:\n print(product[\"name\"])\nprint(product[\"price\"])\n```\n\n\nThe second `print` is at indent level 0, so it's outside the `for` loop. It runs once, after the loop finishes, using whatever value `product` happened to have on the last iteration. That's typically not the intended behavior. To print both lines for each product, indent the second `print` to match the first.\n\n**What's wrong with this code?**\n\n\n```python\ndef cart_total(prices):\n total = 0\n\tfor price in prices:\n total += price\n return total\n```\n\n\nThe first body line uses 4 spaces. The second uses a tab. Python raises `TabError`. Convert the file to spaces only.\n\n---\n\n# Quiz","pageType":"python"}

Get Premium