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

Each Type has a Char

Ever notice how each new type has a char that marks it literal form in the code:

• string - quote ' .. '
• list - brackets [ .. ]
• dict - curly bracket { .. }
• tuple - parenthesis ( .. ) - today!

Tuples

For more detail see guide Python Tuples

• Written with parenthesis
  e.g. ('a', 13, 42)
  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, 42)
>>> t[0]
'a'
>>> t[1]
13
>>> t[2]
42
>>> len(t)
3
>>> t[0] = 'b'
TypeError: 'tuple' object does not support item assignment

When To Use Tuple? (vs. List)

• Use a tuple to group a few data items together
• The number of elements is small and known ahead of time
• Elements may not all be the same type
• e.g. Store sunet and id number together - tuple
  ('sally22', 123456)
• e.g. Store 3 float x,y,z coordinates all together - tuple
  (4, 5.2, 6.1)
• e.g. Store filename of an mp3 file and its length in seconds together - tuple
  ('happy.mp3', 240)

When To Use List?

• List contains many elements, possibly a large number
• Number of elements maybe not known ahead of time
• Want .append() to add more
• Typically elements are all the same type
  Same-type is not a Python requirement, but it's a good practice
• List Examples:
• Store many urls - list of strings
  ['http://foo.com', 'http://kitten.org/bleh', ...]
• Store many weights - list of floats
  [34.5, 12.0, 16, ...]
• Store many filenames - list of strings
  ['poem.txt', 'jokes.html', ... ]

Tuple Optional Parenthesis

It's possible to omit the parenthesis when writing a tuple. 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 when creating a tuple.

>>> t = 1, 4     # This works
>>> t
(1, 4)
>>> t = (4, 5)   # I prefer it spelled out like this
>>> t            # PEP8 says parenthesis optional
(4, 5)

Tuple Assignment = Shortcut

Here is a neat sort of trick you can do with a tuple. This is a shortcut for the use of =, assigning multiple variables in one step. This is just a little trick, not something you need to use.

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

• It's an error if the two sides are not the same len
• Works with lists too
• A bit obscure, you do not need to use this feature
• But handy sometimes (below)

Sorting With Tuples

• Sorting a list 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 len-2 tuples of the form: ('ca', 'palo alto')
• Try sorting these tuples
• First sorted by [0] - all 'ca' before all 'tx'
• Then sort by [1]
  'ca': ('ca', 'aardvark'), ('ca', 'palo alto'), ('ca', 'san jose')
'tx': ('tx', 'austin'), ('tx', 'houston')

>>> cities = [('tx', 'houston'), ('ca', 'san jose' ), ('ca', 'palo alto'), ('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')]
>>>

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. Today we'll use map() to explore how lambda works

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!

Dense One-Liner Code Solutions

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.

double() - How Many Params? How Many Outputs?

Answer: takes in one parameter value. Returns one value.

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

1. map(fn, list-like)

• map() takes in:
• 1. Takes in a reference to a function
• 2. Takes in any list-like collection
• Runs that function over the list
• Calling the passed-in function once for each element
• Gathers the outputs into a list-like which is returned

A visual of what map() does

map(double, [1, 2, 3, 4, 5]) -> [2, 4, 6, 8, 10]

Aside: map() Result + list()

• The result that map() returns is not a list exactly and does not display clearly in the interpreter
• Therefore we call it like this in the interpreter
• list(map(...))
• Thus making a list of the map() result so it prints out correctly
• This use of list() is not needed generally in production code, we're using it here so the demos print nicely in the interpreter

map() Examples

>>> # We have a "double" def
>>> def double(n):
...   return n * 2
... 
>>>
>>> map(double, [1, 2, 3, 4, 5])
<map object at 0x7f9a25969910>     # why we need list()
>>> 
>>> list(map(double, [1, 2, 3, 4, 5]))
[2, 4, 6, 8, 10]
>>> 
>>> 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!']

Thus Far - Ok

The map() function saves us some boilerplate - if we have a function, it takes care of the not too difficult job or running it over a list of inputs, giving us a list of outputs. This is a first example of passing a function in to another function as a parameter, which turns out to be an important advanced technique.

Enter the Lambda

Lambda Niche

• In the examples above
• 1. Do the def first, 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!
• Dense/Powerful code ahead!

Lambda History

• History: Alonzo Church 1930
  Lambda Calculus
• Church studied computation before computers were invented, used lambda as a notation
• Now lambda is a way to make 1-line function in Python
• Without a def
• Great for places where you need a little function
• Continue to use def for regular multi-line functions

Lambda 1-2-3

• "lambda" is a stripped-down syntax to define computation in 1 line
• lambda has the absolute 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, no "return"
• 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: n * 2

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, 2, 3

