DM828 -- Python tutorial

Python Basics

The programming assignments in this course will be in Python, an interpreted, object-oriented language that shares some features with both Java and Scheme (from which R derives as well). This tutorial will walk through the primary syntactic constructions in Python, using short examples.

• www.python.org, its tutorial and its documentation
• Allen B. Downey: Think Python: How to Think Like a Computer Scientist, Version 1.1.24, Green Tea Press, 2009.
• A good reference book: Learning Python

Invoking the Interpeter

You invoke the interpreter by entering python at the Unix command prompt.

Operators

The Python interpeter can be used to evaluate expressions, for example simple arithmetic expressions. If you enter such expressions at the prompt (>>>) they will be evaluated and the result will be returned on the next line.

Boolean operators also exist in Python to manipulate the primitive True and False values.

You can also use the “not” operator to negate a boolean expression:

Strings

Like Java, Python has a built in string type. The + operator is overloaded to do string concatenation on string values.

Exercise: Learn about the methods Python provides for strings. To do this use the dir and help commands:

Help on built-in function find:



find(...)
    S.find(sub [,start [,end]]) -> int
    
    Return the lowest index in S where substring sub is found,
    such that sub is contained within s[start,end].  Optional
    arguments start and end are interpreted as in slice notation.
    
    Return -1 on failure.

Try out some of the string functions listed in dir (for now, ignore those with underscores '_' around the method name).

Built-in Data Structures

Python comes equipped with some useful built-in data structures, broadly similar to Java's collections package.

Lists

Lists store a sequence of mutable items:

>>> help(list.reverse)
Help on built-in function reverse:

reverse(...)
    L.reverse() -- reverse *IN PLACE*

Tuples

A data structure similar to the list is the tuple, which is like a list except that it is immutable once it is created (i.e. you cannot change its content once created). Note that tuples are surrounded with parentheses while lists have square brackets.

The attempt to modify an immutable structure raised an exception. This is how many errors will manifest: index out of bounds errors, type errors, and so on will all report exceptions in this way.

Sets

A set is another data structure that serves as an unordered list with no duplicate items. Below, we show how to create a set, add things to the set, test if an item is in the set, and perform common set operations (difference, intersection, union):

>>> shapes = ['circle','square','triangle','circle']
>>> setOfShapes = set(shapes)
>>> setOfShapes
set(['circle','square','triangle'])
>>> setOfShapes.add('polygon')
>>> setOfShapes
set(['circle','square','triangle','polygon'])
>>> 'circle' in setOfShapes
True
>>> 'rhombus' in setOfShapes
False
>>> favoriteShapes = ['circle','triangle','hexagon']
>>> setOfFavoriteShapes = set(favoriteShapes)
>>> setOfShapes - setOfFavoriteShapes
set(['square','polyon'])
>>> setOfShapes & setOfFavoriteShapes
set(['circle','triangle'])
>>> setOfShapes | setOfFavoriteShapes
set(['circle','square','triangle','polygon','hexagon'])

Note that the objects in the set are unordered; you cannot assume that their traversal or print order will be the same across machines!

Dictionaries

As with nested lists, you can also create dictionaries of dictionaries.

Exercise: Use dir and help to learn about the functions you can call on dictionaries.

Writing Scripts

Now that you've got a handle on using Python interactively, let's write a simple Python script that demonstrates Python's for loop. Open the file called foreach.py and update it with the following code:

# This is what a comment looks like 
fruits = ['apples','oranges','pears','bananas']
for fruit in fruits:
    print fruit + ' for sale'

fruitPrices = {'apples': 2.00, 'oranges': 1.50, 'pears': 1.75}
for fruit, price in fruitPrices.items():
    if price < 2.00:
        print '%s cost %f a pound' % (fruit, price)
    else:
        print fruit + ' are too expensive!'

At the command line, use the following command in the directory containing foreach.py:

Beware of Indendation!

