How to use the pass statement?

问题:

I am in the process of learning Python and I have reached the section about the pass statement. The guide I\'m using defines it as being a Null statement that is commonly used as a placeholder.

I still don\'t fully understand what that means though. Can someone show me a simple/basic situation where the pass statement would be used and why it is needed?

回答1:

Suppose you are designing a new class with some methods that you don\'t want to implement, yet.

class MyClass(object):
    def meth_a(self):
        pass

    def meth_b(self):
        print \"I\'m meth_b\"

If you were to leave out the pass, the code wouldn\'t run.

You would then get an:

IndentationError: expected an indented block

To summarize, the pass statement does nothing particular, but it can act as a placeholder, as demonstrated here.

回答2:

Python has the syntactical requirement that code blocks (after if, except, def, class etc.) cannot be empty. Empty code blocks are however useful in a variety of different contexts, such as in examples below, which are the most frequent use cases I have seen.

Therefore, if nothing is supposed to happen in a code block, a pass is needed for such a block to not produce an IndentationError. Alternatively, any statement (including just a term to be evaluated, like the Ellipsis literal ... or a string, most often a docstring) can be used, but the pass makes clear that indeed nothing is supposed to happen, and does not need to be actually evaluated and (at least temporarily) stored in memory.

• Ignoring (all or) a certain type of Exception (example from xml):

  try:
      self.version = \"Expat %d.%d.%d\" % expat.version_info
  except AttributeError:
      pass # unknown
  

  Note: Ignoring all types of raises, as in the following example from pandas, is generally considered bad practice, because it also catches exceptions that should probably be passed on to the caller, e.g. KeyboardInterrupt or SystemExit (or even HardwareIsOnFireError – How do you know you aren\'t running on a custom box with specific errors defined, which some calling application would want to know about?).

  try:
      os.unlink(filename_larry)
  except:
      pass
  

  Instead using at least except Error: or in this case preferably except OSError: is considered much better practice. A quick analysis of all python modules I have installed gave me that more than 10% of all except ...: pass statements catch all exceptions, so it\'s still a frequent pattern in python programming.

• Deriving an exception class that does not add new behaviour (e.g. in scipy):

  class CompileError(Exception):
      pass
  

  Similarly, classes intended as abstract base class often have an explicit empty __init__ or other methods that subclasses are supposed to derive. (e.g. pebl)

  class _BaseSubmittingController(_BaseController):
      def submit(self, tasks): pass
      def retrieve(self, deferred_results): pass
  

• Testing that code runs properly for a few test values, without caring about the results (from mpmath):

  for x, error in MDNewton(mp, f, (1,-2), verbose=0,
                           norm=lambda x: norm(x, inf)):
      pass
  

• In class or function definitions, often a docstring is already in place as the obligatory statement to be executed as the only thing in the block. In such cases, the block may contain pass in addition to the docstring in order to say “This is indeed intended to do nothing.”, for example in pebl:

  class ParsingError(Exception): 
      \"\"\"Error encountered while parsing an ill-formed datafile.\"\"\"
      pass
  

• In some cases, pass is used as a placeholder to say “This method/class/if-block/... has not been implemented yet, but this will be the place to do it”, although I personally prefer the Ellipsis literal ... in order to strictly differentiate between this and the intentional “no-op” in the previous example. For example, if I write a model in broad strokes, I might write

  def update_agent(agent):
      ... 
  

  where others might have

  def update_agent(agent):
      pass
  

  before

  def time_step(agents):
      for agent in agents:
          update_agent(agent)
  

  as a reminder to fill in the update_agent function at a later point, but run some tests already to see if the rest of the code behaves as intended. (A third option for this case is raise NotImplementedError. This is useful in particular for two cases: Either “This abstract method should be implemented by every subclass, there is no generic way to define it in this base class”, or “This function, with this name, is not yet implemented in this release, but this is what its signature will look like”)

回答3:

Besides its use as a placeholder for unimplemented functions, pass can be useful in filling out an if-else statement (\"Explicit is better than implicit.\")

def some_silly_transform(n):
    # Even numbers should be divided by 2
    if n % 2 == 0:
        n /= 2
        flag = True
    # Negative odd numbers should return their absolute value
    elif n < 0:
        n = -n
        flag = True
    # Otherwise, number should remain unchanged
    else:
        pass

Of course, in this case, one would probably use return instead of assignment, but in cases where mutation is desired, this works best.

The use of pass here is especially useful to warn future maintainers (including yourself!) not to put redundant steps outside of the conditional statements. In the example above, flag is set in the two specifically mentioned cases, but not in the else-case. Without using pass, a future programmer might move flag = True to outside the condition—thus setting flag in all cases.

---

Another case is with the boilerplate function often seen at the bottom of a file:

if __name__ == \"__main__\":
    pass

In some files, it might be nice to leave that there with pass to allow for easier editing later, and to make explicit that nothing is expected to happen when the file is run on its own.

---

Finally, as mentioned in other answers, it can be useful to do nothing when an exception is caught:

try:
    n[i] = 0
except IndexError:
    pass

回答4:

The best and most accurate way to think of pass is as a way to explicitly tell the interpreter to do nothing. In the same way the following code:

def foo(x,y):
    return x+y

means \"if I call the function foo(x, y), sum the two numbers the labels x and y represent and hand back the result\",

def bar():
    pass

means \"If I call the function bar(), do absolutely nothing.\"

The other answers are quite correct, but it\'s also useful for a few things that don\'t involve place-holding.

For example, in a bit of code I worked on just recently, it was necessary to divide two variables, and it was possible for the divisor to be zero.

c = a / b

will, obviously, produce a ZeroDivisionError if b is zero. In this particular situation, leaving c as zero was the desired behavior in the case that b was zero, so I used the following code:

try:
    c = a / b
except ZeroDivisionError:
    pass

Another, less standard usage is as a handy place to put a breakpoint for your debugger. For example, I wanted a bit of code to break into the debugger on the 20th iteration of a for... in statement. So:

for t in range(25):
    do_a_thing(t)
    if t == 20:
        pass

with the breakpoint on pass.

回答5:

A common use case where it can be used \'as is\' is to override a class just to create a type (which is otherwise the same as the superclass), e.g.

class Error(Exception):
    pass

So you can raise and catch Error exceptions. What matters here is the type of exception, rather than the content.

回答6:

if you don\'t know what you are going to put in a certain code block

try:
   int(someuserinput)
except ValueError:
   pass

I like to use it when stubbing out tests too. I often times am aware of what i would liek to test but dont\' quite know how to do it. Testing example looks like what sebastian_oe suggested

class TestFunctions(unittest.TestCase):

   def test_some_feature(self):
      pass

   def test_some_other_feature(self):
      pass

回答7:

pass in Python basically does nothing, but unlike a comment it is not ignored by interpreter. So you can take advantage of it in a lot of places by making it a place holder:

1: Can be used in class

   class TestClass: 
      pass

2: Can be use in loop and conditional statements:

   if (something == true):  # used in conditional statement
       pass

   while (some condition is true):  # user is not sure about the body of the loop
       pass

3: Can be used in function :

   def testFunction(args): # programmer wants to implement the body of the function later
       pass

pass is mostly used when programmer does not want to give implementation at the moment but still wants to create a certain class/function/conditional statement which can be used later on. Since the Python interpreter does not allow for blank or unimplemented class/function/conditional statement it gives an error:

IndentationError: expected an indented block

pass can be used in such scenarios.

回答8:

You can say that pass means NOP (No Operation) operation. You will get a clear picture after this example :-

C Program

#include<stdio.h>

void main()
{
    int age = 12;

    if( age < 18 )
    {
         printf(\"You are not adult, so you can\'t do that task \");
    }
    else if( age >= 18 && age < 60)
    {
        // I will add more code later inside it 
    }
    else
    {
         printf(\"You are too old to do anything , sorry \");
    }
}

Now how you will write that in Python :-

age = 12

if age < 18:

    print \"You are not adult, so you can\'t do that task\"

elif age >= 18 and age < 60:

else:

    print \"You are too old to do anything , sorry \"

But your code will give error because it required an indented block after elif . Here is the role of pass keyword.

age = 12

if age < 18:

    print \"You are not adult, so you can\'t do that task\"

elif age >= 18 and age < 60:

    pass

else:

    print \"You are too old to do anything , sorry \"

Now I think its clear to you.

回答9:

The pass statement does nothing. It can be used when a statement is required syntactically but the program requires no action.

回答10:

Honestly, I think the official Python docs describe it quite well and provide some examples:

The pass statement does nothing. It can be used when a statement is required syntactically but the program requires no action. For example:

>>> while True: ... pass # Busy-wait for keyboard interrupt (Ctrl+C) ...

This is commonly used for creating minimal classes:

>>> class MyEmptyClass: ... pass ...

Another place pass can be used is as a place-holder for a function or conditional body when you are working on new code, allowing you to keep thinking at a more abstract level. The pass is silently ignored:

>>> def initlog(*args): ... pass # Remember to implement this! ...

回答11:

as the book said, I only ever use it as a temporary placeholder, ie,

# code that does something to to a variable, var
if var == 2000:
    pass
else:
    var += 1

and then later fill in the scenario where var == 2000

回答12:

Here\'s an example where I was extracting particular data from a list where I had multiple data types (that\'s what I\'d call it in R-- sorry if it\'s the wrong nomenclature) and I wanted to extract only integers/numeric and NOT character data.

The data looked like:

>>> a = [\'1\', \'env\', \'2\', \'gag\', \'1.234\', \'nef\']
>>> data = []
>>> type(a)
<class \'list\'>
>>> type(a[1])
<class \'str\'>
>>> type(a[0])
<class \'str\'>

I wanted to remove all alphabetical characters, so I had the machine do it by subsetting the data, and \"passing\" over the alphabetical data:

a = [\'1\', \'env\', \'2\', \'gag\', \'1.234\', \'nef\']
data = []
for i in range(0, len(a)):
    if a[i].isalpha():
        pass
    else:
        data.append(a[i])
print(data)
[\'1\', \'2\', \'1.234\']

回答13:

The pass statement in Python is used when a statement is required syntactically but you do not want any command or code to execute.

The pass statement is a null operation; nothing happens when it executes. The pass is also useful in places where your code will eventually go, but has not been written yet (e.g., in stubs for example):

`Example:

#!/usr/bin/python

for letter in \'Python\': 
   if letter == \'h\':
      pass
      print \'This is pass block\'
   print \'Current Letter :\', letter

print \"Good bye!\"

This will produce following result:

Current Letter : P
Current Letter : y
Current Letter : t
This is pass block
Current Letter : h
Current Letter : o
Current Letter : n
Good bye!

The preceding code does not execute any statement or code if the value of letter is \'h\'. The pass statement is helpful when you have created a code block but it is no longer required.

You can then remove the statements inside the block but let the block remain with a pass statement so that it doesn\'t interfere with other parts of the code.