Python 101 - Introduction to Python - Part 2

by Dave Kuhlman
Wednesday, 3rd August 2005

Simple Statements

print

The print statement sends output to stdout.

Here are a few examples:  

Notes:

 

• To print multiple items, separate them with commas. The print statement inserts a blank between objects.

   

• The print statement automatically appends a newline to output. To print without a newline, add a comma after the last object, or use "sys.stdout", for example:

   

  print 'Output with no newline',
  

  which will append a blank, or:

   

  import sys
      sys.stdout.write("Some output")
  

   

• To re-define the destination of output from the print statement, replace sys.stdout with an instance of a class that supports the write method. For example:

   

  import sys
     
      class Writer:
      def __init__(self, filename):
      self.filename = filename
      def write(self, msg):
      f = file(self.filename, 'a')
      f.write(msg)
      f.close()
     
      sys.stdout = Writer('tmp.log')
      print 'Log message #1'
      print 'Log message #2'
      print 'Log message #3'
  

  Download as text (original file name: Examples/python_101_print_sysstdout.py).

   

More information on the print statement is at http://www.python.org/doc/current/ref/print.html.

Note: Note to Jython users - Jython does not appear to support the file constructor for files. In the above example, replace file with open.

import

The import statement makes a module and its contents available for use.

Here are several forms of the import statement:

 

import test

Import module test. Refer to x in test with "test.x".

 

from test import x

Import x from test. Refer to x in test with "x".

 

from test import *

Import all objects from test. Refer to x in test with "x".

 

import test as theTest

Import test; make it available as theTest. Refer to object x with "theTest.x".

 

A few comments about import:

 

• The import statement also evaluates the code in the imported module.

   

• But, the code in a module is only evaluated the first time it is imported in a program. So, for example, if a module mymodule.py is imported from two other modules in a program, the statements in mymodule will be evaluated only the first time it is imported.

   

• If you need even more variety that the import statement offers, see the imp module. Documentation at http://www.python.org/doc/current/lib/module-imp.html. Also see the __import__ built-in function. Documentation at http://www.python.org/doc/current/lib/built-in-funcs.html.

   

More information on import at http://www.python.org/doc/current/ref/import.html.

assert

Use the assert statement to place error checking statements in you code. Here is an example:

 

When arg2 is zero, running this code will produce something like the following:

 

A few comments:

 

• Notice that the trace-back identifies the file and line where the test is made and shows the test itself.

   

• If you run python with the optimize options (-O and -OO), the assertion test is not performed.

   

• The second argument to assert is optional.

   

global

The problem -- Imagine a global variable NAME. If, in a function, the first mention of that variable is "name = NAME", then I'll get the value of the the global variable NAME. But, if, in a function, my first mention of that variable is an assignment to that variable, then I will create a new local variable, and will not refer to the global variable at all. Consider:

 

Running this code produces:

 

The set_global modifies a local variable and not the global variable as I might have intended.

The solution -- How can I fix that? Here is how:

 

Notice the global statement in function set_global. Running this code does modify the global variable NAME, and produces the following output:

 

Comments:

 

• You can list more than one veriable in the global statement. For example:

   

  global NAME1, NAME2, NAME3

Control Structures

if 

The if statement enables us to execute code (or not) depending on a condition.

 

• "if condition: ..."

   

• "if condition: ... else: ..."

   

• "if condition1: ... elif condition2: ... else: ..."

   

Here is an example:

 

 

• The condition can be any expression, i.e. something that returns a value. A detailed description of expressions can be found at http://www.python.org/doc/current/ref/expressions.html.

   

• Parentheses are not needed around the condition. Use parentheses to group sub-expressions and control order of evaluation when the natural operator precedence is not what you want. Python's operator precedences are described at http://www.python.org/doc/current/ref/summary.html.

   

• Python has no switch statement. Use if-elif. Or consider using a dictionary, for example:

   

  def function1():
      print "Hi. I'm function1."
      def function2():
      print "Hi. I'm function2."
      def function3():
      print "Hi. I'm function3."
     
      mapper = {'one': function1, 'two': function2, 'three': function3}
     
      while 1:
      code = raw_input('Enter "one", "two", "three", or "quit": ')
      if code == 'quit':
      break
      if code not in mapper:
      continue
      mapper[code]()
  

  Download as text (original file name: Examples/python_101_if_switch.py).

Here is an example:

 

Comments:

 

