Today: whole-program vs. functions, tuples, dict.items() output pattern, lambda, map, one-liners

Whole Program - Dict Count

wordcount.zip

• Look at Word Count program
• Each function: black box model
• Each function - data in, data out
• e.g. read_counts()
  in: filename
  out: counts dict
• Look at the source code
• Trace from main() to read_counts() and back

Look at read_counts

• What memory picture does this build within the function
• Recall: each function has its own vars
• Q: What happens to memory from line: return counts
• A: pointer to counts passed back to main()
  Both functions have a pointer to the same dict
• "Shallow" - All of these spread references to the one dict, not a copy
  =
  -params into a function
  -return out of a function

Tuples

• For more details see guide Tuples
• Written with parenthesis
  e.g. (1, 2, 'a')
  e.g. ('Alex Smith', 12432255)
• Similar to list, len [ ] work the same
• Fixed size, typically small
• Sometimes have different types inside
• Immutable (no change, no append)

>>> t = ('a', 13)
>>> t[0]
'a'
>>> t[1]
13
>>> len(t)
2
>>> t[0] = 'b'
TypeError: 'tuple' object does not support item assignment

Unfortunate syntax shortcut: possible to omit the parenthesis. We will never do this in CS106A code. More readable to spell out in the code that it's a tuple.

>>> t = 1, 4     # This works
>>> t
(1, 4)
>>> t = (4, 5)   # Prefer readable/spelled out
>>> t
(4, 5)

Tuples vs. List

• Tuple and list are similar in some ways
• When to use them?
• List:
  unbound number of elements, possibly large number
  Want .append to add more
  all same type
• Tuple:
  small, fixed number of elems
  know number of elems ahead of time
  possibly different types
• Examples...
• Store many urls: list
• Store 3 float x,y,z coordinates all together: tuple
  e.g. (4, 5.2, 6.1)
• Store many pixels: list
• Store "name" str and "sunet" id str together: tuple
  e.g. ('sally', 123456)
• Store filename of an mp3 file and its length in seconds together: tuple
  e.g. ('happy.mp3', 240)

Tuples Assignment = Shortcut

Tuple assignment = shortcut. A way to assign multiple variables in one step.

>>> (x, y) = (3, 4)
>>> x
3
>>> y
4

• Error if the two are not the same len
• Works with lists too
• A bit obscure, but handy sometimes (below)

Sorting 1.0

• (Already done this level)
• Built in sorting
• sorted(lst)
• sorted(lst, reverse=True)
• Uses "<" on elements
• Works on ints
• Works on strs
• Do not mix types in one list

>>> lst = [12, 19, 2, 1]
>>> sorted(lst)
[1, 2, 12, 19]
>>> 
>>> sorted(lst, reverse=True)
[19, 12, 2, 1]
>>> 
>>> lst = ['apple', 'zebra', 'banana']
>>> sorted(lst)
['apple', 'banana', 'zebra']

Sorting 2.0 - With Tuples

• Sorting of tuples
• 1. Sorts on tuple[0] first across all tuples
• 2. If tuple[0] is ==, fall back to sorting on tuple[1] and so on
• Lets us combine multiple data items for sorting

>>> pairs = [('stanford.edu', '/meh'), ('google.com','/search'),
  ('stanford.edu', '/admit'), ('google.com', '/aardvark')]
>>> pairs
[('stanford.edu', '/meh'), ('google.com', '/search'), ('stanford.edu', '/admit'), ('google.com', '/aardvark')]
>>> sorted(pairs)
[('google.com', '/aardvark'), ('google.com', '/search'), ('stanford.edu', '/admit'), ('stanford.edu', '/meh')]

Revisit Dict, now that we have tuples

Dict Load Up

• Common dict pattern:
  1. Start with empty dict {}
  2. Loop through data, add in key/value pairs with in/[ ]
• Now dict if filled with key/value data

Dict Data Out Pattern #1

Say we have a dict loaded up with data

>>> d = {'a': 'alpha', 'g': 'gamma', 'b': 'beta'}

The following pattern we've done many times, it works fine. You can still use it.

>>> for key in sorted(d.keys()):
...     print(key, d[key])
... 
a alpha
b beta
g gamma

But there is a more direct way to do it.

Dict Data Out: keys() values() items()

• How to get data out of dict?
• 1. d.keys(), or sorted(d.keys())
• 2. d.values() - collection of just values (same order as keys())
• 3. d.items() - use this one today
  Items is collection of key/value pairs (each a tuple len-2)
  In this way, dumping out all the dict data (random order)
• sorted(d.items()) - sorts the pairs by key - useful form

>>> d = {'a': 'alpha', 'g': 'gamma', 'b': 'beta'}
>>>
>>> d.keys()
dict_keys(['a', 'g', 'b'])
>>> sorted(d.keys())
['a', 'b', 'g']
>>>
>>> d.values()
dict_values(['alpha', 'gamma', 'beta'])
>>> 
>>> d.items()          # still random order
dict_items([('a', 'alpha'), ('g', 'gamma'), ('b', 'beta')])
>>> 
>>> sorted(d.items())  # we'll use this form
[('a', 'alpha'), ('b', 'beta'), ('g', 'gamma')]

Aside: Dict Asymmetry - Do Not Look Up By Value