1. "lambda"

Write the word "lambda"

2. Param:

• What is the lambda input?
• Give the lambda param a good name, followed by colon
• A an int - "n:"
• A string - "s:"
• A mass in kilograms - "mass:" or "kg:"
• Having a good name helps with the next step

3. Expression

• 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]
>>>
>>>

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

Examples / Exercises - Map Lambda

These are true one-liner exercises. We'll do a few of them in class, and you can look at the others in the lambda1 section.

Solve these with a 1-line call to map() for each. Do not call list(), that was needed in the interpreter, but here just map() works.

> lambda1 exercises

For reference, here is the syntax for our "double" example:

map(lambda n: n * 2, [1, 2, 3, 4, 5])

Do these: squared(), diff21() (int)

> squared exercises

> diff21 exercises

Then strings: first2x(), first_up() (str)

> first2x exercises

> first_up exercises

Custom Sort - Power Feature

• Python sorting has a lot of power in it
• Use lambda to guide the sorting
• This code feels powerful and dense
• More examples in section!

Python Custom Sort - Food Examples

• Lamest food I could think of - Radish
• Suppose have list of foods
• Each food is a len-3 food tuple:
• food = (name, tasty 1-10, healthy 1-10)
• food[0] = its name
• food[1] = how tasty it is 1-10
• food[2] = how healthy it is 1-10

We'll try these food examples in the interpreter.

Default sorted()

By default sorted() works on list of tuples, compares [0] first, then [1], and so on

>>> foods = [('radish', 2, 8), ('donut', 10, 1), ('apple', 7, 9), ('broccoli', 6, 10)]
>>> 
>>> # By default, sorts food tuples by [0]
>>> sorted(foods)
[('apple', 7, 9), ('broccoli', 6, 10), ('donut', 10, 1), ('radish', 2, 8)]
>>> 

Sort By Tastiness

• Say I want to sort by tastiness
  e.g. the radish vs. donut dimension
• Control how sorted() looks a the data
• Like drawing a circle around tasty values - sort by these!
• How can we get the code to do this?

Project Out Sort-By Values

• How to code sort-by-tasty
• For each element in list
  "Project out" a sort-by value to be used in sorting comparisons
• Here, for each food, project out its tasty int
• aka "Proxy" strategy
  Each element, proxy value is used for sorting comparisons

Project Out With Lambda

• Q: how to project out these sort-by proxy values?
• A: lambda

Custom Sort Lambda - Plan

• 1. Call sorted() as usual
• 2. provide key=lambda to control sorting
• Lambda here takes one parameter - one elem from the list
• The lambda projects out the sort-by value to use for comparisons
• e.g. sort by tasty
  lambda food: food[1]
• e.g. sort by healthy
  lambda food: food[2]

Q: What is the parameter to the lambda?

A: One elem from the list (similar to map() function)

Sort By Tasty

>>> foods = [('radish', 2, 8), ('donut', 10, 1), ('apple', 7, 9), ('broccoli', 6, 10)]
>>> 
>>> sorted(foods, key=lambda food: food[1])
[('radish', 2, 8), ('broccoli', 6, 10), ('apple', 7, 9), ('donut', 10, 1)]

Sort Tasty First (reverse=True)

>>> sorted(foods, key=lambda food: food[1], reverse=True)  # most tasty
[('donut', 10, 1), ('apple', 7, 9), ('broccoli', 6, 10), ('radish', 2, 8)]

Sort Healthy First

>>> sorted(foods, key=lambda food: food[2], reverse=True)  # most healthy
[('broccoli', 6, 10), ('apple', 7, 9), ('radish', 2, 8), ('donut', 10, 1)]

Most tasty * healthy

