Python lecture 05

Python & Perl

Lecture 06

Department of Computer ScienceUtah State University

Recap

● Types in Python ● Built-in Sequences● List: Python's Workhorse● Function parameters● Scoping

Outline

● Object Comparison● Loops● Dictionaries

Object Comparison

Object Comparison

● The operators <, >, ==, >=, <=, and != compare the values of two objects

● The objects need not have the same type

Object Comparison● Numbers are compared arithmetically● Strings are compared lexicographically using the numeric

equivalents of their characters● Tuples and lists are compared lexicographically using

comparison of corresponding elements● Sequences, to compare equal, must be of the same type and

have the same length and the corresponding elements must compare equal

● Mappings (dictionaries) compare equal if and only if their sorted (key, value) lists compare equal

cmp(x, y) ● cmp(x, y) is a built-in function● cmp(x, y) returns

-1 if x < y

1 if x > y

0 if x == y

● cmp(x, y) provides the default comparison function for sort()

cmp(x, y) >>> cmp(1, 2)

-1

>>> cmp(2, 1)

1

>>> cmp(1, 1)

0

>>> cmp('a', 'b')

-1

>>> cmp('b', 'a')

1

Customizing sort()

● It is possible to customize sort()

● Customization requires two steps:

Define a new comparison function that takes two ar-guments and returns three integers according to the cmp() convention

Pass the function object (just the function name with no parenthesis) to sort()

Example 01: Customizing sort()

● Define a comparator function:def neg_cmp(x, y):

return -cmp(x,y)

● Pass the comparator function to sort():

>>> z = [1, 2, 3, 4, 5]

>>> z.sort(neg_cmp)

>>> z

[5, 4, 3, 2, 1]

Loops

C/C++ while vs. Python while● Common C/C++ idiom:

while ((x = next()) != NULL) {

// Some code

}

● Python while loops may not have assignments in the test statements:

x = next()

while x:

## some code

x = next()

Python while Example

## print numbers from 1 upto 100

x = 1

while x <= 100:

print x

x += 1

Problem

Write a Python script that asks the user for his/her name until the user actually enters a string

Coding Solution 1

### keep asking for name until the user types

### something; not '' evaluates to True

name = ''

while not name:

name = raw_input('Please enter your name: ')

print 'Hello, %s!' % name

Coding Solution 2

### keep asking for name until the user types

### something that does not consist only of white ### spaces; not '' evaluates to True

name=''

while not name.strip():

name=raw_input('Please enter your name: ')

print 'Hello, %s!' % name

for Loops● Syntax

for targetList in IterableObject:

code block● IterableObject is (usually) a sequence and

returns its elements one at a time in order● targetList is one or more comma separated

reference names

for Loop Example## prints (1, 2) and (3, 4) on separate

## lines

for x in ((1, 2), (3, 4)):

print x

## prints 1 2 and 3 4 on separate lines

for x,y in ((1, 2), (3, 4)):

print x, y

Loop Else● Both for loops and while loops have an extended form not usually seen in

other languages

while expression:

code block

else:

code block

for targetList in IterableObject:

code block

else:

code block

Using Loop Else

● The else block of a loop is run if the loop exits normally● Use of continue allows the loop to exit normally● If the loop exits because of a break, the else block is

not run

Builtin Functions Useful in Loops

range([start,] stop [, step])

range()● range() generates a list with values of an arithmetic progression● Syntax pattern 1: range(stop)

>>> range(5) ## start defaults to 0, step defaults to 1

[0, 1, 2, 3, 4]

>>> range(10) ## start defaults to 0, step defaults to 1

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range()● range() generates a list with values of an arithmetic progression● Syntax pattern 2: range(start,stop )

>>> range(5, 10) ## step defaults to 1

[5, 6, 7, 8, 9]

>>> range(10, 20) ## step defaults to 1

