A Quick Tour of Python

Contents

• Python is Dynamic
• Braces? We Don't Need No Stinking Braces!
• Python Data Structures
  • Strings
  • Lists
  • Mutability
  • Tuples
  • Dictionaries
• Truth and Consequences
• Control Constructs
• Modules and Namespaces
• Objects, Classes, and What They Mean to You
• Defining Functions
• But Wait! There's More!
• Python Documentation and Books
  • Books
  • Documentation

Python is Dynamic

x = 1
name = "sample string"
name2 = 'another sample string'
name3 = """a multiline
  string example"""
y = 3.14
longint = 100000000000L
z = None

x = 1
x = "string value"

>>> x = 1
>>> x
1
>>> x+3
4

A common error is to expect the same behavior in Python scripts. In a script nothing will be printed for the above example; if you want a script to print a value, use the print statement. Another common error is to leave off parentheses for a Python function. For example,

>>> raw_input()

>>> raw_input
<built-in function raw_input>

Braces? We Don't Need No Stinking Braces!

This is perhaps the most controversial feature of Python for newcomers. Python does not use begin/end statements or braces {} to denote statement blocks. Instead, indentation is used to delimit blocks. Everything at the same level of indentation is considered in the same block. For example,

if x > 0:
   print "x is greater than 0"
   print "but I don't care"
if y > 0:
   print "y is greater than 0"

The main source of problems with indentation as a blocking scheme is inconsistent mixing of tabs and spaces. Python treats tabs as 8 spaces. If you use an editor that treats tabs as anything but 8 spaces, and you mix spaces and tabs, you may see indentations in your editor's display that appear identical but are different as far as Python is concerned. So the general rule is: Don't mix tabs and spaces for indentation. Use one or the other exclusively.

It may take a little time to adjust to the use of indentation for blocking, but if your experience is like ours, you will soon be wondering why all programming languages don't work this way. It leads to clear, easy-to-read code and is far less likely to lead to errors in blocking than approaches that use braces.

Python Data Structures

Strings

>>> x = 'test string'
>>> x[2]
's'
>>> x[1:3]
'es'
>>> x[-2]
'n'
>>> x[2:]
'st string'
>>> x[:2]
'te'

When a range (or "slice" in Python terminology) is specified, the second number represents an index that is not included as part of the range. One should view indexing as working like this

 0   1   2   3   4   5   6   7   8   9  10  11 positive indices
   t   e   s   t       s   t   r   i   n   g
-11 -10 -9  -8  -7  -6  -5  -4  -3  -2  -1     negative indices

Strings can be concatenated using the addition operator

>>> print "hello" + " world"
'hello world'

>>> print "hello"*5
'hellohellohellohellohello'

Lists

x = [1,4,9,"first three integer squares"]

>>> x[2]
9
>>> x[2:]
[9,"first three integer squares"]

>>> x.append('new end of list')
  or
>>> x = x + ['new end of list'] # i.e., '+' concatenates lists
>>> x
[1,4,9,'first three integer squares','new end of list']

>>> del x[3]
>>> x
[1, 4, 9, 'new end of list']
>>> x.insert(1,'two')
>>> x
[1, 'two', 4, 9, 'new end of list']

>>> 2*x[0:3]
[1, 'two', 4, 1, 'two', 4]

>>> x = [5, 3, 1, 2, 4, 6]
>>> x.sort()
>>> print x
[1, 2, 3, 4, 5, 6]
>>> x.reverse()
>>> print x
[6, 5, 4, 3, 2, 1]

A list can have any number of elements, including zero: [] represents the empty list.

Mutability

>>> x
[1,4,9,'new end of list']
>>> x[2] = 16
>>> x
[1,4,16,'new end of list']
>>> x[2:3] = [9,16,25]
[1,4,9,16,25,'new end of list']

Tuples

x = (1,"string")
x = ()   # empty tuple
x = (2,) # one element tuple requires a trailing comma (which is legal
         # for any length tuple also) to distinguish them from expressions

Dictionaries

>>> employee_id = {"ricky":11,"fred":12,"ethel":15}
>>> print employee_id["fred"]
12

>>> employee_id["lucy"] = 16

There are many operations available for dictionaries; for example, you can get a list of all the keys:

>>> print employee_id.keys()
['ricky', 'lucy', 'ethel', 'fred']

>>> del employee_id['fred']
>>> print employee_id.keys()
['ricky', 'lucy', 'ethel']

It is a rare Python program that doesn't use these basic data structures (strings, lists, and dictionaries) routinely and heavily. They can be mixed and matched in any way you wish. Dictionaries can contain lists, tuples, and other dictionaries (and different entries can contain different types of objects), and the same is true of lists and tuples.

Truth and Consequences

1. None is false.
2. Numeric types:
   • Nonzero values are true.
   • Zero values (0, 0L, 0.0, complex 0+0j) are false.
3. Strings, lists, tuples, dictionaries:
   • Empty values are false, so "", [], (), and {} are all false.
   • Non-empty values are true (even if filled with zeros or None's, for example, [None] is true. "" is false, but the string "false" is true).
4. Other objects:
   • All other objects are considered true (unless the programmer has done some fancy stuff to make them test as false). For example, after fh = open('filename'), the filehandle fh is true (even if the file is closed with fh.close()).

if x = 0:
   print "did I really mean to write a never used print statement?"

if x == 0:
   print "much better"

Control Constructs

for item in itemlist:
  print item

Note the colon after the statement -- all statements that control the execution of a following block of statements (including for, if, while, etc.) end with a colon.

To get the common loop over consecutive integers, use the built-in range function:

for i in range(100): print i

Modules and Namespaces

>>> import string
>>> x = 'my test string'
>>> print string.capitalize(x)
MY TEST STRING

>>> reload(mmm) 

You can import using an alternate form:

>>> from string import *
>>> print capitalize(s)

A better way to use the from ... import ... form of the import statement is to specify explicitly which names you want to import:

>>> from string import capitalize
>>> print capitalize(s)

Objects, Classes and What They Mean to You

Typically an object is created by calling a function (or at least something that looks like a function) and assigning the return value to a variable. Thereafter you may access and modify attributes of the object (its local variables, in effect). You can perform operations on the object (or have it perform actions) by calling its 'methods'. File handles provide a good example of what we mean.

>>> fin = open('input.txt','r') # open file in read mode and return file handle
>>> lines = fin.readlines()     # call a method that returns a list of lines
>>> for line in lines: print line
>>> print fin.name              # print name of the file for the fin object
                                # 'name' is an attribute of the file object
>>> fin.close()                 # close the file

Defining Functions

def factorial(n):
    """a simple factorial function with no overflow protection"""
    if n:
        return n*factorial(n-1)
    else:
        return 1

The string at the beginning of the function is called a "doc string" and contains documentation information on the function. It is available as the __doc__ attribute of the function, so print factorial.__doc__ will print the string for the example function. The doc string can have multiple lines and is by convention enclosed in triple quotes (which allow strings that extend across lines) even when it contains only a single line, as in the sample.

Python provides a great deal of flexibility in handling function arguments. Check books or references to see how to handle default values, keyword arguments and a variable number of arguments.

But Wait! There's More!