We not limited to just projecting out existing values. We can project out a computed value. Here we compute tasty * healthy and sort on that. So apple is first, 7 * 9 = 63, broccoli is second with 6 * 10 = 60. Donut is last :(

>>> sorted(foods, key=lambda food: food[1] * food[2], reverse=True)
[('apple', 7, 9), ('broccoli', 6, 10), ('radish', 2, 8), ('donut', 10, 1)]
>>>

Sorted vs. Min Max

• What code give us the most tasty food?
  Or the least tasty?
• Sorting n things is kind of expensive
• Could sort, take the last item - overly expensive approach
• Use max(), max takes a key=lambda just like sorted()
• e.g. pull out most or least tasty food - change "sorted" to "max" or "min"

>>> foods = [('radish', 2, 8), ('donut', 10, 1), ('apple', 7, 9), ('broccoli', 6, 10)]
>>> max(foods)     # uses [0] by default - tragic!
('radish', 2, 8)
>>> 
>>> sorted(foods, key=lambda food: food[1])
[('radish', 2, 8), ('broccoli', 6, 10), ('apple', 7, 9), ('donut', 10, 1)]
>>> 
>>> max(foods, key=lambda food: food[1])  # most tasty
('donut', 10, 1)
>>> min(foods, key=lambda food: food[1])  # least tasty
('radish', 2, 8)

Key performance point: computing one max/min element is much faster than sorting all n elements.

Python Custom Sort String Examples

• Default sorted() uses "<"
• With strings, < places uppercase before lowercase, rarely what we want

>>> # The default sorting is not good with upper/lower case
>>> strs = ['coffee', 'Donut', 'Zebra', 'apple', 'Banana']
>>> sorted(strs)
['Banana', 'Donut', 'Zebra', 'apple', 'coffee']

String Sort Lambda

• Fix: project out lowercase version of string as sort-by
• The lambda takes in one elem from list - in this case 1 string
• e.g. lambda s: s.lower()
• Examples: sort not case-sensitive, sort by last char

>>> strs = ['coffee', 'Donut', 'Zebra', 'apple', 'Banana']
>>> 
>>> sorted(strs, key=lambda s: s.lower())    # not case sensitive
['apple', 'Banana', 'coffee', 'Donut', 'Zebra']
>>> 
>>> sorted(strs, key=lambda s: s[len(s)-1])  # by last char
['Zebra', 'Banana', 'coffee', 'apple', 'Donut']
>>> 

Movie Examples

Given a list of movie tuples, (name, score, date-score), e.g.

[('alien', 8, 1), ('titanic', 6, 9), ('parasite', 10, 6), ('caddyshack', 4, 5)]

sort_score(movies)

> sort_score()

Given a list of movie tuples, (name, score, date-score), where score is a rating 1-10, and date 1-10 is a rating as a "date" movie. Return a list sorted in increasing order by score.

sort_date(movies)

> sort_date()

Given a list of movie tuples, (name, score, date-score), where score is a rating 1-10, and date-score 1-10 is a rating as a "date" movie. Return the list sorted in decreasing by date score.

Optional Trick: Hand Craft Def with a Lambda

Just to show how Python works, you can actually make your own def using lambda and an equal sign. A def has code and a name. Here we use = to make the name fn point to the lambda code. Then we can call it like any other function.

>>> fn = lambda n: 2 * n
>>> 
>>> fn       # fn points to code
<function <lambda> at 0x7fb944ad0700>
>>>
>>>
>>>
>>> fn(10)   # function call works
20
>>> fn(12)
24
>>>

That is not something you need to do to get work done. That's a peak behind the curtain, showing what def is doing under the hood. Python is in a way very simple. A variable means that name has a pointer to that value. We see here that functions work the same way - a name pointing to a value which happens to be code.

Map With Type-Change

> lambda1 section

The output list does not need to have the same element type as the input list. The lambda can output any type it likes, and that will make the output list. See examples: super_tuple() and lens()

Example: lens(strs)

> lens()

lens(strs): Given a list of strings. return a list of their int lengths.

Solution

def lens(strs):
    return map(lambda s: len(s), strs)

Lambda - Code as a Parameter

Countless times, you have called a function and passed in some data for it to use. The function name is the verb, and the parameters are extra nouns to guide the computation:

e.g. "draw_line" is the verb, with these int coords

canvas.draw_line(0, 0, 100, 50, color='red')

With lambda, we open up a new category, passing in code as the parameter for the function to use, e.g. with map():

map(lambda s: s.upper() + '!',
    ['pass', 'code']) ->
 ['PASS!', 'CODE!']

Having an easy way to pass code between functions can be very handy.

Lambda vs. Def

Lambda and def are similar:

def double(n):
    return 2 * n

Equivalent lambda

lambda n: 2 * n

Use Lambda For Everything?

Should you just use lambda for everything? Not at all! Lambda is good for cases where the code is really short. Your program will have situations like that sometimes, and lambda is great for that. But def can do many things lambda cannot.

Def Features

• Not everything needs to be a lambda
• def introduces a name for the code
• Def has room for real code features:
• Multiple lines
• If statements
• Variables
• Loops
• Doctests
• Inline comments
• Lambda: best without any of that, just short, 1-line

Def vs. Lambda

• What to do if computation does not fit in 1 line?
• Just write a def
• map() can use the def

map/def Example - map_parens()

> map_parens()

In lambda1, see the map_parens() problem.

['xx(hi)xx', 'abc(there)xyz', 'fish'] ->
  ['hi', 'there', 'fish']

map_parens() Solution

Solution Code. map() works fine with "parens" by name

def parens(s):
    left = s.find('(')
    right = s.find(')', left)
    
    if left == -1 or right == -1:
        return s
    return s[left + 1:right]


def map_parens(strs):
    return map(parens, strs)