• You can iterate over strings, lists, and tuples.

   

• Iterate over the keys or values in a dictionary with "aDict.keys()" and "aDict.values()". Here is an example:

   

  >>> aDict = {'cat': 'furry and cute', 'dog': 'friendly and smart'}
      >>> aDict.keys()
      ['dog', 'cat']
      >>> aDict.values()
      ['friendly and smart', 'furry and cute']
      >>> for key in aDict.keys():
      ... print 'A %s is %s.' % (key, aDict[key])
      ...
      A dog is friendly and smart.
      A cat is furry and cute.
  

   

• In recent versions of Python, a dictionary itself is an iterator for its keys. Therefore, you can also do the following:

   

  >>> for key in aDict:
      ... print 'A %s is %s.' % (key, aDict[key])
      ...
      A dog is friendly and smart.
      A cat is furry and cute.
  

   

• And, in recent versions of Python, a file is also an iterator over the lines in the file. Therefore, you can do the following:

   

  >>> infile = file('tmp.txt', 'r')
      >>> for line in infile:
      ... print line,
      ...
      This is line #1
      This is line #2
      This is line #3
      >>> infile.close()
  

   

• There are other kinds of iterations. For example, the built-in iter will produce an iterator from a collection. Here is an example:

   

  >>> anIter = iter([11,22,33])
      >>> for item in anIter:
      ... print 'item:', item
      ...
      item: 11
      item: 22
      item: 33
  

   

• You can also implement iterators of your own. To do so, define a function that returns values with yield (instead of with return). Here is an example:

   

  >>> def t(collection):
      ... icollection = iter(collection)
      ... for item in icollection:
      ... yield '||%s||' % item
      ...
      >>> for x in t(collection): print x
      ...
      ||111||
      ||222||
      ||333||

while

while is another repeating statement. It executes a block of code until a condition is false.

Here is an example:

 

Comments:

 

• Use the break statement to exit from a loop. This works for both for and while. Here is an example that uses break in a for statement:

   

  # for_break.py
      """Count lines until a line that begins with a double #.
      """
     
      import sys
     
      def countLines(infilename):
      infile = file(infilename, 'r')
      count = 0
      for line in infile.readlines():
      line = line.strip()
      if line[:2] == '##':
      break
      count += 1
      return count
     
      def usage():
      print 'Usage: python python_101_for_break.py <infilename>'
      sys.exit(-1)
     
      def main():
      args = sys.argv[1:]
      if len(args) != 1:
      usage()
      count = countLines(args[0])
      print 'count:', count
     
      if __name__ == '__main__':
      main()
  

  Download as text (original file name: Examples/python_101_for_break.py).

   

• Use the continue statement to skip the remainder of the code block in a for or while. A continue is a short-circuit which, in effect, branches back to the top of the for or while (or if you prefer, to the end of the block).

   

• The test "if __name__ == '__main__':" is used to enable the script to both be (1) imported and (2) run from the command line. That condition is true only when the script is run, but not imported. This is a common Python idiom, which you should consider including at the end of your scripts, whether (1) to give your users a demonstration of what your script does and how to use it or (2) to provide a test of the script.

try-except and raise -- Exceptions

Use a try:except: block to catch an exception.

Use raise to raise an exception.

Comments and hints:

 

• Catch all exceptions with a "bare" except:. For example:

   

  >>> try:
      ... x = y
      ... except:
      ... print 'y not defined'
      ...
      y not defined
  

   

• Catch a specific error by refering to an exception class in the except:. To determine what error or exception you want to catch, generate it and try it. Because Python reports errors with a walk-back that ends with reporting the exception, you can learn which exception to catch. For example, suppose I want to learn which exception is thrown when a Python can't open a file. I can try the following from the interactive prompt:

   

  >>> myfile = file('amissingfile.py', 'r')
      Traceback (most recent call last):
      File "<stdin>", line 1, in ?
      IOError: [Errno 2] No such file or directory: 'amissingfile.py'
  

  So, now I know that I can do:

   

  >>> try:
      ... myfile = file('amissingfile.py', 'r')
      ... except IOError:
      ... print 'amissingfile.py is missing'
      ...
      amissingfile.py is missing
  

   

