Unix/Python Tutorial


This tutorial will cover the basics of working in the Unix environment for the Berkeley instructional machines and a small Python tutorial. It assumes you have an EECS Instructional account for CS 188 and that you know how to access it.


To get you familiarized with the automatic grading system, we will ask you to submit some code for this assignment. However, note that we have provided for all exercises, even those which you will submit. As such, you will only be graded on completion of the assignment. Of course, this does not mean that you should just download the solutions and submit them without working through the exercises yourself. Learning the basics of python now will save you many headaches later in the course.

For submission instructions, please see the submission instructions. Please read them. They contain important information on how to submit this and all further assignments. Failure to submit properly could result in a grade of 0 for the assignment.

This tutorial should be submitted with the name p0.

You will submit solutions for your buyLotsOfFruits function (see below) and your shopSmart function (see below). The tutorial is due by 11:59 pm on Tuesday, January 29th.

Unix Basics

You should have familiarity with basic Unix terminal commands used to navigate the directory structure and manage files. You should also know how to use a text editor, such as Emacs.

File/Directory Manipulation

When you open a terminal window, you're placed at a command prompt.

[cs188-tf@solar ~]$

The prompt shows your username, the host you are logged onto, and your current location in the directory structure (your path). The tilde character is shorthand for your home directory. To make a directory, use the mkdir command. Use cd to change to that directory:

[cs188-tf@solar ~]$ mkdir tutorial
[cs188-tf@solar ~]$ cd tutorial
[cs188-tf@solar ~/tutorial]$

The Python files used in this tutorial reside in the ~cs188/projects/tutorial directory. To copy them to your directory, use the cp command. The * is a useful way to specify multiple files in a given directory; *.py refers to all filenames that end have the .py ending. Note that . is shorthand for the current directory. Use ls to see a listing of the contents of a directory.

