Class 31 — Wednesday, April 6

Functionization

Social distancing — Does not mean we cannot share — Love, hopes, and friendship

---

Look both ways

• Back or ahead

---

Agenda

• "Why Functions?" Analogy

• Being functional

• Convert specifications dealing with strings into working functions

---

• Module quad.py

• Tester program riga.py

---

Post class

• Review musings.

• Try CodingBat.

• Complete Homework.

---

• We’ve been talking about how to implement functions in Python, but a question that may come to mind is "what is really the motivation behind learning functions?"

• Let’s talk about what a function is, to better establish why we need to use them

• A function is an algorithm. Well, that doesn’t help much, let’s go further.

• An algorithm is a series of steps that will be performed exactly according to a set of rules.

• We use algorithms everywhere-- for example, our own brains are full of “functions” in fact!

• We use functions to define commonly used algorithms.

• One library, or module of algorithms that our brains may use is a set of directions to perform different home-improvement tasks.

• An example of a function from the module is using a screw-driver.

• When a furniture assembly instruction set tells you to screw something in, they are invoking your screw-driver function.

• Let’s think about what steps that algorithm. First, we have to get a screwdriver of the right size. Once we have the proper screwdriver, we need to turn it right if we’re tightening or left if we’re loosening the screw. Let’s pseudocode this in the style of Python:

def screw( direction ) :

finding_screwdriver = True

while ( finding_screwdriver ) :

    try the next bit

    if ( the bit fits ) :

        finding_screwdriver = False

if ( direction = “left” ) :

    while ( screw still moves )

        continue rotating to the left until screw is out

else :

    while ( screw still moves )

        continue rotating to the right until screw is fully tightened

• Imagine if every time a direction set told you to screw in a bolt, they told you every step of this algorithm. That’s a world without functions. And this is a pretty simple example, too! Think about if every street sign had to re-teach you how to drive!

• Let’s say that one day, we discovered that there was an error in our screw function and we were trying to use a screw with an ill-fitting bit.

• If we didn’t have a function, we’d have to fix the problem everywhere that we used this algorithm.

• But since we use functions, we can just fix it in the one place that the function is defined.

---

Module quad.py

• Defines four functions for cleaning up lists of strings. Program riga.py performs simple testing of quad.py.

• Observation: none of the function implementations need nested for-loops.

• Requirement: none of the functions are allowed to modify their parameters.

• Recommendtion: review string and list documentation

---

Suppose the following definitions are in effect below

test1 = ['AbCdE', 'ABCDE', '!"#\'x$&)|}~', '- x -_', 'AAcc', ' ', 'x\n']

test2 = ['\tx X']

test3 = []

test4 = ['a', 'B', 'r', 'A', 'c', 'a', 'D', 'a', 'B', 'r', 'a']

---

Function to_lower( strings )

• Parameter strings is a list of strings.

• Returns a new list whose elements are lower case versions of those in strings.

• Given the above definitions of test1, test2, test3, and test4, the following is the expected invocation results for to_lower().

to_lower( test1 ) = ['abcde', 'abcde', '!"#\'x$&)|}~', '- x -_', 'aacc', ' ', 'x\n']

to_lower( test2 ) = ['\tx x']

to_lower( test3 ) = []

to_lower( test4 ) = ['a', 'b', 'r', 'a', 'c', 'a', 'd', 'a', 'b', 'r', 'a']

• Observation: an accumulator is needed. Lower-case versions of elements of strings need to be added to the accumulator one-at-a-time.

---

Function cleanup( strings )

• Parameter strings is a list of strings.

• Returns a new list whose elements correspond to the elements in strings with leading and trailing extraneous characters (punctuation or whitespace) removed.

• The following constants are defined for the function

PUNCTUATION = '''!"#$%&'()*+,-./:;<=>?@[]^_`{|}~'''

WHITE_SPACE = ' \t\n\r\v\f'

EXTRANEOUS = PUNCTUATION + WHITE_SPACE

• Given the above definitions of test1, test2, test3, and test4, the following is the expected invocation results for cleanup().

cleanup( test1 ) = ['AbCdE', 'ABCDE', 'x', 'x', 'AAcc', '', 'x']

cleanup( test2 ) = ['x X']

cleanup( test3 ) = []

cleanup( test4 ) = ['a', 'B', 'r', 'A', 'c', 'a', 'D', 'a', 'B', 'r', 'a']

• Observation: Same as the previous function, an accumulator is needed. Stripped versions of elements of strings need to be added to the accumulator one-at-a-time.

---

Function unique( strings )

• Parameter strings is a list of strings.

• Returns a new version of strings without any duplicate values.

• Given the above definitions of test1, test2, test3, and test4, the following is the expected invocation results for unique().

unique( test1 ) = ['AbCdE', 'ABCDE', '!"#\'x$&)|}~', '- x -_', 'AAcc', ' ', 'x\n']

unique( test2 ) = ['\tx X']

unique( test3 ) = []

unique( test4 ) = ['a', 'B', 'r', 'A', 'c', 'D']

• Observation: an accumulator is needed. The elements of strings need to be added to the accumulator one-at-a-time if they are not already there.

---

Function canonical( strings )

• Parameter strings is a list of strings.

• Returns a new list cleaned up lower case version of strings without duplicates. It should be obvious that making use of functions cleanup(), to_lower(), and unique() should be helpful.

• To ensure that you do make use of functions cleanup(), to_lower(), and unique() should be helpful, no loops are allowed in canonical() code.

• Because functions to_lower() and cleanup() both have the potential for returns lists with duplicates, function canonical() needs to make use of unique() after using to_lower() and cleanup().

• Given the above definitions of test1, test2, test3, and test4, the following is the expected invocation results for canonical().

canonical( test1 ) = ['abcde', 'x', 'aacc', '']

canonical( test2 ) = ['x x']

canonical( test3 ) = []

canonical( test4 ) = ['a', 'b', 'r', 'c', 'd']

---

Module quad.py musings

• Functions to_lower() and cleanup() seem similar.

• Both functions want to return a new list, where there will be a separate entry for each string in their string list parameter strings.

• The new lists must be accummulated.

• For each string in strings, a conversion is produced and the conversion is added to the accummulator.

• In WWAHD speak

Create a new empty list

For each string in strings do

— Get a converted version of the string

— Add conversion to the new list

Hand back completed new list

• Function unique() has similarities to functions to_lower() and cleanup().

• Needs to build and return a new list.

• The new list needs to be accumulated.

• Needs to consider each string in the string list parameter strings for the accumulation.

• However, it does not need to do a conversion. Instead, it needs to individually check each string in strings whether to add it to the accumulator.

• In WWAHD speak

Create a new empty list

For each string in strings do

— Test whether string needs to be added the new list. If so, add string to new list

Hand back completed new list

• The job of function canonical() is to produce a cleaned up, lowercase version of strings with no duplicates. It should be obvious that making use of functions cleanup(), to_lower(), and unique() should be helpful.

• Use one of three functions to start the conversion process.

• Pass its result to a second of the functions.

• Pass that result to the third function to produce the desired canonical result.

Because both cleanup() and to_lower() have the potential to return duplicates, unique() needs to be the third function. It is up you to determine whether one of the other two needs to be first.

---

 

---

🦆 © 2022 Jim Cohoon

Resources from previous semesters are available.