• You can customize your error handling still further by passing an object on the raise and catching that object in the except:. By doing so, you can pass information up from the raise statement to an exception handler. One way of doing this is to pass an object. A reasonable strategy is to define a sub-class of a standard exception. For example:

   

  >>> class E(RuntimeError):
      ... def __init__(self, msg):
      ... self.msg = msg
      ... def getMsg(self):
      ... return self.msg
      ...
      >>>
      >>> try:
      ... raise E('my test error')
      ... except E, obj:
      ... print 'Msg:', obj.getMsg()
      ...
      Msg: my test error

Reading Text Files

To read a text file, first create a file object. Here is an example:

 

Then use one or more of the file object's methods to process the contents of the file. Here are a few strategies:

 

• Use "inFile.read()" to get the entire contents of the file (a string). Example:

   

  >>> inFile = file('tmp.txt', 'r')
      >>> content = inFile.read()
      >>> inFile.close()
      >>> print content
      aaa bbb ccc
      ddd eee fff
      ggg hhh iii
     
      >>> words = content.split()
      >>> print words
      ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg', 'hhh', 'iii']
      >>> for word in words:
      ... print word
      ...
      aaa
      bbb
      ccc
      ddd
      eee
      fff
      ggg
      hhh
      iii
  

   

• Use "for line in inFile:" to process one line at a time. You can do this because (at least since Python 2.3) file objects obey the iterator protocol, that is they support methods __iter__ and next. For more on the iterator protocol see http://www.python.org/doc/current/lib/typeiter.html.

  Example:

   

  >>> inFile = file('tmp.txt', 'r')
      >>> for line in inFile:
      ... print 'Line:', line,
      ...
      Line: aaaaa
      Line: bbbbb
      Line: ccccc
      Line: ddddd
      Line: eeeee
      >>> inFile.close()
  

   

• For earlier versions of Python, use "inFile.readlines()" or "inFile.xreadlines()".

   

• If your want to get the contents of an entire text file as a collection of lines, use readlines. Example:

   

  >>> inFile = file('tmp.txt', 'r')
      >>> lines = inFile.readlines()
      >>> print lines
      ['aaaaa\n', 'bbbbb\n', 'ccccc\n', 'ddddd\n', 'eeeee\n']
      >>> print lines[2]
      ccccc
     
      >>> inFile.close()

Iterator objects

This section explains how to implement iterator objects, that is a class that obeys the iterator protocol.

We explain generators first -- A generator is a function which uses yield. Because it returns values with yield instead of with return, the function can be resumed immediately after the yield. Here is an example:

 

Running this example produces the following output:

 

Notes:

 

• Notice that the value returned by the call to the generator (function) is an iterator. It obeys the iterator protocol. That is, "dir(anIter)" shows that it has both __iter__ and next.

   

• Because it is an iterator, we can use a for statement to iterate over the values returned by the generator.

   

• We can also get its values by repeatedly calling the next method, until it raises the StopIteration exception. This ability to call the next method enables us to pass the iterator object around and get values at different locations in our code.

   

• Once we have obtained all the values from an iterator, it is, in effect, "empty". The iterator protocol, in fact, specifies that once an iterator raises the StopIteration exception, it should continue to do so. Another way to say this, is that there is no "rewind" operation. But, you can call the the generator function again to get a "fresh" iterator.

   

Now, we will implement a class that obeys the iterator protocol. By doing so, we can produce "iterable" objects. Here is an example:

 

Iterating over an instance of the above class produces every other object from the sequence with which the instance was constructed. Running the above example produces the following:

 

Explanation:

 

• Method __iter__ should return an iterator. So, in our example it calls method _next to produce that iterator. _next is a generator (it contains yield), which means that it returns an iterator.

   

• Method next should return the next item in the sequence. But, this is exactly what the next method of the iterator returned by _next does. So, we just capture that using "self.next = self._next().next".

   

The definition of the iterator protocol is at http://www.python.org/doc/current/lib/typeiter.html.

Continue reading Part 3 of Python 101 - Introduction to Python

---

Dave Kuhlman has worked for many years on a variety of software development projects, in several programming languages, and on more than one platform. Because of Python's clear syntax, developer friendliness, and broad utility, Dave focuses his energy on the Python language, on systems built with Python, and on developing documentation and training materials for those systems. Dave's current work involves XML processing in Python as well as the development of tools and documentation for Zope and the CMSs (content management systems) that run on top of Zope, Dave's current platform is Debian GNU/Linux; he has installed and administers a small network composed of several Linux boxes behind a Linux router/gateway. More information about Dave's work can be found at http://www.rexx.com/~dkuhlman.