• Here we talk about keys and values, 2 vital dict ideas
• But lookup is key only
• Given key, dict can look up value very quickly
• Does not work the other way
• If we have value e.g. 'gamma'
  No way to look up which key goes with that
  Apart from brute-force . looping over all the values
• There is probably something wrong with your code if it has a value, and needs to look up the key for it

Dict Output Pattern #1.5

• Problem with d.keys() - "revisit" dict for each key
  Works, but not the most convenient
• Not quite the final pattern
• Use dict.items() instead of dict.keys()
  Get (key, value) len-2 tuples
• Items has all the data in one step - nice
• Use sorted(d.items())
• item[0] is key, item[1] is value - below is not that readable

>>> for item in sorted(d.items()):
...     print(item[0], item[1])
... 
a alpha
b beta
g gamma

Foreach "Unpack" Shortcut

d.items() is a list of tuples len-2. Instead of this:

for item in sorted(d.items()):
    print(item[0], item[1])

Can write this, much nicer:

for key, value in sorted(d.items()):
    print(key, value)

• Each len-2 item is "unpacked" into the key, value variables
• Similar to the (x, y) = (3, 4) trick above
• This is just a shortcut
• The one time I use this shortcut is with d.items()

Dict Output Pattern #2

• You can use this pattern or #1 above
• Use dict.items() instead of dict.keys()
• Use sorted(dict.items()) to put in order by key
• Use the "unpack" foreach shortcut to get key, value

>>> for key, value in sorted(d.items()):
...     print(key, value)
... 
a alpha
b beta
g gamma

Lambda - Dense and Powerful

Thought for today: Lambda code is dense. Another way of saying that it is powerful. Sometimes you feel powerful with computer code because the code you write is long. Sometimes you feel even a little more powerful, because the code you write is short!

Consider this def. It has a name + code. What does this give the program? A name associated with some code that can be called, returns a computed value.

def double n:
    return n * 2

Lambda - Big Picture

Within many programs, there are spots where you have a list of xxx and need a list of yyy computed from xxx. The lambda technique here is an amazingly compact way of expressing that part of your program.

Lambda

• "lambda" is a way to make 1-line function in Python
• Without a def
• Like a black box
• Nothing left to remove

e.g. a lambda function that takes in n, returns double its value. Has: 1 param, code, returns double value. Does not have: name, "return", multiple lines

lambda n: n * 2

e.g. a lambda that takes a string and returns its int length * 10.

lambda s: len(s) * 10

• Like a def, but
  no name
  one line of code, an expression
  no "return"
• All of today's lambdas will have 1 parameter
  Possible to have different numbers, but 1 is very common
• Lambda: parameters, a colon, an expression, no "return"
• Lambda is great where you want a tiny function

Lambda in Action - map(fn, iterable)

• map( -lambda-, -list-)
• lambda of 1 parameter (defs work too, but today lambdas)
• What map does:
  Calls lambda once for each element in list
  Gathers results into a list, which is returned
  n items in original list, lambda called n times, have n results
• "map" as a verb - map this function over these elements
• map() returns an "iterable" - like a list, but does not display
• Building a function to return a list, can return map() result directly, typically fine
• Examples below use list(map(...)) just so it displays

Lambda Doubling Example

Double number lambda:

lambda n: n * 2

• Double each num in a list with map/lambda
• Think about the lambda parameter - it's one element from the source list
• Wrap map() in list() so it prints right

>>> nums = [1, 2, 3, 4]
>>> map(lambda n: n * 2, nums)
<map object at 0x11012c390>
>>> list(map(lambda n: n * 2, nums))
[2, 4, 6, 8]

Lambda Num Examples

Do these in python3 interpreter >>> They're all 1 line long! (note: abs(n) is absolute value of n)

>>> nums = [1, 2, 3, 4]
>>> 
>>> list(map(lambda n: n * -1, nums))
[-1, -2, -3, -4]
>>> 
>>> list(map(lambda n: 100 - n, nums))
[99, 98, 97, 96]
>>>
>>> list(map(lambda n: abs(n - 3), nums))
[2, 1, 0, 1]
>>>

Examples / Exercises - Map Lambda int

Solve these with 1 line of code each. Do not call list(), that was just so the examples print in the interpreter.

> map lambda

Lambda String Examples

Have a list of strings. Map a lambda over this list. What is the parameter to the lambda? One string. Whatever the lambda returns, that's what makes up the list of results.

>>> strs = ['Banana', 'apple', 'Zebra', 'coffee', 'Donut']
>>> 
>>> list(map(lambda s: s.lower(), strs))
['banana', 'apple', 'zebra', 'coffee', 'donut']
>>> 
>>> list(map(lambda s: s[0], strs))
['B', 'a', 'Z', 'c', 'D']
>>> 

Map Lambda str

Demo: first_2x(). Students try the other 2.

Lambda / Def Interchange

The above examples all us lambda to express little functions. Just for completeness, the code of a def can be used instead of a lambda, like this:

>>> nums = [1, 2, 3, 4]
>>> def double(n):
...     return n * 2
... 
>>> list(map(double, nums))
[2, 4, 6, 8]

Where we would put a lambda, just put the name of the function. This is the rare case of referring to a function by name, but not putting () after it. The () calls the function, but here we want to identify the function by name but not call it.

If the code you want is several lines long, expressing it in a def is a better approach. Lambdas are great when the computation needed is short. For multi-line computations, use s a def.