Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How to use the pass statement

Tags:

python

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. What would be a simple/basic situation where the pass statement would be used and why would it be needed?

like image 264
Capurnicus Avatar asked Dec 14 '12 20:12

Capurnicus


People also ask

How do you write a pass statement in Python?

Example. #!/usr/bin/python for letter in 'Python': if letter == 'h': pass print 'This is pass block' print 'Current Letter :', letter print "Good bye!" Current Letter : P Current Letter : y Current Letter : t This is pass block Current Letter : h Current Letter : o Current Letter : n Good bye!

What is a pass in Python?

In Python, pass is a null statement. The interpreter does not ignore a pass statement, but nothing happens and the statement results into no operation. The pass statement is useful when you don't write the implementation of a function but you want to implement it in the future.

Is pass a keyword in Python?

In Python, the pass keyword is an entire statement in itself. This statement doesn't do anything: it's discarded during the byte-compile phase. But for a statement that does nothing, the Python pass statement is surprisingly useful. Sometimes pass is useful in the final code that runs in production.


2 Answers

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.

like image 156
sebastian_oe Avatar answered Nov 16 '22 05:11

sebastian_oe


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. (Note that the Ellipsis literal is a valid expression only in Python 3)

    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, and there isn't a 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”)

like image 37
Anaphory Avatar answered Nov 16 '22 03:11

Anaphory