Today: function call, grayscale, boolean precedence, list functions, midterm next week

Function Call - Parameters in Detail

How do function call parameters work? It's often intuitive, so you don't have to think about it too much. BUT when pushed, you need to know how it works to avoid getting tripped up.

1. The variables and parameters in each function are independent, sealed off from those in other functions. An "x" in one function is independent of an "x" in some other function.

2. Function call: parameter values come in by position within the ( .. ) (not by name or anything else)

Function Call Example

Say we have a "foo" function with 2 parameters, and it is called by a "caller" function later. What does the run of caller() below print? This is very detail oriented, but mercifully there's just a few lines.

def foo(x, y):
    x = x - y
    return x + 1


def caller():
    x = 2
    y = 3
    z = foo(y, x)
    print(x, y, z)

Solution

printed line:
2 3 2

Values passed in to foo(x, y) are 3 and 2, value returned is 1
The "x" within foo() is independent of the "x" in caller()

Grayscale

• This comes up in a small way in HW5
• RGB colors - 16 million different colors
  More details next week
• What makes a color "grayscale", lacking hue
  Like in a black-and-white photo?
• Q: What is gray in RGB?
• A: when red == green and green == blue
• e.g. 220 220 220
• e.g. 50 50 50
• e.g. 0 0 0
• Try it in rgb-explorer
• Later we'll build an algorithm to convert color image to grayscale

Recall: Floating Point Numbers

• "float" number type
• More in future lecture
• Look like 3.14
• HW5 has floating point numbers in a list
• Simple, all these work: + - * /
• Math with float values produces more float values
• Why is int math a separate idea?
• Indexing is int-only
• float does not make sense, say, with [ ]

>>> # + - * / with float works, yielding floats
>>> # more in future
>>> 3.14 * 2
6.28
>>> 
>>> # int math - indexing with [ ]
>>> s = 'Hello'
>>> len(s) - 4
1
>>> s[1]
'e'
>>> 
>>> # indexing is fundamentally *int* only
>>> s[1.0]   
TypeError: string indices must be integers

Boolean Operators

• Arithmetic operators: + - * /
• Combine numbers to make a number
  1 + 2 * 3 -> 7
• Boolean operators: and or not
• Combine Boolean values to make a Boolean
  True or False -> True
True and False -> False
True and Not False -> True

Boolean Precedence

• More details see: Python Booleans
• Boolean operators: and or not
• Mixture of these, can add parenthesis to force order of operation
• Say have three boolean variables, each True/False
  age - say age is good if less than 30
  raining - True if raining
  weekend- True if it's the weekend
• Define: to be a good day
  age under 30 or weekend and it must be not raining
  Intention is that not-raining is required for both under 30 and weekend cases

This does not work, but it's close

def good_day(age, weekend, raining):
    """age is int, weekend and raining are Boolean"""
    if age < 30 or weekend and not raining:
        print('good day')

• Precedence:
  not = highest
  and = next highest (like *)
  or = lowest (like +)
• Many programmers do not have this memorized . ok
• Remember that "not" is the highest
• Solution: note that you have a mixture, put in parenthesis
  We will never complain about parenthesis, so just put the in to force the order you want

Solution

def good_day(age, weekend, raining):
    """age is int, weekend and raining are Boolean"""
    if (age < 30 or weekend) and not raining:
        print('good day')

One More Problem from the Parse-Words series

4.parse_words99: Like parse_words(), but with an extra way for a word to extend. Given a string s, parse out and return all "words", where a word is made of 1 or more adjacent alphabetic chars. Except, digits are allowed within a word after the first char, so 'ab12 6 a34a' returns ['ab12', 'a34b'].

Solution

def parse_words99(s):
    search = 0
    words = []
    while True:
        begin = search
        while begin < len(s) and not s[begin].isalpha():
            begin += 1
        
        if begin >= len(s):
            break
        
        # Your code here, find end of word
        end = begin + 1
        # Skip over both alpha/digit
        # Parenthesis added to force and/or order
        while end < len(s) and (s[end].isalpha() or s[end].isdigit()):
            end += 1
        
        word = s[begin:end]
        words.append(word)
        search = end + 1
    return words

