IndentationError: expected an indented block

Encountering IndentationError: expected an indented block means Python didn't find the necessary indented code after a block-defining statement; this guide explains how to identify and fix it efficiently.

What This Error Means

The IndentationError: expected an indented block message is Python's way of telling you that your code structure is incorrect, specifically concerning its unique reliance on whitespace. Unlike many other programming languages that use curly braces {} or keywords like end to define code blocks (functions, loops, conditional statements, classes, etc.), Python uses indentation. This error occurs when the Python interpreter expects to find an indented block of code but encounters a line that is either not indented at all or is indented incorrectly (e.g., less than expected).

This isn't just a stylistic preference; it's a fundamental part of Python's syntax. The level of indentation dictates the scope of a code block. When Python sees a statement like def, if, for, while, class, with, or try, it expects the subsequent lines that logically belong to that statement to be indented by a consistent amount. If it doesn't find this, it raises an IndentationError. It's a syntax error caught at runtime or during the initial parsing phase, preventing your program from executing correctly.

Why It Happens

This error stems directly from Python's strict rules around code structure. When you define a function, a loop, or a conditional branch, you introduce a new code block. This new block must start with a line that is indented relative to the line that introduced it.

Consider this:

def my_function():
    print("This line is part of the function.")
print("This line is outside the function.")

Here, print("This line is part of the function.") is correctly indented and thus part of my_function. The second print statement is dedented and is considered outside the function.

The error arises when the interpreter expects an indented line but finds something else. This usually happens in a few key scenarios:

1. Missing Indentation After a Colon: Statements like def, if, for, while, class, with, and try always end with a colon (:). This colon signals to Python that a new indented block is about to follow. If the very next line after such a statement is not indented, or if the block is entirely empty, Python throws this error.
2. Empty Code Blocks: Sometimes, you might introduce a block (e.g., an if statement) but forget to put any code inside it. Python still expects an indented line. If you genuinely intend to have an empty block, you must explicitly tell Python with the pass keyword.
3. Incorrect Dedenting/Re-indenting: While less common for expected an indented block, this can occur if you incorrectly dedent a line that Python still believes should be part of an existing block, or if you accidentally place a line at the wrong indentation level immediately after a block-defining statement.

Understanding that Python is literally scanning for the next line to be indented correctly after a colon is crucial to diagnosing this issue.

Common Causes

In my experience, encountering IndentationError: expected an indented block usually boils down to one of these common mistakes:

1. Forgetting to indent the first line of a new block: This is the most straightforward cause. You've declared def my_func(): or if condition: and then the very next line of code is at the same indentation level as the def or if statement, instead of being indented.
   python def calculate_sum(a, b): result = a + b # ERROR: This line should be indented return result
2. Missing a colon (:): While this specific error usually manifests as SyntaxError: invalid syntax if the colon is completely missing, sometimes a missing colon can lead to the interpreter misinterpreting the following line, especially if you're trying to quickly type code. However, the direct IndentationError means the colon was present, but the following indentation was not.
3. Empty blocks without pass: You might be drafting code and temporarily leave a block empty.
   python if user_is_admin: # TODO: Add admin specific logic here print("Welcome!") # ERROR: The 'if' block is empty and not properly terminated.
   Python expects something indented. If you don't have code yet, use pass:
   python if user_is_admin: pass # Placeholder for future code print("Welcome!") # Now this is fine.
4. Copy-pasting code with inconsistent indentation: This is a trap I've seen many engineers fall into, especially when grabbing snippets from online forums or different projects. If the source code uses tabs and your editor is configured for spaces (or vice versa), or if the number of spaces differs, it can introduce invisible characters that Python interprets as inconsistent indentation, even if it looks correct. This is less likely to directly cause "expected an indented block" for a first line of a block, but rather IndentationError: unindent does not match any outer indentation level or IndentationError: unexpected indent. However, if the copy-pasted block starts with a line that's supposed to be indented but isn't, then expected an indented block could arise.
5. Accidental Backspace/Delete: Sometimes, during rapid coding or refactoring, a quick Backspace or Delete can remove the indentation from a crucial line, leading to this error.

Step-by-Step Fix

Fixing IndentationError: expected an indented block is usually straightforward once you understand what Python is looking for. Here’s a methodical approach:

1. Locate the Error:

   • Examine the traceback provided by Python. It will pinpoint the exact file and line number where the error occurred.
     File "my_script.py", line 5 print("Hello") IndentationError: expected an indented block
   • The ^ indicator (if present) often points to the column where the problem starts, but for indentation errors, the line number is usually sufficient.

