Answer to Question #276455 in Python for kika

Question

"Debugging" lists three possibilities to consider if a function is not working.

• Describe each possibility in your own words.
• Define "precondition" and "postcondition" as part of your description.
• Create your own example of each possibility in Python code. List the code for each example, along with sample output from trying to run it.

Answer 1

If a function is not working, there are three possibilities to consider:

• There is something wrong with the arguments the function is getting; a precondition is violated. 

SOLUTION - To rule out the first possibility, you can add a print statement at the beginning of the function and display the values of the parameters (and maybe their types). Or you can write code that checks the preconditions explicitly.

• There is something wrong with the function; a postcondition is violated. 

SOLUTION- If the parameters look good, add a print statement before each return statement that displays the return value. If possible, check the result by hand. Consider calling the function with values that make it easy to check the result 

• There is something wrong with the return value or the way it is being used.

SOLUTION- If the function seems to be working, look at the function call to make sure the return value is being used correctly (or used at all!).

PRECONDITION AND POSTCONDITION:

A precondition is a predicate that should hold upon entry into a function. It expresses a function's expectation on its arguments and/or the state of objects that may be used by the function.

 

A postcondition is a predicate that should hold upon exit from a function. It expresses the conditions that a function should ensure for the return value and/or the state of objects that may be used by the function.

 

Adding print statements at the beginning and end of a function can help make the flow of execution more visible. For example, here is a version of factorial with print statements:

def factorial(n):
    space = ' ' * (4 * n)
    print(space, 'factorial', n)
    if n == 0:
        print(space, 'returning 1')
        return 1
    else:
        recurse = factorial(n-1)
        result = n * recurse
        print(space, 'returning', result)
        return result

print(factorial(7))

Adding print statements at the beginning and end of a function can help make the flow of execution more visible. For example, here is a version of factorial with print statements.

test.py
                             factorial 7
                         factorial 6
                     factorial 5
                 factorial 4
             factorial 3
         factorial 2
     factorial 1
 factorial 0
 returning 1
     returning 1
         returning 2
             returning 6
                 returning 24
                     returning 120
                         returning 720
                             returning 5040
5040


Process ​finished with exit code 

Space is a string of space characters that controls the indentation of the output.

If You are confused about the flow of execution, this kind of output can be helpful. It takes some time to develop effective scaffolding*, but a little bit of scaffolding can save a lot of debugging.

Scaffolding, as used in computing, refers to one of two techniques: The first is a code generation technique related to database access in some model view controller frameworsk;

the second is a project generation technique supported by various tools.