← Home

049. Pass

Placeholder for future implementation

049. Pass

RAM Manager: Filling in Stubs

Aryan is building his RAM manager in stages. He writes the function signatures first — with pass as placeholders — so the file is syntactically valid and he can import and test the structure before implementing everything.

class RamManager:
    def scan_processes(self):
        pass   # TODO: implement

    def kill_process(self, pid):
        pass   # TODO: implement

    def get_report(self):
        pass   # TODO: implement

Now it’s time to replace the stubs with real implementations. The noop function is correctly just return x — sometimes pass-through is genuinely the right behavior. But is_palindrome and count_vowels need real logic.

💡 Fun fact: The pass statement exists because Python, unlike C or Java, has no {} block delimiters — indented blocks are the syntax. Without pass, an empty def foo(): or if True: would be a SyntaxError. The related ... (Ellipsis literal) has become a popular alternative stub in modern Python, especially in type stubs (.pyi files) and abstract method bodies, since it reads as “to be defined.”

⚠️ Watch out: Leaving pass in a function you intended to implement is an easy way to ship broken code — the function runs without error, silently returns None, and the bug only surfaces when a caller tries to use the result. Some teams use a raise NotImplementedError("TODO") stub instead of pass so unfinished functions fail loudly rather than quietly.

🤔 Think about it: is_palindrome uses s[::-1] to reverse a string. This is an O(n) operation that creates a whole new string. If you had to check palindromes on strings of millions of characters, how would you write a more memory-efficient version that stops as soon as it finds a mismatch?

Learning objectives

  • Understand what pass does (and doesn’t do)
  • Use pass as a placeholder during development
  • Replace pass stubs with real implementations

Key concepts

  • pass
  • placeholder
  • stub

Try it

Concept detail
pass is Python’s null statement — syntactically required when a code block must exist but you have nothing to put there yet.
Why it exists: Python requires at least one statement in every block. If you leave a block empty, it’s a SyntaxError: def foo(): # SyntaxError: expected an indented block class Bar: # SyntaxError: expected an indented block if True: # SyntaxError: expected an indented block
Use pass as the placeholder: def foo(): pass # valid stub function class MyError(Exception): pass # empty exception class if debug_mode: pass # explicitly do nothing in this branch while waiting: pass # busy wait (usually bad, but valid)
pass vs None: pass is a statement — it’s a no-op executed at runtime None is a value — it can be assigned, returned, compared They’re completely different things that happen to look similar in intent
When you see pass in a codebase, it means either:
  1. “TODO: implement this” (developer left a stub)
  2. “Intentionally empty” (comment often explains why)
Related — the ellipsis … is also used as a stub placeholder, especially in type stubs: def process(data: list) -> dict: … # type stub
Solution
def noop(x):
    return x

def is_palindrome(s):
    s = s.lower()
    return s == s[::-1]

def count_vowels(s):
    count = 0
    for char in s.lower():
        if char in "aeiou":
            count += 1
    return count
Tests
def test_noop():
    assert noop(42) == 42
    assert noop("hello") == "hello"
    assert noop(None) is None

def test_palindrome_true():
    assert is_palindrome("racecar") == True
    assert is_palindrome("level") == True

def test_palindrome_case_insensitive():
    assert is_palindrome("Madam") == True, "Palindrome check should be case-insensitive"

def test_palindrome_false():
    assert is_palindrome("hello") == False

def test_palindrome_not_none():
    result = is_palindrome("racecar")
    assert result is not None, "is_palindrome still has 'pass' — returns None"

def test_count_vowels():
    assert count_vowels("hello") == 2
    assert count_vowels("aeiou") == 5

def test_count_vowels_uppercase():
    assert count_vowels("AEIOU") == 5, "count_vowels should be case-insensitive"

def test_count_vowels_none():
    assert count_vowels("xyz") == 0

def test_count_vowels_not_none():
    result = count_vowels("hello")
    assert result is not None, "count_vowels still has 'pass' — returns None"
Resources