More List Functions

More details see: Python Lists

List 1.0 Features

• Bread and butter list features
• Many programs just use these and nothing else
• lst = [1, 2, 3]
• lst.append(4) to add
• len(lst)
• lst[2] access
• in test
• foreach loop

>>> nums = []
>>> nums.append(1)
>>> nums.append(0)
>>> nums.append(6)
>>> 
>>> nums
[1, 0, 6]
>>> 
>>> 6 in nums
True
>>> 5 in nums
False
>>> 5 not in nums
True
>>> 
>>> nums[0]
1
>>> 
>>> for num in nums:
...   print(num)
... 
1
0
6

List Variable Naming - "s"

• Style: "s" on list variable name
• e.g. urls lines masses
• foreach variable matches up - nice
• for num in nums:
• Common bug - lose track of element vs. list
• Use variable names to keep yourself on track

lst.extend(lst2)

• Use extend() to build up a list with another list
• lst.extend(lst2) - an alternative to append()
  make lst longer with lst2 elements
  though append() is much more commonly used

>>> a = [1, 2, 3]
>>> b = [4, 5]
>>> a.append(b)
>>> # what is a now?
... 
>>> a
[1, 2, 3, [4, 5]]
>>>
>>> c = [1, 2, 3]
>>> d = [4, 5]
>>> c.extend(d)
>>> c
[1, 2, 3, 4, 5]

lst1 + lst2

• + works with list like string
• lst1 + lst2 - create bigger list of all their elements=
• + leaves the original lists unchanged

>>> a = [1, 2, 3]
>>> b = [9, 10]
>>> a + b
[1, 2, 3, 9, 10]
>>> a   # original is still there
[1, 2, 3]

Like extend(): lst1 += lst2

• lst1 += lst2- re-assigns lst1, often what you want
• Therefore: list += is basically the same as .extend()
• Detail: .extend() is a little faster, as it re-uses lst1 memory
  While += creates a new list and discards lst1
• What's most important is getting the right result before worrying about speed

>>> a = [1, 2, 3]
>>> b = [4, 5]
>>> a += b
>>> a
[1, 2, 3, 4, 5]

List Slices

• Slices work with lists, just as with strings
  Creates a new list
  Populated with elements from original list
• lst[:] copies the whole list

>>> lst = ['a', 'b', 'c']
>>> lst2 = lst[1:]   # slice without first elem
>>> lst2
['b', 'c']
>>> lst
['a', 'b', 'c']
>>> lst3 = lst[:]    # copy whole list
>>> lst3
['a', 'b', 'c']
>>> # can prove lst3 is a copy, modify lst
>>> lst[0] = 'xxx'
>>> lst
['xxx', 'b', 'c']
>>> lst3
['a', 'b', 'c']

List pop([optional index])

• Building up a list is very common - append
• How to pull elements out of a list, shrinking it?
• lst.pop() - by default returns the last value from list
  And also removes it from the list
• Mnemonic: opposite of append()
• pop(index) - takes an optional index number
• Pops off that element instead of the end one
• pop(0) pops the first element
• List keeps elements contiguous, shifting elements

>>> lst = ['a', 'b', 'c']
['a', 'b', 'c']
>>> lst.pop()   # opposite of append
'c'
>>> lst
['a', 'b']
>>> lst.pop(0)  # can specify index
'a'
>>> lst
['b']

Midterm - Fri Nov 1, at regular class time. Talk about next week. What to know now:

Midterm is closed-note, writing functions. The functions look a lot like functions from homework/section/lecture - be able to do those. Re-visit things you have solved before, maybe with help. Practice to be able to solve them cold. We give partial credit and do not grade on syntax.

See also: Midterm Prep