Python The pass Statement

Python uses indentation to define blocks, so an empty one would be indistinguishable from no block at all. Writing a colon and then nothing indented is a syntax error:

    def planned_report():

    ^
IndentationError: expected an indented block after function definition on line 1

pass is the smallest valid statement, so it's used anywhere a block is required but there's nothing to do yet: a function you'll write later, a class you'll fill in, an if branch you haven't decided on, or a loop body while you test the loop header.

A docstring also counts as a statement, so a function or class containing only a docstring is valid without pass. The ellipsis literal ... is another common placeholder, especially in type stubs and abstract method definitions; like pass, it does nothing when executed.

A function whose body is just pass runs, does nothing, and returns None, because every Python function that ends without a return statement returns None:

def feeding_count():
    pass

result = feeding_count()
print(result)          # None
print(result + 1)      # TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

That's the danger of placeholders. The program doesn't fail where the missing code is; it fails later, in whatever code used the None, which can make the bug hard to trace. A placeholder is fine during the first minutes of writing a program. Before anything else depends on the function, replace it with real code or make it fail loudly, as shown in the last section.

pass doesn't affect the flow of a loop at all. The rest of the iteration still runs:

for tank in ["reef", "river", "empty"]:
    if tank == "empty":
        pass              # no effect: the print below still runs
    print(tank)

All three names are printed. If the goal was to skip the empty tank, the statement needed is continue. Mixing these up is one of the most common beginner bugs, because the code runs without errors and only the output is wrong.

When unfinished code might actually be called, prefer to fail clearly instead of silently returning None. Raising NotImplementedError stops the program at the exact line that still needs work, with a message that explains why:

def feeding_report(tank):
    raise NotImplementedError("feeding_report is not written yet")

The same exception is used in base classes to mark methods that subclasses must provide. The abc module enforces this even earlier with @abstractmethod, which prevents the class from being instantiated until the method exists.

Never combine pass with broad exception handling:

try:
    update_feeding_log()
except Exception:
    pass                  # every error, including typos, disappears

This swallows every error without a trace. If an error really can be ignored, catch that specific exception and leave a comment or log message explaining why.

Task: replace a feeding report placeholder with a function returning a real count. Start from def feeding_count(schedule): pass and return the number of feedings that are not marked as skipped.

def feeding_count(schedule):
    """Return how many scheduled feedings will actually happen."""
    count = 0
    for tank, status in schedule:
        if status == "skip":
            continue
        count += 1
    return count

schedule = [("reef", "due"), ("river", "skip"), ("lagoon", "due")]
print(feeding_count(schedule))   # 2

Notice that skipping uses continue; replacing it with pass would count all three. For the worked check: does pass skip the rest of a loop iteration? No. It does nothing, so the following statements still run.

The language reference describes the pass statement and NotImplementedError. Revisit loops for break and continue, and error handling for raising exceptions. Practise with the Python exercises and Python quiz.