[cs188-tf@solar ~/tutorial]$ cp ~cs188/projects/tutorial/*.py .
[cs188-tf@solar ~/tutorial]$ ls

Some other useful Unix commands:

The Emacs text editor

Emacs is a customizable text editor which has some nice features specifically tailored for programmers. However, you can use any other text editor that you may prefer (such as vi, pico, or joe on Unix; or Notepad on Windows; or TextWrangler on Macs). To run Emacs, type emacs at a command prompt:

[cs188-tf@solar ~/tutorial]$ emacs test.py &
[1] 3262

Here we gave the argument test.py which will either open that file for editing if it exists, or create it otherwise. Emacs notices that test.py is a Python source file and enters Python-mode, which is supposed to help you write code. When editing this file you may notice some of that some text becomes automatically colored: this is syntactic highlighting to help you distinguish items such as keywords, variables, strings, and comments. Pressing Enter, Tab, or Backspace may cause the cursor to jump to weird locations: this is because Python is very picky about indentation, and Emacs is predicting the proper tabbing that you should use.

Some basic Emacs editing commands (C- means "while holding the Ctrl-key"):

You can also copy and paste using just the mouse. Using the left button, select a region of text to copy. Click the middle button to paste.

There are two ways you can use Emacs to develop Python code. The most straightforward way is to use it just as a text editor: create and edit Python files in Emacs; then run Python to test the code somewhere else, like in a terminal window. Alternatively, you can 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).

For advanced debugging, you may want to use an IDE like Eclipse. In that case, you should refer to PyDev.

Python Basics

The programming assignments in this course will be written in Python, an interpreted, object-oriented language that shares some features with both Java and Scheme. This tutorial will walk through the primary syntactic constructions in Python, using short examples. It is not required that you complete this tutorial; it is here for your benefit, to facilitate learning the Python language.

Invoking the Interpeter

Like Scheme, Python can be run in one of two modes. It can either be used interactively, via an interpeter, or it can be called from the command line to execute a script. We will first use the Python interpreter interactively.

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

[cs188-tf@solar ~/tutorial]$ python
Python 2.4.2 (#1, Jan 11 2006, 12:45:36)
[GCC 3.4.3] on sunos5
Type "help", "copyright", "credits" or "license" for more information.

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 wil be returned on the next line.

>>> 1 + 1
>>> 2 * 3
>>> 2 ** 3

The ** operator in the last example corresponds to exponentiation.

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

>>> 'artificial' + "intelligence"

There are many built-in methods which allow you to manipulate strings.

>>> 'artificial'.upper()
>>> 'HELP'.lower()
>>> len('Help')

Notice that we can use either single quotes ' ' or double quotes " " to surround string.

We can also store expressions into variables.

>>> s = 'hello world'
>>> print s
hello world
>>> s.upper()
>>> len(s.upper())
>>> num = 8.0
>>> num += 2.5
>>> print num

In Python, unlike Java or C, you do not have declare variables before you assign to them.

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

>>> s = 'abc'

>>> dir(s)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__','__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__','__repr__', '__rmod__', '__rmul__', '__setattr__', '__str__', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'replace', 'rfind','rindex', 'rjust', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

>>> help(s.find)
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.
>> s.find('b')

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 store a sequence of mutable items:

>>> fruits = ['apple','orange','pear','banana']
>>> fruits[0]

We can use the + operator to do list concatenation:

>>> otherFruits = ['kiwi','strawberry']
>>> fruits + otherFruits
>>> ['apple', 'orange', 'pear', 'banana', 'kiwi', 'strawberry']

Python also allows negative-indexing from the back of the list. For instance, fruits[-1] will access the last element 'banana':

>>> fruits[-2]
>>> fruits.pop()
>>> fruits
['apple', 'orange', 'pear']
>>> fruits.append('grapefruit')
>>> fruits
['apple', 'orange', 'pear', 'grapefruit']
>>> fruits[-1] = 'pineapple'
>>> fruits
['apple', 'orange', 'pear', 'pineapple']

We can also index multiple adjacent elements using the slice operator. For instance fruits[1:3] which returns a list containing the elements at position 1 and 2. In general fruits[start:stop] will get the elements in start, start+1, ..., stop-1. We can also do fruits[start:] which returns all elements starting from the start index. Also fruits[:end] will return all elements before the element at position end:

>>> fruits[0:2]
['apple', 'orange']
>>> fruits[:3]
['apple', 'orange', 'pear']
>>> fruits[2:]
['pear', 'pineapple']
>>> len(fruits)

The items stored in lists can be any Python data type. So for instance we can have lists of lists:

>>> lstOfLsts = [['a','b','c'],[1,2,3],['one','two','three']]
>>> lstOfLsts[1][2]
>>> lstOfLsts[0].pop()
>>> lstOfLsts
[['a', 'b'],[1, 2, 3],['one', 'two', 'three']]

Exercise: Play with some of the list functions. You can find the methods you can call on an object via the dir and get information about them via the help command:

>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',
'__delslice__', '__doc__', '__eq__', '__ge__', '__getattribute__',
'__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__',
'__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',
'__rmul__', '__setattr__', '__setitem__', '__setslice__', '__str__',
'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse',
>>> help(list.reverse)
Help on built-in function reverse:

    L.reverse() -- reverse *IN PLACE*
>>> lst = ['a','b','c']
>>> lst.reverse()
>>> ['c','b','a']

Note: Ignore functions with underscores "_" around the names; these are private helper methods.

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.

>>> pair = (3,5)
>>> pair[0]
>>> x,y = pair
>>> x
>>> y
>>> pair[1] = 6
TypeError: object does not support item assignment

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.

The last built-in data structure is the dictionary which stores a map from one type of object (the key) to another (the value). The key must be an immutable type (string, number, or tuple). The value can be any Python data type.

Note: in the example below, the printed order of the keys returned by Python could be different than shown below. The reason is that unlike lists which have a fixed ordering, a dictionary is simply a hash table for which there is no fixed ordering of the keys (see the FAQ about dictionary key ordering).

>>> studentIds = {'aria': 42.0, 'arlo': 56.0, 'john': 92.0 }
>>> studentIds['arlo']
>>> studentIds['john'] = 'ninety-two'
>>> studentIds
{'aria': 42.0, 'arlo': 56.0, 'john': 'ninety-two'}
>>> del studentIds['aria']
>>> studentIds
{'arlo': 56.0, 'john': 'ninety-two'}
>>> studentIds['aria'] = [42.0,'forty-two']
>>> studentIds
{'aria': [42.0, 'forty-two'], 'arlo': 56.0, 'john': 'ninety-two'}
>>> studentIds.keys()
['aria', 'arlo', 'john']
>>> studentIds.values()
[[42.0, 'forty-two'], 56.0, 'ninety-two']
>>> studentIds.items()
[('aria',[42.0, 'forty-two']), ('arlo',56.0), ('john','ninety-two')]
>>> len(studentIds)

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.

Exercise: How would you use the dictionary type in order to represent a set (rather than a list) of unique items?

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)
        print fruit + ' are too expensive!'
At the command line, use the following command in the directory containing foreach.py:

[cs188-tf@solar ~/tutorial]$ python foreach.py
apples for sale
oranges for sale
pears for sale
bananas for sale
oranges cost 1.500000 a pound
pears cost 1.750000 a pound
apples are too expensive!

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
Put this code into a file called listcomp.py and run the script:

[cs188-tf@solar ~/tutorial]$ python listcomp.py

Those of you familiar with Scheme, will recognize that the list comprehension is similar to the map function. In Scheme, the first list comprehension would be written as:
(define nums '(1,2,3,4,5,6))
   (lambda (x) (+ x 1))  nums)
Exercise: Write a list comprehension which, from a list, generates a lowercased version of each string that has length greater than five. Solution

Beware of Indendation!

Unlike many other languages, Python uses the indentation in the source code for interpretation. So for instance the script
if 0 == 1: 
    print 'We are in a world of arithmetic pain' 
print 'Thank you for playing' 
will output

Thank you for playing

But if we had written the script as
if 0 == 1: 
    print 'We are in a world of arithmetic pain'
    print 'Thank you for playing'
there would be no output. The moral of the story: be careful how you indent! Its best to use a single tab for indentation.

Writing Functions

As in Scheme, 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)
        cost = fruitPrices[fruit] * numPounds
        print "That'll be %f please" % (cost)

# Main Function
if __name__ == '__main__':        
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. Save this script as fruit.py and run it:

[cs188-tf@solar ~/tutorial]$ python fruit.py
That'll be 4.800000 please
Sorry we don't have coconuts

Exercise (for submission): 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 (which is like nil in Scheme). Solution

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:We will "sanity check" this portion of your code by testing that

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

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

Although this isn't a class in object-oriented programming, you'll have to use some objects in the programming projects, and so it's worth covering the basics of objects in Python. An object encapsulates data and provides functions for interacting with that data. Here's an 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 = 'CS 188'
fruitPrices = {'apples':2.00, 'oranges': 1.50, 'pears': 1.75}
myFruitShop = shop.FruitShop(name, fruitPrices)
print myFruitShop.getCostPerPound('apples')

otherName = 'CS 170'
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:

[cs188-tf@solar ~/tutorial]$ python shopTest.py
Welcome to the CS 188 fruit shop
Welcome to the CS 170 fruit shop

So what just happended? The import shop statement told Python to load all of the functions and classes in shop.py. These import statements are used more generally to load code modules. The line myFruitShop = shop.FruitShop(name, fruitPrices) constructs an instance of the FruitShop class defined in shop.py, by calling the __init__ function in that class. Note that we only passed two arguments in, while __init__ seems to take three arguments: (self, name, fruitPrices). The reason for this is that all methods in a class have self as the first argument. The self variable's value is automatically set by the interpreter; when calling a method, you only supply the remaining arguments. The self variable contains all the data (name and fruitPrices) for the current specific instance, similar to this in Java.

Exercise (for submission): 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. Solution

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

Test Case:We will 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'


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

More Python Tips and Tricks

This tutorial has briefly touched on some major aspects of Python that will be relevant to the course. Here's some more useful tidbits: