Scope: Local and Global Variables

A Value Before the Function

When you call a function, the information inside the parentheses can be a literal value, a variable, or an expression. User-defined functions accept these forms just as built-in functions do. The key timing rule is simple: Python evaluates each argument exactly once before it calls the function.

The Evaluation Sequence

An expression is a combination of values, operators, and function calls that Python can evaluate to produce a result. When an expression is used as an argument, the expression does not reach the function. Python computes its result first, and the function receives only that result. The computation occurs once during argument evaluation, even if the function later uses the received value more than once.

Tracing an Expression Argument

The important distinction is between producing the argument and using the argument. The expression produces one string before print_twice begins. The function then uses the already-produced string twice. This distinction helps you predict both the received value and the amount of evaluation work.

Tracing a Variable Argument

A variable holds a value. When a variable is passed as an argument, Python looks up the value stored in that variable and passes the value to the function. The variable name itself is not passed. The receiving parameter therefore gets the stored value rather than the original variable name.

A Function Call with math.cos

The argument can itself contain a function call. In math.cos(math.pi), the complete argument is an expression. Python evaluates that expression once before calling print_twice. The result is -1.0, so print_twice receives -1.0. Although print_twice prints the received value twice, math.cos is called only once during argument evaluation.

Mistakes in Evaluation Tracing

• Treating an expression as though it is passed unchanged.

  Python evaluates an expression before the function is called.

  Fix: Write down the expression's result first, then trace that value into the parameter.

• Assuming an argument expression is evaluated once for every use inside the function.

  The expression is evaluated exactly once before the call. The function receives the resulting value.

  Fix: Separate the one-time argument evaluation from the later uses of the received value.

• Thinking the variable name is passed to the function.

  Python retrieves the value stored in michael and passes that value.

  Fix: Replace the variable reference with the value it stores when tracing the call.

• Debugging only the function body when the received value is unexpected.

  The unexpected value may have arisen during argument preparation before the function began.

  Fix: Trace the argument first, then inspect how the function uses the value.

Debugging with a Four-Step Trace

1. Identify whether the argument is a variable or an expression.
2. If it is an expression, compute its result once. If it is a variable, identify the value stored in it.
3. Record the value that reaches the function parameter.
4. Only then trace what the function does with that received value.

This trace separates two possible sources of an unexpected result: preparing the argument and using the received value. If the value is already wrong before the function begins, inspect the expression or variable. If the value is correct at the parameter but the outcome is wrong, inspect the function's use of that value.

Practice the Call Trace

Key Takeaways

1. User-defined functions can receive literals, variables, and expressions as arguments.
2. Python evaluates an argument exactly once before calling the function.
3. An expression contributes its result, not the unevaluated expression itself.
4. A variable argument contributes the value stored in the variable, not the variable name.
5. Tracing argument preparation before tracing the function body helps locate unexpected behavior.