Python pass (Do Nothing): When And How To Use

Python has a special keyword called pass. The Python pass keyword tells Python to do nothing at all. In other words: just pass this line of code and continue. If you are used to programming in C-like languages, you probably never needed such a statement.

  • So why does this keyword exist in Python and not in other languages?
  • And where and how would you use it?

This article answers these questions and shows you several situations in which Python’s pass keyword is needed. We’ll also look at an interesting alternative you might like to use instead!

What is the pass keyword

Python’s pass is a keyword, just like if, else, return, and others are keywords. pass doesn’t do anything. It’s a keyword that tells Python to continue running the program, ignoring this line of code. pass is often used as a placeholder for future code.

Note that because pass forms a valid statement on its own, pass can be called a statement too. Hence, you’ll see people using the words pass statement and pass keyword, and it’s both correct.

Why does Python need a pass keyword?

Python relies on indentation. Python can only detect a code block if it is indented with an equal amount of white space (usually four space characters). Python grammar is defined in such a way that code is required in some places. This is done because not adding code in these places would not make much sense and would not help with readability.

Let’s take a look at four places where you must have code. There might be more (please let me know), but these are the most prominent ones. If you don’t enter code in these places, Python will exit the program with an IndentationError exception:

  1. Function definitions
  2. Class definitions
  3. if… else statements
  4. try… except… finally statements

Let’s try some of these for the sake of demonstration:

def myfunction():
    # This function has no body, which is not allowed


Python will fail to run this code with the following error:

  File "", line 4
IndentationError: expected an indented block after function definition on line 1

Similar complaints will result in the other cases:

if True:
    # No code, not allowed!
    # Here too, code is required

    # let's try doing nothing (not allowed)
except Exception:
    # Again: this can't be empty!

class MyClass:
    # A completely empty class is not allowed

As you can see, a comment is not considered code, so comments can’t be used to fill in the gap! This is where the pass statement comes into play. In all the situations above, the pass statement can be used to insert code that does nothing but still satisfies the requirement of having some code in place. Let’s fill in the gaps:

def myfunction():


if True:

except Exception:

class MyClass:

This is all valid but completely useless code.

When to use Python’s pass keyword

So when should you use pass? There are several reasons, and I think these are the most common ones.

As a placeholder

As mentioned before, pass can be useful during development. We can use it to create stub functions and classes that will be implemented later on. This way we can create runnable code that doesn’t throw errors, even while not all the functions, classes, error handling, and if-else cases are implemented.

Ignoring exceptions

It’s very common to ignore exceptions, especially when they are KeyErrors. This is a pattern you’ll see often:

    email = customer['email']
    send_notification(email, ...)
except KeyError:
    # Not the end of the world, let's continue

We catch the error but don’t want to do anything with it. However, Python requires code in an except block, so we use pass.

Create a breakpoint while debugging

Another interesting use of pass is to create breakpoints in your code. Sometimes you want to create a breakpoint right after some code. If that code is at the end of a function, you might want to throw in an extra pass at the end and set your breakpoint there. To learn more about breakpoints, make sure to read my article on debugging Python code in VSCode and the article on using the Python debugger.

Creating subclasses with no extra functionality

If you want to create a subclass without adding functionality, you can use pass to do so. This can come in handy if you want to create a custom-named exception, for example:

class MyCustomException(Exception):

When not to use pass

In my opinion, you should use the pass keyword very sparingly in production code. And if you do, it should be incidental. As mentioned before, using pass to ignore an exception is obviously OK. But should you ship production code full of stubs using pass? I’m not sure!

If you find yourself using the pass keyword a lot, e.g., in ifelse constructs, you may want to try rewriting your code. Let’s look at an example:

if customer_exists:

In the above example, we check if a customer exists. If it does, we’re all set and we use pass to continue. If not, we redirect to a sign-up page. Code like this can be rewritten easily though, resulting in fewer lines of code and less complexity. Often, all you need to do is invert the logic:

if not customer_exists:

We saved ourselves two lines of code and made the code more readable.

An alternative to using pass

I’ve written a blog article on a special object in Python called the Ellipsis. In that article, I mentioned that we can use the Ellipsis to replace pass. The ellipsis object doesn’t do anything, hence it can be used exactly as you would use pass. Here’s an example:

def create_account(username, password):
    # TODO: implement me

Instead of using pass, I used the three dots ... that form an ellipsis object. Looks pretty cool, if you ask me, and it almost begs to be replaced by some actual code!

It doesn’t stop here, though. You can put any statement without side effects in spots where you would otherwise put pass, here are some possibilities:

  • A number, like 0
  • A boolean (True or False)
  • A string: “Not implemented yet”

Despite all these alternatives, pass is the de-facto standard in these cases and clearly communicates to others that this is intentionally left blank, or needs to be implemented. So when in doubt, use pass, especially when you’re working in a team.

Python pass vs continue

Many people asked me what the difference is between pass and continue. They might look the same, but they are far from the same. While pass does nothing at all, continue basically stops the current flow of code and directly starts the next iteration of a loop. Hence, continue only works inside loops and it can not be used as a replacement for pass.

Here’s how you would use continue in a for-loop:

# Send voucher to all inactive customers
for customer in customers:
    if customer.is_active():
        # Skip this customer
    # do some stuff to send voucher


We learned what Python’s pass keyword is, why Python needs the pass keyword, and in which cases you should and shouldn’t use it. We even looked at a pretty cool alternative: the ellipsis. Finally, I explained the difference between pass and continue.

Python Courses

Are you enjoying this free tutorial? Please also have a look at my premium courses. They offer a superior user experience with small, easy-to-digest lessons and topics, progress tracking, quizzes to test your knowledge, and practice sessions. Each course will earn you a downloadable course certificate.

The Python Fundamentals Course For Beginners
Now for $29 (from $49)

Python Fundamentals I is a course for beginners that will get you started with Python in no time. Learn all the essentials, test your progress with quizzes and assignments, and bring it all together with the final course project!

Python Course for Beginners

Modules, Packages, And Virtual Environments
Now for $29 (from $49)

Python Fundamentals II covers creating your own modules and packages, using virtual environments and Python package managers to make your life as a programmer easier. Advance your productivity as a Python programmer!

Python Fundamentals 2

Leave a Comment