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

Dict Temperatures Warmup

Say for our building we have a "temps" dict with a key for each room - 'room1', 'room2', etc. The value for each room is a nested dict of the sensors in the at room 't1', 't2, with the value being the temperature.

>>> d = {'room1': {'t1': 100, 't2': 102}}

Temps Question

Question: Write an expression to compute the average temperature of average temp of t1 and t2 in room1?

The code d['room1'] is a reference to the nested dict. So can add ['t1'] to its right, like this:

>>> # Set values this way
>>> d['room1']['t1'] = 100
>>>
>>> # Compute average
>>> (d['room1']['t1'] + d['room1']['t2']) / 2
101.0

Can store a reference to the nested dict in a var, then use that. We typically do it this way.

>>> # Get a reference to room1 dict, store in var
>>> temps = d['room1']
>>> (temps['t1'] + temps['t2']) / 2
101.0
>>>

Tuples

For more detail see guide Python 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 not do this in CS106A code, but you can write it if you like and it is allowed under PEP8. We will write our code more spelled-out, showing explicitly where have a tuple.

>>> t = 1, 4     # This works
>>> t
(1, 4)
>>> t = (4, 5)   # We 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)

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')]

Note: Sorting With Tuples

• Sorting of tuples
• 1. Sorts on tuple[0] first across all tuples
• 2. If tuple[0] is the same between two elements
  Fall back to sorting on tuple[1] and so on
• Lets us combine multiple data items for sorting
• Say we have city tuples of the form (State, City)
• Try sorting these tuples

>>> cities = (('tx', 'houston'), ('ca', 'palo alto'), ('ca', 'san jose'), ('tx', 'austin'), ('ca', 'aardvark'))
>>> 
>>> sorted(cities)
[('ca', 'aardvark'), ('ca', 'palo alto'), ('ca', 'san jose'), ('tx', 'austin'), ('tx', 'houston')]
>>> 
>>> sorted(cities, reverse=True)
[('tx', 'houston'), ('tx', 'austin'), ('ca', 'san jose'), ('ca', 'palo alto'), ('ca', 'aardvark')]

So with d.items() - sorts by key first, which works perfectly for us. The keys are all unique, so it never looks at the value.

Dict .items() Output Code

• Slightly easier output
• Use sorted(dict.items() instead of dict.keys()
  Get (key, value) len-2 tuples
• Items has all the data in one step - nice
• item[0] is key, item[1] is value - ok

>>> 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 it this way, a little nicer:

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

• You do not need to use this form, it's just a shortcut
• 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 only time I use this shortcut is with d.items()

Dict .items() Shortcut Output

• You can use this if you like
• Use dict.items() instead of dict.keys()
• Adding the "unpack" shortcut to get key, value

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

Map/Lambda - Advanced Hacker Features

Map - a short way to transform a list - handy, but not super important

Lambda - an important way to package some code. Use with map() for today.

Lambda - Dense and Powerful

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!

Code One-Liner

There is something satisfying about solving a real problem with 1 line of code. The 1-liner code is so dense, we'll will write it a little more deliberately. See how this works below!

What is a def?

Consider the following "double" def. What does this provide to the rest of the program?

def double n:
    return n * 2

The def sets up the name of the function, and associates it with that body of code. Later line can refer to this function by name. The drawing below shows a form of this - the name "double" now points to this black-box of code that anybody can call.

Call Double - int in, int out

>>> # Normally don't def a function in the interpreter.
>>> # But it works for little demos like this.
>>>
>>> def double(n):
...   return n * 2
... 
>>> 
>>> double(10)
20
>>> double(144)
288

1. map(fn, iterable)

• map(function-reference, iterable)
• map() takes in a reference to a function by name
  For CS106A we'll use a function of 1 parameter here
• map() takes in any iterable, list-like linear collection
• What map() does is pretty simple
• 1. map() loops over the input list, calling the function once for each element
• 2. Map() gathers the function-call-results into a new list which is returned
• e.g. below, map() runs the "double" function over a list of numbers
• The thing that map() returns is not a list exactly and does not display neatly
• Therefore we call it like this in the interpreter
  list(map(...)) to make a list of the map() result so it prints out correctly

>>> # We have a "double" def
>>> def double(n):
...   return n * 2
... 
>>>
>>> list(map(double, [1, 2, 3, 4, 5]))
[2, 4, 6, 8, 10]
>>> 

Other examples

>>> list(map(double, [3, -1, 10]))
[6, -2, 20]
>>> 
>>> list(map(double, range(20)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38]
>>> 

map() Example 2 - exclaim()

Say we have an exclaim(s) function that takes in a string and returns it uppercase with an exclamation mark at the end. Use map to run exclaim() over a list of strings.

>>> def exclaim(s):
...   return s.upper() + '!'
... 
>>>
>>> list(map(exclaim, ['hi', 'woot', 'donut']))
['HI!', 'WOOT!', 'DONUT!']
>>> 
>>> list(map(exclaim, ['meh']))
['MEH!']

Lambda Promise

• In the examples above
• 1. Do the def in place, define the name + code we want to use
• 2. Then later in the code, map() refers to that name and maps the code over the list
• If the code is short, it would be nice to do the whole thing in one place
• Read on!
• Bafflement to Powerful transition

Lambda 1-2-3

• "lambda" is a stripped-down syntax to define computation in 1 line
• lambda has just the minimum needed
• Below is a lambda which defines code to double a number
• Syntax:
• 1. The word "lambda"
• 2. A single parameter and colon
• 3. An expression defining the output of the lambda
• All of today's lambdas will have 1 parameter
  Possible to have different numbers, but 1 is very common
• Lambda is great where you want a tiny function

Here is a lambda that takes in a number, returns double that number

lambda n: 2 * n

Lambda Black Box

It's like the lambda just defines the black box code, not bothering with giving it name.

Lambda works with map()

Want to double a bunch of numbers? Instead of a separate def, write the lambda inside the map() like this:

>>> list(map(lambda n: n * 2, [1, 2, 3, 4, 5]))
[2, 4, 6, 8, 10]

How To Write Lambda

• 1. Type in "lambda" - not too bad so far!
• 2. What is the input?
  Give the lambda param a good name
  Do not skip this step!
  A an int - "n"
  A string - "s"
  A mass in kilograms - "m" or "kg"
  Helps you write the expr correctly
• 3. Write the expression for the output
  Fit on one line, use the param
  No "return"
  If the code is long .. consider using a "def" see below

Lambda Examples in Interpreter

Do these in interpreter >>>. Just hit the up-arrow to change the body of the lambda.

>>> nums = [1, 2, 3, 4]
>>> 
>>> # n * 10
>>> list(map(lambda n: n * 10, nums))
[10, 20, 30, 40]
>>>
>>> # n * -1
>>> list(map(lambda n: n * -1, nums))
[-1, -2, -3, -4]
>>> 
>>> # 100 - n
>>> list(map(lambda n: 100 - n, nums))
[99, 98, 97, 96]
>>>
>>>

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.

Look at the "lambda" exercises on the experimental server

> lambda1 exercises

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']
>>> 
>>> # Works with strings - change param name to "s"
>>> list(map(lambda s: s.upper() + '!', ['hi', 'ho', 'meh']))
['HI!', 'HO!', 'MEH!']
>>>

Map Lambda str

Demo: first_2x().