Python Tutorial
Due Sunday, Jan. 23 by 11:59pm

This tutorial is adapted from one developed by John DeNero and Dan Klein at UC Berkeley.

Starting point code

Do the following steps to get the starting point code. Replace USERNAME with your own username.

1. Connect to the CS machines:
   ssh USERNAME@cslab.cs.swarthmore.edu


2. Make a new directory for this class and change into that directory:
   mkdir cs63
   cd cs63


3. Clone the repo with the starting point code:
   git clone git@github.swarthmore.edu:cs63-s22/tutorial-USERNAME.git


4. Then change into that directory and begin working:
   cd tutorial-USERNAME

Python Basics

You may find the Troubleshooting section helpful if you run into problems. It contains a list of the frequent problems previous students have encountered when following this tutorial.

Invoking the Interpreter

Exiting the Interpreter

Operators

Strings

Exercise 1: Learn about the methods Python provides for strings. In the file ex1_strings.py show some examples of applying the string methods.

To see what methods Python provides for a datatype, 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.

Built-in Data Structures

Lists

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

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

Tuples

Dictionaries

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

Exercise 3: Use dir and help to learn about the functions you can call on dictionaries. In the file ex3_dictionaries.py show examples of testing dictionaries.

Writing Programs

Exercise 4: Open the file ex4_foreach.py which includes the following code:

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

# Here is a dictionary mapping fruit names to prices
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!')

This program should produce the following output:

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!


List comprehension

In python, list comprehension is a shorthand way of creating a new list based on the values within an existing list.

For example, suppose we had a list called nums with the values [1,6,2,5,3,4] and we wanted to create a new list with these values each multiplied by 10. One way to accomplish this would be to use a for loop as shown below:

  new_nums = []
  for x in nums:
      new_nums.append(x*10)

However, list comprehension allows you to create this new list in a single line of code like this:

  new_nums = [x*10 for x in nums]
  

nums = [1,6,2,5,3,4]
plusOneNums = [x+1 for x in nums]
print(plusOneNums)
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)

Exercise 5: Put the above code in the file called ex5_listcomp.py. Add a few of your own list comprehension examples. Then you can run it like this:

$ python3 ex5_listcomp.py


Ensure that the output it produces makes sense to you.

For example, when given the list:
["Artificial", "Intelligence", "Is", "Fun"]
Your list comprehension should return the list:
["artificial", "intelligence", "Is", "Fun"]

To accomplish this you will need to use the following syntax for a more complex form of list comprehension that includes both an if and an else.

[f(x) if condition else g(x) for x in sequence]

NOTE: Successfully applying list comprehension within your python programs can make them more concise and easier to read.

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')

Writing 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))

def main():
    buyFruit('apples',2.4)
    buyFruit('coconuts',2)        

main()

Test Case: Check your code by testing that the program correctly outputs:

Cost of [('apples', 3.0), ('pears', 1.0), ('oranges', 2.0)] is 10.75

Object Basics

Defining Classes

class FruitShop(object):

    def __init__(self, name, fruitPrices):
        """
        name: Name of the fruit shop
        fruitPrices: Dictionary with keys as fruit strings and 
        prices for values, such as:
        {'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 it is in the dictionary
        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 for all available fruit
        """ 
        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?

1. Encapsulating the data prevents it from being altered or used inappropriately,
2. The abstraction that objects provide make it easier to write general-purpose code.

Using Objects

import shop

shopName = 'the Berkeley Bowl'
fruitPrices = {'apples': 1.00, 'oranges': 1.50, 'pears': 1.75}
berkeleyShop = shop.FruitShop(shopName, fruitPrices)
applePrice = berkeleyShop.getCostPerPound('apples')
print(applePrice)
print('Apples cost $%.2f at %s.' % (applePrice, shopName))

otherName = 'the Stanford Mall'
otherFruitPrices = {'kiwis':6.00, 'apples': 4.50, 'peaches': 8.75}
otherFruitShop = shop.FruitShop(otherName, otherFruitPrices)
otherPrice = otherFruitShop.getCostPerPound('apples')
print(otherPrice)
print('Apples cost $%.2f at %s.' % (otherPrice, otherName))
print("My, that's expensive!")

$ python3 shopTest.py
Welcome to the Berkeley Bowl fruit shop
1.0
Apples cost $1.00 at the Berkeley Bowl.
Welcome to the Stanford Mall fruit shop
4.5
Apples cost $4.50 at the Stanford Mall.
My, that's expensive!

Test Case: Check that, with the following variable definitions:

order1 = [('apples',1.0), ('oranges',3.0)]
order2 = [('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(order1, shops).getName() == 'shop1'

and

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

Submitting your code

To submit your code use git to add, commit and push the files that you modified.

More Python Tips and Tricks

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

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

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

• Use try and except to catch errors. For example, suppose you have a dictionary that is keyed on strings with integer values. The following snippet of code will produce an error:
  

  d = {}
  d['a'] = 1
  d['b'] = 2
  d['c'] = 3
  for letter in ['a', 'b', 'c', 'd', 'e']:
      print letter, "is a key with value", d[letter]
  

  One option for handling this problem is to wrap the problematic code in a try-except as shown below:

  for letter in ['a', 'b', 'c', 'd', 'e']:
      print letter, 
      try:
          value = d[letter]
          print "is a key with value", value
      except:
          print "is NOT a key"
  

  You can also catch an error and do nothing as shown here:

  for letter in ['a', 'b', 'c', 'd', 'e']:
      try:
          value = d[letter]
          print letter, "is a key with value", value
      except:
          pass
  

  You can read more about handling exceptions.
• 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)



Troubleshooting

• Problem:
  ImportError: No module named py
  

  Solution:
  When using import, do not include the ".py" from the filename.
  For example, you should say: import shop
  NOT: import shop.py

• Problem:
  NameError: name 'MyVariable' is not defined
  Even after importing you may see this.
  

  Solution:
  To access a member of a module, you have to type ModuleName.MemberName, where ModuleName is the name of the .py file, and MemberName is the name of the variable (or function) you are trying to access.

• Problem:
  TypeError: 'dict' object is not callable
  

  Solution:
  Dictionary looks up are done using square brackets: [ and ]. NOT parenthesis: ( and ).

• Problem:
  ValueError: too many values to unpack
  

  Solution:
  Make sure the number of variables you are assigning in a for loop matches the number of elements in each item of the list. Similarly for working with tuples.

  For example, if pair is a tuple of two elements (e.g. pair =('apple', 2.0)) then the following code would cause the "too many values to unpack error":
  (a,b,c) = pair
  

  Here is a problematic scenario involving a for loop:
  

  pairList = [('apples', 2.00), ('oranges', 1.50), ('pears', 1.75)]
  for fruit, price, color in pairList:
      print '%s fruit costs %f and is the color %s' % (fruit, price, color)
  

• Problem:
  AttributeError: 'list' object has no attribute 'length' (or something similar)
  

  Solution:
  Finding length of lists is done using len(NameOfList).

• Problem:
  Changes to a file are not taking effect.
  

  Solution:
  

  1. Make sure you are saving all your files after any changes.
  2. If you are editing a file in a window different from the one you are using to execute python, make sure you reload(YourModule) to guarantee your changes are being reflected. reload works similar to import.

More References!

• The place to go for more Python information: www.python.org