[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

range()● range() generates a list with values of an arithmetic progression● Syntax pattern 3: range(start,stop,step)

>>> range(1, 11, 2) ## odd numbers in [1, 10]

[1, 3, 5, 7, 9]

>>> range(9, -1, -2) ## odd numbers in [1, 10] from

## largest to smallest[9, 7, 5, 3, 1]

>>> range(10, 0, -2) ## even numbers from 10 down to 1

[10, 8, 6, 4, 2] ## note 0 is not included but 10 is

xrange()● range() creates the entire list that contains each element of the

arithmetic progression● If the range is too large, this requires a large amount of memory● xrange() is an alternative to range() for dealing large ranges● xrange() uses the same arguments as range() but returns an it-

erable object that supports lazy iteration: generates each element in the range one at a time

● Bottom line: size of xrange() object is independent of the size of the range

xrange()

>>> rng = xrange(10, 1000000)

>>> for x in rng:

if x > 999998:

print x999999

Parallel Iteration

● If you want to iterate over two sequences at the same time

names=['a','b','c','d']

ages=[12,15,25,17]● To print the names with corresponding ages

for i in range(len(names)):

print names[i], 'is', ages[i], 'years old.'

zip(seq1 [, seq2 [...]] )

Zip>>> names=['a','b','c','d']

>>> ages=[12,15,25,17]

>>> zip(names,ages)

[('a', 12), ('b', 15), ('c', 25), ('d', 17)]

>>> for name,age in zip(names,ages):

print name, 'is', age, 'years old'

zip()● zip() combines one or more sequences into a list of tu-

ples where the n-th element of each tuple is the n-th ele-ment in the n-th sequence>>> zip([1, 2], [3, 4])

[(1, 3), (2, 4)]

>>> zip([1, 2])

[(1,), (2,)]

>>> zip('ab', [3, 4])

[('a', 3), ('b', 4)]

zip()● The length of the list returned by zip() is the length of the

shortest sequence>>> zip([1, 2], [3, 4, 5])

[(1, 3), (2, 4)]

>>> zip('abc', [3, 4])

[('a', 3), ('b', 4)]

zip()

● zip() can handle ranges>>> zip(xrange(1, 10), xrange(11, 20))

[(1, 11), (2, 12), (3, 13), (4, 14), (5, 15), (6, 16), (7, 17), (8, 18), (9, 19)]

>>> zip(range(1, 5), range(6, 10), range(11, 15))

[(1, 6, 11), (2, 7, 12), (3, 8, 13), (4, 9, 14)]

zip()

● zip() can be used in sequence unpacking>>> x, y = [zip(range(1, 5), range(6, 10)), zip(range(-5, 0), range(-10, -5))]

>>> x

[(1, 6), (2, 7), (3, 8), (4, 9)]

>>> y

[(-5, -10), (-4, -9), (-3, -8), (-2, -7), (-1, -6)]

enumerate(iterable [, start])

enumerate()● enumerate() returns an enumeration object

● Enumeration objects support the next() method that returns the tuple (i, j) where i is the number of element j in the enumeration object>>> en01 = enumerate(['a', 'b'])

>>> en01.next()

(0, 'a')

>>> en01.next()

(1, 'b')

>>> en01.next() ## error

Dictionaries

Dictionary● Dictionary is a set of key-value pairs● Dictionaries are mutable● Dictionary is the only type built-in mapping data

structure● The keys are not ordered

Basic Syntax● Dictionary is defined by { }

emptyDict = {} ## defines empty dictionary

● A key-value pair is defined as key colon valuedict = {'one' : 1}

● Multiple key-value pairs are separated by commasdict = {'one' : 1, 'two' : 2, 'three' : 3}

Keys and Values

● Keys can be any immutable objects: numbers, characters, tuples, and strings

● Lists and dictionaries cannot be keys● Values can be any objects● Dictionaries can be nested, i.e., there can be a

dictionary within another dictionary

Examplebox = {'size' : {'height' : 10,

'width' : 20},

'isCardboard' : True,

'color' : 'red',

'contents' : ['nail',

'hammer',

'screw']}

Access>>> box['size'] # must retrieve on key that exists

{'width': 20, 'height': 10}

>>> box['size']['width']

20

>>> box['contents']

['nail', 'hammer', 'screw']

>>> box['contents'][-1]

'screw'

Access>>> box.hasKey('size')

True

>>> box.items() # do it only on small dictionaries

[('color', 'red'), ('isCardboard', True), ('contents', ['nail', 'hammer', 'screw']), ('size', {'width': 20, 'height': 10})]

>>> box.items()[0]

('color', 'red')

>>> box.items()[0][-1]

'red'

Adding Key-Value Pairs● You can add new key value pairs to the previously

created dictionarymy_dict = {}

for c in 'abcdefg':

my_dict[c.upper()] = c

>>> my_dict

{'A': 'a', 'C': 'c', 'B': 'b', 'E': 'e', 'D': 'd', 'G': 'g', 'F': 'f'}

>>> my_dict[(1, 2)] = [1, 2]

>>> my_dict[(1, 2)]

[1, 2]

Construction● The constructor dict() can be used to create dictionaries from a

sequence of two-item sequences>>> my_dict2 = dict([['A', 'a'], ['B', 'b'], ['C', 'c']])

>>> my_dict2

{'A': 'a', 'C': 'c', 'B': 'b'}

>>> my_dict3 = dict([('A', 'a'), ('B', 'b'), ('C', 'c')])

>>> my_dict3

{'A': 'a', 'C': 'c', 'B': 'b'}

>>> my_dict4 = dict((('A', 'a'), ('B', 'b'), ('C', 'c')))

>>> my_dict4

{'A': 'a', 'C': 'c', 'B': 'b'}

Construction● The constructor dict() can be used to create

dictionaries from keyword-value pairs● The keyword-value pair has the following syntax:

keyword = value

● Keywords are converted into strings>>> my_dict5 = dict(first_name = "John", last_name = "Nicholson")

>>> my_dict5

{'first_name': 'John', 'last_name': 'Nicholson'}

Checking for Keys● Option 1: key in dictionary

>>> my_dict = dict(first_name = "John", last_name = "Nicholson")

>>> "first_name" in my_dict

True

>>> "middle_name" not in my_dict

True

● Option 2: dictionary.has_key(<key>)

>>> my_dict.has_key('first_name')

True

Safe Access with get()● dict.get() is similar to use dict[] but safer● Syntax: dict.get(key[, default])

● dict[key] returns the value of key in dict or throws error if key is not in dict

● dict.get(key) returns value of key in dict or None if key is not in dict

● dict.get(key, default) returns value of key in dict or default if key is not in dict

Example

>>> my_dict = {'one' : 1, 'two' : ['a', 'b', 'c']}

>>> my_dict['one']

1

>>> my_dict['three'] ## error

>>> my_dict.get('three') ## None (nothing) returned

>>> my_dict.get('three', 'not in dict')

'not in dict' ## default 'not in dict' returned

Clearing Dictionaries>>> my_dict = { }

>>> my_dict['one'] = [1, 2, 3]

>>> my_dict['two'] = ['a', 'b', 'c']

>>> my_dict

{'two': ['a', 'b', 'c'], 'one': [1, 2, 3]}

>>> my_dict.clear()

>>> my_dict

{ }

Shallow Copying● The method copy() returns a shallow copy of the dictionary

my_dict = {'one' : 1, 'two' : ['a', 'b', 'c']}

my_dict2 = my_dict.copy()

print 'shallow copying:', my_dict, my_dict2

del my_dict2['two'][-1]

print 'shallow copying:', my_dict, my_dict2

Output:

shallow copying: {'two': ['a', 'b', 'c'], 'one': 1} {'two': ['a', 'b', 'c'], 'one': 1}

shallow copying: {'two': ['a', 'b'], 'one': 1} {'two': ['a', 'b'], 'one': 1}

Deep Copying● The method deepcopy() returns a deep copy of the dictionary

from copy import deepcopy

my_dict3 = {'one' : 1, 'two' : ['a', 'b', 'c']}

my_dict4 = deepcopy(my_dict3)

print 'deep copying:', my_dict3, my_dict4

del my_dict4['two'][-1]

print 'deep copying:', my_dict3, my_dict4

Output:

deep copying: {'two': ['a', 'b', 'c'], 'one': 1} {'two': ['a', 'b', 'c'], 'one': 1}

deep copying: {'two': ['a', 'b', 'c'], 'one': 1} {'two': ['a', 'b'], 'one': 1}

Dictionary Creation From Keys● The method fromkeys() creates a dictionary from keys each of

which maps to None

>>> d = {}.fromkeys(['key1', 'key2'])

>>> d

{'key2': None, 'key1': None}

>>> d['key1'] = 'value1'

>>> d['key2'] = 'value2'

>>> d

{'key2': 'value2', 'key1': 'value1'}

Deleting Keys with del()

● You can use del() to delete key-value pairs from dictionaries>>> my_dict

{0: 0, 1: 1, 2: 4, 3: 9}

>>> del my_dict[2]

>>> my_dict

{0: 0, 1: 1, 3: 9}

Reading & References● www.python.org● Ch 03 (Strings), M. L. Hetland. Beginning Python From

Novice to Professional, 2nd Ed., APRESS● Ch 05 (Object Comparison, Loops), M. L. Hetland. Begin-

ning Python From Novice to Professional, 2nd Ed., APRESS