[cs188-tf@solar ~]$
mkdir
command. Use cd
to change to that directory:
[cs188-tf@solar ~]$ mkdir tutorial
[cs188-tf@solar ~]$ cd
tutorial
[cs188-tf@solar ~/tutorial]$
~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
buyLotsOfFruits.py
foreach.py
listcomp.py
listcomp2.py
quickSort.py
shop.py
shopSmart.py
shopTest.py
rm
removes (deletes) a file
mv
moves a file (ie. cut/paste instead of copy/paste)
man
displays documentation for a command
pwd
prints your current path
xterm
opens a new terminal window
mozilla
opens a web browser
&
to a command to run it in the background, i.e.
multi-tasking 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
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"):
C-x C-s
Save the current file
C-x C-f
Open a file, or create a new file it if doesn't exist
C-k
Cut a line, add it to the clipboard
C-y
Paste the contents of the clipboard
C-_
Undo
C-g
Abort a half-entered command 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
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
>>> 2 * 3
6
>>> 2 ** 3
8
The
**
operator in the last example corresponds to exponentiation.
+
operator is overloaded to do string concatenation on string values.
>>> 'artificial' + "intelligence"
'artificialintelligence'
>>>
'artificial'.upper()
'ARTIFICIAL'
>>>
'HELP'.lower()
'help'
>>> len('Help')
4
' '
or double quotes "
"
to surround string.
>>> s = 'hello world'
>>> print s
hello world
>>> s.upper()
'HELLO WORLD'
>>>
len(s.upper())
11
>>> num = 8.0
>>> num += 2.5
>>> print num
10.5
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')
1
Try out some of the string
functions listed in dir
(for now, ignore those with underscores '_'
around the method name).
>>> fruits =
['apple','orange','pear','banana']
>>> fruits[0]
'apple'
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]
'pear'
>>>
fruits.pop()
'banana'
>>> fruits
['apple', 'orange',
'pear']
>>> fruits.append('grapefruit')
>>> fruits
['apple', 'orange', 'pear', 'grapefruit']
>>> fruits[-1] =
'pineapple'
>>> fruits
['apple', 'orange', 'pear', 'pineapple']
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)
4
The items stored in lists can be any Python data type. So for
instsance we can have lists of lists:
>>> lstOfLsts =
[['a','b','c'],[1,2,3],['one','two','three']]
>>> lstOfLsts[1][2]
3
>>> lstOfLsts[0].pop()
'c'
>>>
lstOfLsts
[['a', 'b'],[1, 2, 3],['one', 'two',
'three']]
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',
'sort']
>>> help(list.reverse) Help on built-in function reverse: 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.
>>> pair = (3,5)
>>>
pair[0]
3
>>> x,y = pair
>>> x
3
>>>
y
5
>>> 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.
>>> studentIds = {'aria': 42.0, 'arlo': 56.0, 'john':
92.0 }
>>> studentIds['arlo']
56.0
>>>
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)
3
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?
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:
[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!
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
[1,3,5]
[2,4,6]
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)) (map (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
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.
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. 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: Add some more fruit to the
fruitPrices
dictionary and add a buyLotsOfFruit
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
quickSort
function in Python using list comprehensions. Use the first element as the
pivot. The solution should be very short. Solution
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? Save the class code above into a file
called shop.py. We can use the FruitShop
as follows:
Copy the code above into a file called shopTest.py (in the
same directory as shop.py) and run it: 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')
So what
just happended? The
[cs188-tf@solar
~/tutorial]$ python shopTest.py
Welcome to the CS 188 fruit
shop
2.0
Welcome to the CS 170 fruit shop
1.5import 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:
Write a function, shopSmart
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
range
to generate a sequence of integers, useful for
generating traditional indexed for
loops: for index in range(3): print lst[index]
reload
command:
>>>
reload(shop)