1 / 45

EECS 110: Lec 5: List Comprehensions

Understanding list comprehensions, conditionals, recursion, and their applications in functional programming using Python. Explore power and vowels calculation functions. Learn how to compose functions to solve problems efficiently.

rgauthier
Download Presentation

EECS 110: Lec 5: List Comprehensions

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. EECS 110: Lec 5: List Comprehensions Aleksandar Kuzmanovic Northwestern University http://cs.northwestern.edu/~akuzma/classes/EECS110-s10/

  2. EECS 110 today data, sequences The building blocks of functional computing conditionals recursion List Comprehensions map and applications Homework 2 - this coming Sunday…! 1 lab problem Tuesday 3 problems Homework 1 - submitted 2 python problems

  3. "Quiz" on recursion Names: def power(b,p): def sajak(s): """ returns b to the p power using recursion, not ** inputs: ints b and p output: a float """ """ returns the number of vowels in the input string, s """ sajak('wheel of fortune') == 6 power(5,2) == 25.0 Want more power? Handle negative values of p, as well. For example,power(5,-1) == 0.2(or so)

  4. def power(b,p): """ inputs: base b and power p (an int) implements: b**p = b*b**(p-1) """ if p == 0: return if p > 0: return else: # p < 0 return

  5. def power(b,p): """ inputs: base b and power p (an int) implements: b**p = b*b**(p-1) """ if p == 0: return 1 if p > 0: return else: # p < 0 return

  6. def power(b,p): """ inputs: base b and power p (an int) implements: b**p = b*b**(p-1) """ if p == 0: return 1 if p > 0: return b*power(b,p-1) else: # p < 0 return

  7. def power(b,p): """ inputs: base b and power p (an int) implements: b**p = b*b**(p-1) """ if p == 0: return 1 if p > 0: return b*power(b,p-1) else: # p < 0 return 1/power(b,-1*p)

  8. behind the curtain power(2,3)

  9. def sajak(s): when there are no letters, there are ZERO vowels Base case? Look at the initial character. if it is NOT a vowel, the answer is Rec. step? if it IS a vowel, the answer is

  10. def sajak(s): when there are no letters, there are ZERO vowels Base case? Look at the initial character. if it is NOT a vowel, the answer is just the number of vowels in the rest ofs Rec. step? if it IS a vowel, the answer is 1 + the number of vowels in the rest ofs

  11. def sajak(s): if len(s) == 0: return 0 else: Base Case Checking for a vowel: Try #1

  12. def sajak(s): if len(s) == 0: return 0 else: Base Case Checking for a vowel: Try #1 and same as in English! but each side has to be a complete boolean value! or not

  13. def sajak(s): if len(s) == 0: return 0 else: Base Case if s[0] == 'a' or s[0] == 'e' or… Checking for a vowel: Try #1 and same as in English! but each side has to be a complete boolean value! or not

  14. def sajak(s): if len(s) == 0: return 0 else: Base Case in Checking for a vowel: Try #2

  15. def sajak(s): if len(s) == 0: return 0 else: if s[0] not in 'aeiou': return sajak(s[1:]) else: return 1+sajak(s[1:]) Base Case Rec. Step if it is NOT a vowel, the answer is just the number of vowels in the rest ofs if it IS a vowel, the answer is 1 + the number of vowels in the rest ofs

  16. behind the curtain sajak('eerier')

  17. The key to understanding recursion is to first understand recursion… - advice from a student

  18. functional programming >>> 'fun' in 'functional' True • representation via list structures (data) • leverage self-similarity (recursion) • create small building blocks (functions) Compose these together to solve or investigate problems. Key ideas in functional programming not maximally efficient for the computer… elegant and concise vs.

  19. return to recursion Composing functions into specific applications Creating general functions that will be useful everywhere (or almost…)

  20. return to recursion Composing functions into specific applications Creating general functions that will be useful everywhere (or almost…) building blocks with which to compose…

  21. sum, range defsum(L): """ input: a list of numbers, L output: L's sum """

  22. sum, range defsum(L): """ input: a list of numbers, L output: L's sum """ if len(L) == 0: return 0.0 else: return L[0] + sum(L[1:]) Base Case This input to the recursive call must be "smaller" somehow… if the input has no elements, its sum is zero Recursive Case if L does have an element, add that element's value to the sum of the REST of the list…

  23. sum, range defrange(low,hi): """ input: two ints, low and hi output: int list from low up to hi """ excluding hi

  24. sum, range defrange(low,hi): """ input: two ints, low and hi output: int list from low up to hi """ ifhi <= low: return [] else: return excluding hi

  25. sum, range defrange(low,hi): """ input: two ints, low and hi output: int list from low up to hi """ ifhi <= low: return [] else: return [low] + range(low+1,hi) excluding hi

  26. sum and range >>> sum(range(101)) Looks sort of scruffy for a 7-year old… ! and 100 more…

  27. Recursion: Good News/Bad News Recursion is common (fundamental) in functional programming defdblList(L): """ Doubles all the values in a list. input: L, a list of numbers """ if L == []: return L else: return [L[0]*2] + dblList(L[1:]) But you can sometimes hide it away!

  28. Map: The recursion "alternative" def dbl(x): return 2*x >>> map( dbl, [0,1,2,3,4,5] ) [0, 2, 4, 6, 8, 10] def sq(x): return x**2 >>> map( sq, range(6) ) [0, 1, 4, 9, 16, 25] (1) map always returns a list (2) map(f,L) calls f on each item in L def isana(x): returnx=='a’ >>> map( isana, 'go away!' ) [0, 0, 0, 1, 0, 1, 0, 0] Hey… this looks a bit False to me!

  29. Map ! defdblList(L): """ Doubles all the values in a list. input: L, a list of numbers """ if L == []: return L else: return [L[0]*2] + dblList(L[1:]) Without map def dbl(x): return x*2 defdblList(L): """ Doubles all the values in a list. input: L, a list of numbers """ return map(dbl, L) With map!

  30. Map: a higher-order function In Python, functions can take other functions as input… def map( f, L ): KeyConcept Functions ARE data!

  31. Why use map?

  32. Why use map? More elegant / shorter code, “functional in style” Faster execution in Python – map optimized for operations in lists Avoid rewriting list recursion (build once, use lots)

  33. Mapping without map: List Comprehensions Anything you want to happen to each element of a list name that takes on the value of each element in turn the list (or string) any name is OK! >>> [ dbl(x) for x in [0,1,2,3,4,5] ] [0, 2, 4, 6, 8, 10] input output input >>> [ x**2 for x in range(6) ] [0, 1, 4, 9, 16, 25] output >>> [ c == 'a'for c in 'go away!' ] [0, 0, 0, 1, 0, 1, 0, 0] input output

  34. Mapping without map: List Comprehensions def dbl(x): return 2*x >>> map( dbl, [0,1,2,3,4,5] ) [0, 2, 4, 6, 8, 10] >>> [ dbl(x) for x in [0,1,2,3,4,5] ] [0, 2, 4, 6, 8, 10] def sq(x): return x**2 >>> map( sq, range(6) ) [0, 1, 4, 9, 16, 25] >>>[ x**2 for x in range(6) ] [0, 1, 4, 9, 16, 25] >>> map( isana, 'go away!' ) [0, 0, 0, 1, 0, 1, 0, 0] def isana(x): returnx=='a’ >>> [ c == 'a'for c in 'go away!' ] [0, 0, 0, 1, 0, 1, 0, 0]

  35. List Comprehensions def len(L): if L == []: return 0 else: return 1 + len(L[1:]) len(L) def sajak(s): if len(s) == 0: return 0 else: if s[0] not in 'aeiou': return sajak(s[1:]) else: return 1+sajak(s[1:]) sajak(s) def sScore(s): if len(s) == 0: return 0 else: return letScore(s[0]) + \ sScore(s[1:]) sScore(s) scrabble score implemented via raw recursion

  36. List Comprehensions len(L) LC =[1 for x in L] return sum( LC )

  37. List Comprehensions len(L) LC =[1 for x in L] return sum( LC ) sajak(s) # of vowels LC = [c in 'aeiou' for c in s] return sum( LC )

  38. List Comprehensions len(L) LC =[1 for x in L] return sum( LC ) sajak(s) # of vowels LC = [c in 'aeiou' for c in s] return sum( LC ) sScore(s) scrabble score LC =[ letScore(c) for c in s] return sum( LC )

  39. Quiz Write each of these functions concisely using list comprehensions… Name(s): Write input: e, any element L, any list or string Remember True == 1 and False == 0 output: the # of times L contains e def count(e,L): example: count('f', 'fluff') == 3 W are the winning numbers Write input: Y and W, two lists of lottery numbers (ints) Y are your numbers def lotto(Y,W): output: the # of matches between Y & W example: lotto([5,7,42,44],[3,5,7,44]) == 3 Extra! Write input: N, an int >= 2 output: the number of positive divisors of N def divs(N): example: divs(12) == 6 (1,2,3,4,6,12)

  40. Quiz

  41. Quiz count(e,L) LC =[x==e for x in L] return sum( LC )

  42. Quiz lotto(Y,W) LC = [c in Y for c in W] return sum( LC )

  43. Quiz divs(N) LC =[ N%c==0 for c in range(1,N+1)] return sum( LC )

  44. Quiz count(e,L) LC =[x==e for x in L] return sum( LC ) lotto(Y,W) LC = [c in Y for c in W] return sum( LC ) divs(N) LC =[ N%c==0 for c in range(1,N+1)] return sum( LC )

  45. See you at Lab!

More Related