Upcoming SlideShare
×

Python lecture 05

356 views

Published on

Published in: Education
1 Like
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

Views
Total views
356
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
6
0
Likes
1
Embeds 0
No embeds

No notes for slide

Python lecture 05

1. 1. Python & Perl Lecture 06 Department of Computer Science Utah State University
2. 2. Recap ● ● ● ● ● Types in Python Built-in Sequences List: Python's Workhorse Function parameters Scoping
3. 3. Outline ● Object Comparison ● Loops ● Dictionaries
4. 4. Object Comparison
5. 5. Object Comparison ● ● The operators <, >, ==, >=, <=, and != compare the values of two objects The objects need not have the same type
6. 6. 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
7. 7. cmp(x, y) ● cmp(x, y) is a built-in function ● cmp(x, y) returns  if x < y  1 if x > y  ● -1 0 if x == y cmp(x, y) provides the default comparison function for sort()
8. 8. cmp(x, y) >>> cmp(1, 2) -1 >>> cmp(2, 1) 1 >>> cmp(1, 1) 0 >>> cmp('a', 'b') -1 >>> cmp('b', 'a') 1
9. 9. Customizing sort() ● It is possible to customize sort() ● Customization requires two steps:  Define a new comparison function that takes two arguments and returns three integers according to the cmp() convention  Pass the function object (just the function name with no parenthesis) to sort()
10. 10. 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]
11. 11. Loops
12. 12. 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()
13. 13. Python while Example ## print numbers from 1 upto 100 x = 1 while x <= 100: print x x += 1
14. 14. Problem Write a Python script that asks the user for his/her name until the user actually enters a string
15. 15. 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
16. 16. 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
17. 17. 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
18. 18. 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
19. 19. 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
20. 20. 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
21. 21. Builtin Functions Useful in Loops
22. 22. range([start,] stop [, step])
23. 23. 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]
24. 24. 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]
25. 25. 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) [10, 8, 6, 4, 2] ## even numbers from 10 down to 1 ## note 0 is not included but 10 is
26. 26. 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 iterable 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
27. 27. xrange() >>> rng = xrange(10, 1000000) >>> for x in rng: if x > 999998: print x 999999
28. 28. 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.'
29. 29. zip(seq1 [, seq2 [...]] )
30. 30. 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'
31. 31. zip() ● zip() combines one or more sequences into a list of tuples where the n-th element of each tuple is the n-th element 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)]
32. 32. 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)]
33. 33. 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)]
34. 34. 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)]
35. 35. enumerate(iterable [, start])
36. 36. 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
37. 37. Dictionaries
38. 38. 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
39. 39. Basic Syntax ● Dictionary is defined by { } emptyDict = {} ## defines empty dictionary ● A key-value pair is defined as key colon value dict = {'one' : 1} ● Multiple key-value pairs are separated by commas dict = {'one' : 1, 'two' : 2, 'three' : 3}
40. 40. 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
41. 41. Example box = {'size' : {'height' : 10, 'width' : 20}, 'isCardboard' : True, 'color' 'contents' : 'red', : ['nail', 'hammer', 'screw']}
42. 42. 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'
43. 43. 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'
44. 44. Adding Key-Value Pairs ● You can add new key value pairs to the previously created dictionary my_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]
45. 45. 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'}
46. 46. 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'}
47. 47. 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
48. 48. 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
49. 49. 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
50. 50. 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 {}
51. 51. 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}
52. 52. 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}
53. 53. 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'}
54. 54. 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}
55. 55. Reading & References ● ● ● www.python.org Ch 03 (Strings), M. L. Hetland. Beginning Python From nd Novice to Professional, 2 Ed., APRESS Ch 05 (Object Comparison, Loops), M. L. Hetland. Beginning Python From Novice to Professional, 2nd Ed., APRESS