CS 1112: Fall 2020

Class 23 — Monday October 21

Form with function

The task before us — Turn the abstract to concrete – Functions are at hand

Being functional — Is your mantra from now on — Embrace to your core

To be, not to be — That is the question I ask – The answer, to be

Look both ways

Back or ahead

Agenda

Start function-based chrestomathics

Druthers

What built-in functions are missing; that is, how can Python can be modified to make it easier to problem solve?

Downloads

olio.py

use_olio.py

To do

Look over artifacts

Look at Hands on Python

Look at function epistle

GUI for photo manipulation homework screen grab

Changing our modus operandi

Up to this point when we were confronted with a problem, our contribution was a single program file.

In the future our contribution will often involve multiple files.

One file will still be a program.

The other file(s) will be modules that define functions in support of the program task. We already have lots of functional experience with built-in functions and standard module functions.

While module is the Python term for a file of related functions definitions, programmers also use the terms library, programming toolbox, and API (application programmer interface).

In programming documentation, it is common practice to always include a pair of parentheses when referencing a function. The parentheses clue the reader that a function is being discussed. For example a string has a function lower() that returns a new copy of its string with all characters converted to lowercase.

Why have functions

Complex problem solving requires that we break a problem down into tasks that when put together, solve the problem. If the component tasks are also complex, the breaking down process can be repeated to determine the sub-tasks needed for solving the major tasks.

This form of problem solving is called top-down design; there is also bottom-up design and object-oriented design. Object-oriented design is the focus of the second course in digital problem solving at UVA.

In digital problem solving, the component tasks are written as independent units of code. For clarity, code units are named so that there is no ambiguity as to what unit is being considered. In Python we call a named unit of code, a function.

We use functions to provide an easier, clearer, and often a reusable way for the manipulation and calculation of values. In designing a function we need to

Determine what information is needed upon startup;

Determine what information is to be produced; and

Provide an algorithm for going from one to the other.

Using functions

Knowledge of what the function does and needs in order to be correctly used is paramount; i.e., carefully examine its documentation.

If the function is not built-in, program access to the library (module) defining the function needs to be gotten by importing. A module name must be an identifier.

import module_name

To make use of a function it needs to be invoked. A module-defined function invocation has form

module_name . function_name ( arguments )

The module_name is the name of the .py file containing the definition of function function_name(). A function name must be an identifier.

Operator . is the selection operator. It indicates that a component of the indicated module is to be accessed.

The function_name is the name of the function being invoked.

The ( arguments ) are a list of values that are passed to the function so that it can carry out its task.

Flow of control

When a function is invoked, Python passes control over to the function and it is now its code that is running. When the function completes, control is passed back to the code that contained the invocation, and its code now continues being executed.

Implementing functions

In digital problem solving, the component tasks are written as independent units of code. For clarity, code units are named so that there is no ambiguity as to what unit is being considered. In Python we call a named unit of code, a function. The name of function must be an identifier.

We use functions to provide an easier, clearer, and often reusable way for the manipulation and calculation of values. In designing a function we need to determine

What information is needed to be given to the function upon startup;

The information is called the parameter list. A parameter is a variable. Parameters are automatically initialized using information passed to it upon function startup.

What information it is to produce.

A function typically produces a value that is returned to the code that invoked it. Python provides the return statement for this purpose.

return function_result

Provide an algorithm for going from one to the other.

The algorithm is written as code. The code is known as a statement block or as the body of the function.

Function definition syntax and terminology

A typical Python function definition looks like the following

def function_name( parameters ) :
''' header_comment '''
action

The keyword def signals that a function is being defined.

The function_name is an identifier that names the task.

The ( parameters ) are a list of variable names (identifiers). The values of the parameters are the values needed by the function upon start up. The function_name along with the parameters form the function header.

The colon ( : ) is a separator of the function header from the function statement block.

Although optional, the literal string ''' header-comment ''' is normally the first line following the function header. The header-comment is a documentation string or as it commonly abbreviated docstring. The header-comment docstring describes the operation of the function. A Python installation comes with tools (e.g., Sphinx) for automatically generating online documentation from a program's triple-quoted strings. Comments intended for online documentation are written as docstrings.

The action is the block of statements to be executed when the function is called upon. The statements can include a return statement(s) that specifies the value to be associated with the function's usage. BTW, return is a keyword.

Function invocation syntax and terminology

The starting up of a function is called an invocation. A non-built-in function invocation has form

module_name . function_name ( arguments )

The module_name is the name of the .py file containing the definition of function function_name(). Like function_name, a module_name must be an identifier.

Operator . is the selection operator. It indicates that a component of the indicated module is to be accessed.

The function_name is the name of the function being invoked.

The ( arguments ) are a list of values that are passed to the function so that it can carry out its task.

The following code snippet from wc.py gets the contents of a user-specified web site by invoking function url.get_text(). In programming documentation, it is common practice to include a pair of parentheses when referencing a function. The parentheses clue the reader that a function is being discussed.

import url
reply = input( 'Enter web file: ' )
link = reply.strip()
text = url.get_text( link )

Observe that the program begins with an import statement. Just as standard Python modules must be imported for program usage, so too must local modules.

Preferences can be set where Python looks for local modules. By default, Python always searches for a module in the same folder as the program making the invocation.