if 0 == 1: 
    print 'We are in a world of arithmetic pain' 
print 'Thank you for playing' 

if 0 == 1: 
    print 'We are in a world of arithmetic pain'
    print 'Thank you for playing'

The next snippet of code demonstrates python's list comprehension construction:

nums = [1,2,3,4,5,6]
plusOneNums = [x+1 for x in nums]
oddNums = [x for x in nums if x % 2 == 1]
print oddNums
oddNumsPlusOne = [x+1 for x in nums if x % 2 ==1]
print oddNumsPlusOne

If you like functional programming (like Scheme) you might also like map and filter:

>>> map(lambda x: x * x, [1,2,3])
[1, 4, 9]
>>> filter(lambda x: x > 3, [1,2,3,4,5,4,3,2,1])
[4, 5, 4]

The map is similar to the list comprehension. You can learn more about lambda if you're interested.

Exercise: Write a list comprehension which, from a list, generates a lowercased version of each string that has length greater than five. Solution

Writing Functions

You can define your own functions:

fruitPrices = {'apples':2.00, 'oranges': 1.50, 'pears': 1.75}

def buyFruit(fruit, numPounds):
    if fruit not in fruitPrices:
        print "Sorry we don't have %s" % (fruit)
    else:
        cost = fruitPrices[fruit] * numPounds
        print "That'll be %f please" % (cost)

# Main Function
if __name__ == '__main__':        
    buyFruit('apples',2.4)
    buyFruit('coconuts',2)        

Rather than having a main function as in Java, the __name__ == '__main__' check is used to delimit expressions which are executed when the file is called as a script from the command line. Read this thread on how to write main functions.

Save this script as fruit.py and run it:

Exercise: Add some more fruit to the fruitPrices dictionary and add a buyLotsOfFruit(orderList) function which takes a list of (fruit,pound) tuples and returns the cost of your list. If there is some fruit in the list which doesn't appear in fruitPrices it should print an error message and return None.

This function should be defined in a file called buyLotsOfFruits.py. A stub implementation is provided here. Note that the fruitPrices variable must be set exactly as it is in the stub.

Test Case:You can "sanity check" this portion of your code by testing that

buyLotsOfFruits.buyLotsOfFruit([ ('apples', 2.0), ('pears',3.0), ('limes',4.0) ]) == 12.25

Solution

Advanced Exercise: Write a quickSort function in Python using list comprehensions. Use the first element as the pivot. The solution should be very short. Solution

Object Basics

An object (class) encapsulates data and provides functions for interacting with that data. Here's a definition example:

class FruitShop:

    def __init__(self, name, fruitPrices):
        """
            name: Name of the fruit shop
            
            fruitPrices: Dictionary with keys as fruit 
            strings and prices for values e.g. 
            {'apples':2.00, 'oranges': 1.50, 'pears': 1.75} 
        """
        self.fruitPrices = fruitPrices
        self.name = name
        print 'Welcome to the %s fruit shop' % (name)
        
    def getCostPerPound(self, fruit):
        """
            fruit: Fruit string
        Returns cost of 'fruit', assuming 'fruit'
        is in our inventory or None otherwise
        """
        if fruit not in self.fruitPrices:
            print "Sorry we don't have %s" % (fruit)
            return None
        return self.fruitPrices[fruit]
        
    def getPriceOfOrder(self, orderList):
        """
            orderList: List of (fruit, numPounds) tuples
            
        Returns cost of orderList. If any of the fruit are  
        """ 
        totalCost = 0.0             
        for fruit, numPounds in orderList:
            costPerPound = self.getCostPerPound(fruit)
            if costPerPound != None:
                totalCost += numPounds * costPerPound
        return totalCost
    
    def getName(self):
        return self.name

The FruitShop class has some data, the name of the shop and the prices per pound of some fruit, and it provides functions, or methods, on this data.

