1.3.2 Indentation rules and code organization

Indentation plays a fundamental role in Python as it defines the structure of the code, making it readable and clear. Python relies on indentation to indicate the level of nesting and the scope of code blocks, such as functions, loops, conditionals, and classes.

Here are the key rules and guidelines for indentation and code organization in Python:

1. Importance of Indentation

• Indentation in Python is mandatory: Python does not use curly braces {} or keywords like begin and end to define code blocks, unlike languages such as C, C++, or Java. Instead, it uses indentation to group statements that belong to the same block.
• Indentation indicates scope: A block of code that is indented at the same level indicates that it belongs to the same logical group (e.g., the body of a loop or function). Incorrect indentation will lead to errors or unexpected behavior.

Example:

# Correct Indentation
if True:
    print("This is inside the if block")
    x = 5
    print(x)

# Incorrect Indentation (will raise IndentationError)
if True:
print("This is inside the if block")  # This line should be indented

2. Indentation Level

• Standard indentation: Python does not require a specific number of spaces or tabs but PEP 8, which is the official Python style guide, recommends 4 spaces per indentation level.
  • It is important to consistently use either spaces or tabs, not both. Mixing tabs and spaces can lead to errors that are difficult to debug.
  • Many modern code editors, such as VSCode or PyCharm, automatically handle indentation for you by converting tabs to spaces.

Example:

# 4 spaces indentation per level (recommended by PEP 8)
def greet():
    name = "Alice"
    if name == "Alice":
        print(f"Hello, {name}!")

# This will raise an error due to inconsistent indentation
def greet():
	name = "Alice"  # Tab used for indentation here
    if name == "Alice":  # Spaces used here, causes error
        print(f"Hello, {name}!")

3. Indentation in Control Flow Statements

Python relies on indentation to define the body of control flow statements like if, for, while, etc. The indented code belongs to the block controlled by the statement.

Example:

# Indentation within an 'if' statement
x = 10
if x > 5:
    print("x is greater than 5")  # Indented line inside 'if'
else:
    print("x is less than or equal to 5")  # Indented line inside 'else'

In the example above, the indented lines after if and else define the block of code that will be executed if the condition is true or false, respectively.

4. Functions and Methods

The body of a function is indented to define its scope. The function itself is defined using the def keyword, and the indented lines following it represent the code that belongs to that function.

Example:

def add(a, b):
    result = a + b  # Indented block belonging to the function
    return result

print(add(3, 5))

5. Nested Structures

Indentation is also used for nested code blocks. For example, if a loop is inside a function or an if statement is inside a loop, each block should be properly indented.

Example:

def process_numbers(numbers):
    for number in numbers:
        if number % 2 == 0:
            print(f"{number} is even")
        else:
            print(f"{number} is odd")

process_numbers([1, 2, 3, 4])

Here, the if and else statements are nested inside the for loop, so they are indented under it. The for loop itself is indented under the process_numbers function.

6. Indentation Errors

• Python will raise an IndentationError if the indentation is not consistent or proper. This is one of the most common types of errors that Python developers encounter.

Example of IndentationError:

# This will raise IndentationError due to inconsistent indentation
def greet():
    name = "Alice"
  print(f"Hello, {name}!")  # The 'print' statement is not properly indented

7. Code Organization Best Practices

To maintain readability and clarity, Python code should be organized in a consistent and clean manner. Here are some best practices for code organization:

• Function and Variable Naming:
  • Use descriptive and meaningful names.
  • Follow the PEP 8 naming conventions: functions and variable names should use lowercase with underscores (e.g., my_function, user_name), while class names should use CamelCase (e.g., MyClass).
• Docstrings for Documentation:
  • Use docstrings (triple quotes) to describe the functionality of your functions, classes, and modules. This provides clarity about the purpose of the code.

  Example:

  def greet(name):
      """
      This function takes a name as input and prints a greeting.
      :param name: str
      :return: None
      """
      print(f"Hello, {name}!")
  

• Use Blank Lines:
  • Leave blank lines between top-level functions and class definitions to improve readability. You can also use blank lines within functions to separate logical sections of code.
• Limit Line Length:
  • PEP 8 recommends keeping lines at 79 characters or fewer to ensure that your code is easy to read and doesn't require horizontal scrolling.

8. Summary of Indentation Rules

• Python requires proper indentation to define code blocks.
• 4 spaces per indentation level is the standard, as per PEP 8.
• Consistent use of spaces or tabs is critical (do not mix them).
• Indentation defines the scope of loops, conditionals, functions, and classes.
• Proper code organization and documentation contribute to clean, readable, and maintainable code.

By following these indentation rules and best practices, your Python code will be structured, readable, and easy to maintain.