The ability to reuse functions within a program and across programs is a major part of what make modules so attractive.

Function invocation semantics — what happens under the hood

When Python encounters a function invocation, it performs preparatory work before starting up the invoked function.

Python first checks that the number of invocation arguments, matches the number of parameters specificed in the function definition. If the counts match, the arguments are evaluated; that is, their values are determined.

Python then sets aside some computer memory for carrying out the function. In progamming speak (parlance), that memory is called an activation record or a frame.

The activation record stores values of the parameter variables. The parameter variables are initialized with the argument values. If a function needs other variables to perform its task, those variables are also stored there.

Once the parameters of an invoked fuction are initialized, the flow of control is given to the function — its actions are carried out. After the function completes, the flow of control is handed back to the invoking code where it picks up the running of its code at the point of the invocation.

If a return statement is encountered during the execution of a function, the value of the expression (if any) following keyword return is determined. The value of the return_expression is the value of the function invocation. That is, when a function invocation is encountered during program execution, the invocation is evaluated. The evaluation value is the value from the return statement.

All invoked Python functions return a value. If there is no explicit return value supplied, a Python function invocation returns None. As you should recall, keyword None indicates no value is available.

The following code snippet

s = "Cole's law: marinate shredded cabbage in vinaigrette."
x = print( s )
print( x )

indicates even the print() function returns a return. The snippet output is

Cole's law: marinate shredded cabbage in vinaigrette.
None

Taxonomy

The two main kinds of functions are:

Functions that have parameters and return values

Functions that have parameters and have None as a return value

There can also be:

Functions that do not have parameters, but do return values

Functions that do not have parameters and have None as a return value.

Staying within the law of scope

Parameters and other function variables are collectively called local variables. Local variables only exist during that invocation.

When a function completes, its activation record memory is released back to the system. That means referencing a local variable is not possible outside the function with the flow of control. We say that the scope of the local variables is limited to the function.

As an example, consider program test_locality.py that tries to access the local variable text from the definition of url module function get_text().

import url
page = url.get_text( 'http://www.cs.virginia.edu/~cs1112/' )
print( url.get_text.text )

The program terminates with a traceback indicating there is no text to reference. The restriction on local variable usage is symmetric — the invoking function cannot reference the local variables of the function doing the invocation.

Module `olio.py`

Function voting_age()

Does not take any parameters. Returns an integer indicating how old you need to be to vote. For example, the following code segment initializes both x and y to the integer 18.

x = olio.voting_age()
y = olio.voting_age()

Function has_blanks( s )

Has one parameter s. Returns whether s contains at least one blank character; i.e., returns True if s contains a blank, and returns False otherwise. For example, the following code segment initializes b1 and b2 to True and False respectively.

x = 'CS 1112'
y = 'the_aarvark_said_arf_arf'
b1 = olio.has_blanks( x )
b2 = olio.has_blanks( y )

Function great_seal()

Does not have any parameters and does not return a value. The function prints text from the Great Seal of the United States, i.e., E Pluribus Unum.

The code segment

olio.great_seal( )
print()
olio.great_seal( )
print()

produces as output

E Pluribus Unum

E Pluribus Unum

Function a_ing( n )

Has one parameter n. The function does not perform a return, instead it prints n lines of output. The first line prints a single 'a', the second line prints 'aa', the third line prints 'aaa', and so on. The string operator * should prove useful. For example usage, the code segment

olio.a_ing( 5 )
print()
olio.a_ing( 1 )
print()
olio.a_ing( 3 )

produces as output

a
aa
aaa
aaaa
aaaaa

a

a
aa
aaa

What's next

Look at Hands on Python

Two www.python.org resources should be examined now and also re-examined later.

The Python Tutorial includes a section on functions. I recommend before going there to thoroughly review the discussion presented here.

Python enhancement proposal 008 (PEP 008) includes recommended practices for naming modules, functions, and variables. The recommendations suggest that function and variable names are as a rule written in _snakecase; that is, lower-case words joined by underscores. Module names are expected to be short, lower-case, and no separation between words. I will add that function names are often action or verb phrases; e.g., input_integer().

Resources from previous semesters are available.

Class 23 — Monday October 21

Form with function

Look both ways

Agenda

Druthers

Downloads

To do

Changing our modus operandi

Why have functions

Using functions

Flow of control

Implementing functions

Function definition syntax and terminology

Function invocation syntax and terminology

Function invocation semantics — what happens under the hood

Taxonomy

Staying within the law of scope

Module `olio.py`

Function `voting_age()`

Function `has_blanks( s )`

Function `great_seal()`

Function `a_ing( n )`

What's next

Class 23 — Monday October 21

Form with function

Look both ways

Agenda

Druthers

Downloads

To do

Changing our modus operandi

Why have functions

Using functions

Flow of control

Implementing functions

Function definition syntax and terminology

Function invocation syntax and terminology

Function invocation semantics — what happens under the hood

Taxonomy

Staying within the law of scope

Module olio.py

Function voting_age()

Function has_blanks( s )

Function great_seal()

Function a_ing( n )

What's next

Module `olio.py`

Function `voting_age()`

Function `has_blanks( s )`

Function `great_seal()`

Function `a_ing( n )`