2. Identify the Preceding Block-Defining Statement:

   • Go to the line before the error line (line 4 in the example above, or often, the line containing the def, if, for, while, class, with, or try statement that ends with a colon).
   • This is the statement that Python expected an indented block to follow.

3. Check for a Missing Colon:

   • Ensure the block-defining statement (e.g., if condition) correctly ends with a colon (:). While a missing colon typically results in SyntaxError: invalid syntax, it's worth a quick check as it can sometimes indirectly contribute to indentation confusion.

4. Add or Correct Indentation:

   • Most commonly, the line causing the error simply needs to be indented. Place your cursor at the beginning of the error line and press Tab or Space (typically four spaces, as per PEP 8).
   • If you're using an IDE like VS Code, PyCharm, or Sublime Text, these usually have smart indentation features that will automatically indent new lines after a colon.
   • Example of fix:
     Before (Error):
     python def my_function(): print("This should be indented.")
     After (Fixed):
     python def my_function(): print("This should be indented.") # Indented with 4 spaces

5. Insert pass for Empty Blocks:

   • If you deliberately intend a block to be empty for now (e.g., a conditional branch you haven't implemented), add the pass keyword, properly indented.
   • Before (Error):
     python if debug_mode: print("Debugging output is off.")
   • After (Fixed with pass):
     python if debug_mode: pass # Placeholder for debug-specific actions print("Debugging output is off.")

6. Standardize Indentation (if necessary):

   • While less direct for expected an indented block, inconsistent indentation (mixing tabs and spaces) can lead to subtle parsing issues. It's a good practice to ensure your entire file uses a consistent indentation style.
   • Many IDEs have features to "Convert Indentation to Spaces" or "Convert Indentation to Tabs." I usually stick to 4 spaces, which is the community standard (PEP 8).
   • Tools like Black or Flake8 integrated into your development workflow can automatically format your code or highlight inconsistencies, preventing these errors before runtime.

By following these steps, you should be able to quickly resolve the IndentationError: expected an indented block and get your Python code running.

Code Examples

Here are some concise, copy-paste ready examples demonstrating the error and its fix.

Example 1: Missing Indentation for a Function Body

• Incorrect (will raise error):
  python # broken_function.py def greet(name): print(f"Hello, {name}!")
bash python broken_function.py # Output: # File "broken_function.py", line 3 # print(f"Hello, {name}!") # IndentationError: expected an indented block

• Corrected:
  python # fixed_function.py def greet(name): print(f"Hello, {name}!") # Indented with 4 spaces
bash python -c 'def greet(name): print(f"Hello, {name}!") greet("Asha")' # Output: # Hello, Asha!

Example 2: Empty Conditional Block without pass

• Incorrect (will raise error):
  ```python
  # broken_conditional.py
  is_active = False

  if is_active:
  print("User is active.") # This line is outside the if block, but the if block is empty
  bash
  python broken_conditional.py

  Output:

  File "broken_conditional.py", line 5

  print("User is active.")

  IndentationError: expected an indented block

  ```

• Corrected with pass:
  ```python
  # fixed_conditional.py
  is_active = False

  if is_active:
  pass # The 'pass' keyword fulfills the indentation requirement
  print("User is active.")
  bash
  python -c 'is_active = False
  if is_active:
  pass
  print("User is active.")'

  Output:

  User is active.

  ```

Example 3: Missing Indentation for a Loop Body

• Incorrect (will raise error):
  python # broken_loop.py for i in range(3): print(f"Iteration {i}")
bash python broken_loop.py # Output: # File "broken_loop.py", line 3 # print(f"Iteration {i}") # IndentationError: expected an indented block

• Corrected:
  python # fixed_loop.py for i in range(3): print(f"Iteration {i}") # Indented with 4 spaces
bash python -c 'for i in range(3): print(f"Iteration {i}")' # Output: # Iteration 0 # Iteration 1 # Iteration 2

Environment-Specific Notes

The IndentationError: expected an indented block can manifest differently, or be easier/harder to diagnose, depending on your development environment.

Local Development

• IDEs (PyCharm, VS Code, Sublime Text, Atom): Modern IDEs are your best friend here. They typically auto-indent correctly after a colon and can visually highlight inconsistent indentation (e.g., mixing tabs and spaces). Many have features to "show whitespace characters" which can reveal hidden tabs or spaces. They also integrate linters (like Flake8) and formatters (like Black) that can proactively catch and fix these issues before you even try to run the code. I almost never see this error locally anymore because my VS Code setup catches it instantly.
• Text Editors (Vim, Emacs, Nano): These editors require more manual configuration for indentation. You need to ensure they are set to insert spaces (and a consistent number, usually 4) when you press Tab, or to highlight mixed tabs/spaces. Without these settings, it's easy to accidentally introduce indentation errors.

CLI (Command Line Interface)

When running Python scripts directly from the command line (python your_script.py), you'll only see the traceback if an error occurs. There are no visual cues like in an IDE.

python my_script_with_error.py
# Example output for CLI:
# Traceback (most recent call last):
#   File "my_script_with_error.py", line 7, in <module>
#     my_function()
#   File "my_script_with_error.py", line 4
#     print("Inside function.")
# IndentationError: expected an indented block

Here, you're reliant on the line number and the error message itself. You'd then open the file in your preferred editor to fix it. This is where a good editor setup for consistency is vital.

Build Systems & CI/CD Pipelines

I've seen this in production when a developer pushes code that hasn't been properly linted or tested locally. When your Python code is part of a larger build system (e.g., Jenkins, GitLab CI, GitHub Actions) or a CI/CD pipeline, an IndentationError will cause the build to fail. The pipeline logs will display the full traceback, similar to a CLI execution. This is a good thing – it prevents broken code from being deployed. The key is to ensure your CI pipeline includes linting and unit tests that would catch such a basic syntax error early.

Docker

If you're containerizing your Python application with Docker, an IndentationError can strike at various stages:
* During Image Build (docker build): If your Dockerfile executes a Python script (e.g., for pre-processing or setup) or copies a Python script that immediately errors out, the build will fail. For instance, if your ENTRYPOINT script has an IndentationError, the container won't even start properly.
* During Container Runtime (docker run): If the error is in your main application code that gets run inside the container, the container will start and then exit with the Python traceback visible in its logs (docker logs <container_id>).
Debugging involves looking at the container logs and then updating your source code on the host machine before rebuilding the image or restarting the container.

Cloud (AWS Lambda, Azure Functions, GCP Cloud Functions)

Serverless functions and other cloud-hosted Python applications are particularly sensitive.
* Deployment Failure: Cloud providers often perform a syntax check upon deployment. If your function code has an IndentationError, the deployment might be rejected outright.
* Runtime Failure: If the error is in a code path only executed under certain conditions, the deployment might succeed, but function invocations will fail. You'll find the IndentationError traceback in the cloud provider's logging service (e.g., AWS CloudWatch, Azure Application Insights, GCP Stackdriver/Cloud Logging).
Debugging in the cloud typically involves meticulous local testing (often using local emulators like AWS SAM CLI), replicating the environment as closely as possible, and relying heavily on detailed logging. It's much harder to interactively debug indentation issues in a live cloud environment, reinforcing the need for robust local development practices.

Across all these environments, the core fix remains the same: identify the offending line and correct its indentation. However, proactive measures like using good IDEs, linters, and formatters are crucial to prevent these errors from reaching more complex environments.

Frequently Asked Questions

Q: Can I use tabs instead of spaces for indentation in Python?
A: Technically, yes, Python allows tabs for indentation. However, PEP 8 (Python's official style guide) strongly recommends using 4 spaces per indentation level. Mixing tabs and spaces in the same file is a recipe for IndentationError or other related issues, as different editors interpret tabs differently. Consistency is paramount. My advice is always 4 spaces.

Q: My code looks perfectly fine, but I'm still getting an IndentationError: expected an indented block. What could be wrong?
A: This is almost always due to invisible characters. You likely have a mix of tabs and spaces, or some other non-standard whitespace character, that your editor isn't showing. Enable "show whitespace characters" in your IDE or text editor to reveal these. Then, use your editor's "Convert Indentation to Spaces" or "Convert Indentation to Tabs" feature to standardize it.

Q: Does this error happen in other programming languages?
A: Not in the same specific way. Languages like C++, Java, JavaScript, C# use curly braces {} to define code blocks, making indentation purely stylistic (though crucial for readability). Languages like Ruby use end keywords. Python's unique syntax makes this type of indentation error specific to it.

Q: How can I prevent IndentationError reliably in my projects?
A:
1. Use a good IDE: PyCharm, VS Code, etc., offer intelligent auto-indentation and visual cues for whitespace issues.
2. Configure your editor: Set your editor to use 4 spaces for tabs and to show whitespace characters.
3. Use linters: Integrate tools like Flake8 into your development workflow. They will catch indentation inconsistencies early.
4. Use code formatters: Tools like Black or isort can automatically reformat your code to a consistent style, eliminating indentation issues before you even commit your changes.

Q: What if I need an empty block of code (e.g., an if statement with no actions yet)?
A: You must use the pass keyword as a placeholder. pass is a null operation; nothing happens when it executes. It fulfills the requirement for an indented block.

if condition:
    pass # This block does nothing, but satisfies Python's syntax
else:
    print("Condition was false.")

Related Errors