def mean(num1, num2):
	return (num1 + num2)/2

• The number of arguments for that function are indicated, and their types are identified.

• The return value is described in terms of the argument(s).

• The spec uses arg1 and arg2 to refer to the individual arguments for that function.

• The type of the return value is also indicated.

    mean(5, 8) --> 6.5

    def invite(namelist):
        for name in namelist:
            print("Hi,", name, "-- please come to my party!")
        return    

    invite(['Bob', 'Carol', 'Ted', 'Alice'])
    Hi, Bob -- please come to my party!
    Hi, Carol -- please come to my party!
    Hi, Ted -- please come to my party!
    Hi, Alice -- please come to my party!

• A state change is an effect of a function other than a return value. Input and output (as in invite()) are examples of state changes.

• Write out your function definition on a piece of paper as correctly as possible -- so correct, if possible, that someone else who didn't know Python3 could type it in exactly and produce a correct Python3 computation. If you are uncertain about anything as you write, look it up.

• Then, enter your work in idle3, and verify that it runs correctly

    x = 7

An accumulator is a variable that is used to build up an answer over time. For example, consider the following modified code for invite()

    def invite(namelist):
        count = 0
	# invar: count holds the number of invitations printed so far
        for name in namelist:
            print("Hi,", name, "-- please come to my party!")
            count = count + 1
        return count

    invite(['Bob', 'Carol', 'Ted', 'Alice']) --> 4
    Hi, Bob -- please come to my party!
    Hi, Carol -- please come to my party!
    Hi, Ted -- please come to my party!
    Hi, Alice -- please come to my party!

This function definition prints the same four invitations as the original definition of invite(), but this definition returns 4 -- the number of invitations printed -- instead of returning no value. This new definition satisfies the following modified spec.

Here's a description of how this function uses a variable count to compute the desired return value.

1. Just after the assignment count = 0, the memory location count holds the value 0:
   

2. Just after the first invitation has been printed (for 'Bob'), count holds the value 1.
   
   Note: the expression

   count = count + 1

   would be nonsense if it were Mathematics, but in computing, it (a) computes the value of count+1, then (b) assigns that value to count. In terms of problem solving strategies, this is the expression that updates the accumulator.

3. Just after the second invitation has been printed (for 'Carol', the accumulator variable count is updated to hold 2.
   

4. After the third invitation has been printed, count holds 3. Notice how the invariant remains true at the beginning and end of each repetition: it always holds the number of invititations printed at those points in the computation.
   

5. After printing the fourth invitation (for 'Alice'), count holds 4.
   

Finally, when there are no more names to print, the for loop ends, and Python3 proceeds to execute the next statement after that loop (namely, the return statement). At the end of the loop, we know from the logic behind the invariant that count holds the number of invitations that were printed. That's the return value demanded by the spec, so we return the value count.

DO THIS: Write Python3 function definitions for each of the following specs, using accumulator variables within those definitions to compute the desired return values. As before, write out precise and correct code for each of these [HC] problems on paper first, then test each on the computer. (It's ideal to write out an answer to one problem, then test that code using Python3, then write out an answer to the next problem, etc., so that any errors you catch on one problem can be avoided in the next.)