What advantage is there to wrapping this data in a class? There are two reasons:
1) Encapsulating the data prevents it from being altered or used inappropriately and
2) The abstraction that objects provide make it easier to write general-purpose code.

So how do we make an object and use it? Download the FruitShop implementation from here and save it to a file called shop.py. We can use the FruitShop as follows:

import shop

name = 'DM828'
fruitPrices = {'apples':2.00, 'oranges': 1.50, 'pears': 1.75}
myFruitShop = shop.FruitShop(name, fruitPrices)
print myFruitShop.getCostPerPound('apples')

otherName = 'DM811'
otherFruitPrices = {'kiwis':1.00, 'bananas': 1.50, 'peaches': 2.75}
otherFruitShop = shop.FruitShop(otherName, otherFruitPrices)
print otherFruitShop.getCostPerPound('bananas')

Copy the code above into a file called shopTest.py (in the same directory as shop.py) and run it:

Static vs Instance Variables

The following example with illustrate how to use static and instance variables in python.

class Person:
  population = 0
  def __init__(self, myAge):
      self.age = myAge
      Person.population += 1

  def get_population(self):
      return Person.population

  def get_age(self):
      return self.age

We first compile the script:

Now use the class as follows:

>>> import person_class
>>> p1 = person_class.Person(12)
>>> p1.get_population()
1
>>> p2 = person_class.Person(63)
>>> p1.get_population()
2
>>> p2.get_population()
2
>>> p1.get_age()
12
>>> p2.get_age()
63

In the code above, age is an instance variable and population is a static variable. population is shared by all instances of the Person class whereas each instance has its own age variable.

Exercise: Write a function, shopSmart(orders,shops) which takes an orderList (like the kind passed in to FruitShop.getCostOfOrder and a list of FruitShop and returns the FruitShop where your order costs the least amount in total.

This function should be defined in a file called shopSmart.py. A stub implementation is provided here. Note that the shop.py implementation is provided as a "support" file, so please do not submit it.

Test Case: You can check that, with the following variable definitions:

orders1 = [('apples',1.0), ('oranges',3.0)]
orders2 = [('apples',3.0)]			 
dir1 = {'apples': 2.0, 'oranges':1.0}
shop1 =  shop.FruitShop('shop1',dir1)
dir2 = {'apples': 1.0, 'oranges': 5.0}
shop2 = shop.FruitShop('shop2',dir2)
shops = [shop1, shop2]

The following are true:

shopSmart.shopSmart(orders1, shops).getName() == 'shop1'

and

shopSmart.shopSmart(orders2, shops).getName() == 'shop2'

Solution

Tricks and Tips

Here are some more useful bits of information:

• Emacs and gedit are good for editing Python scripts. Emacs also allows to run Python inside Emacs: see the options under "Python" in the menubar, or type C-c ! to start a Python interpreter in a split screen. (Use C-x o to switch between the split screens). See here for Emacs keybindings.
• Eclipse has also a python perspective: PyDev.
• IPython can be used as a system shell replacement, especially on Windows, which has a minimally capable shell. It offers enhanced introspection, additional shell syntax, code highlighting, tab completion string completion and rich history. It is a component of the SciPy package.
• After importing a file, if you edit a source file, the changes will not be immediately propagated in the interpreter. For this, use the reload command:

>>> reload(shop)


• Use range to generate a sequence of integers, useful for generating traditional indexed for loops:

  for index in range(3):
      print lst[index]
  

Note that indices start from 0.



• names should start in letters A-Za-z
• Python is case sensitive
• underscore can be used in names but not @ $ % =
• start with capital letter if name of a class
• whether an attribute, function or method of a class is public or private depends on the way its name starts:
  • with underscore if private function
  • with 2 underscores (but doesn't end with), it is a private
  • with 2 underscores and ends with 2 underscores then it is a language special method
  • On lambda functions (see also Python Information and Examples)
  • For details on private attribute see here.

Last modified: Mon Nov 7 18:50:14 CET 2011