Function Arguments, Return Values, and Scope

Select a timestamp to watch that moment on YouTube.

1. 00:00

   This function calculates the right number inside its body, but the next line still crashes. The price is twenty and the tax rate in this first example is twenty percent, so we expect a total of twenty-four. Why can Python calculate that value and then say it cannot find total? The answer is in the boundary between a function and its caller. In this lesson we will follow an argument into a parameter, watch a local variable being created, and return a value back to the caller. We will also use a default argument so a common rate can be omitted and a special rate can be supplied explicitly. The browser lesson includes worked examples, a checked coding task, and a quiz.

2. 00:43

   Here I want you to watch each real terminal run and ask what value the call itself produces. A visible printout and a returned value are different things. A parameter is the name in the function definition; an argument is the value you supply at the call site. Following one argument into a parameter is a useful way to understand where the calculation gets its input. The traceback ends with NameError because total has not been defined in the caller's scope. It was assigned inside total_with_tax, where it is a local name. The call passes twenty to the parameter price, then the function evaluates twenty times one point two and stores twenty-four in its local total.

3. 01:26

   After the function body ends, the call has no explicit return statement, so its value is None. The later print does not look inside the finished call; it searches for a name called total where that print statement is running. There is no such name there. This error is useful evidence because it tells us which name Python could not resolve, and the highlighted line tells us where the lookup happened. We should not try to repair it by adding a global variable. The function already has the value. It needs to hand that value back to its caller. The calculation inside the function did happen before the error. The crash is on the later print of total, after the call has finished.

4. 02:09

   That timing tells us to inspect what value crossed back from the function to the caller. Let us name the pieces precisely. The twenty in total_with_tax called with twenty is an argument: a value supplied by the caller. The word price in the definition is a parameter: a local name that receives that argument for this call. The assignment to total also creates a local name. None of these names automatically becomes a variable in the caller. Return is the route out. A function call is an expression, and a return statement decides the value of that expression. If we write print inside the function instead, the user may see twenty-four on the screen while the call still evaluates to None.

5. 02:54

   Save that call in a variable and you would save None, not the printed number. Calculation functions are easier to reuse when they return data and let the outer program decide whether to print, format, or store it. The repair is one extra statement at the end of the function body. Without an explicit return, a Python function returns None. You can print the call itself to confirm that observation, then remove that temporary diagnostic. It separates the computed local value from the value the caller actually receives. Now the local total is returned. The call expression evaluates to twenty-four point zero, and the outer print displays that returned number.

6. 03:38

   We never need to reference the local name from outside. This design also lets us call the same function with a different price. Each call receives its own local price and total. The second call does not overwrite a variable inside a previous call that the caller is meant to reach. If the caller wants to keep a result, it can assign result equals total_with_tax called with twenty. That result is in the caller's scope, so it can be printed or used in another calculation later. The lesson's practical task begins with the calculation already stored in total. You add a return of round total to two decimal places.

7. 04:18

   Do not put a print in place of return: the task checker calls your function with several values and needs the actual numeric answer. A return statement ends that execution path and hands a value back to the call expression. Printing inside the function would display the total, but it would not make the total available for another calculation in the caller. A default parameter gives the caller a shorter form for a common case. In the first call we pass only the price, so rate takes its default value of zero point two and the result is twenty-four point zero. In the second call we pass zero as the rate, overriding the default for that call, so the result is twenty.

8. 05:01

   In ordinary code I would often write rate equals zero at the call site to make the second argument's meaning obvious. Defaults should be chosen deliberately; real tax rates depend on context, so this is a focused function exercise, not a complete tax model. Before you finish, predict a call with a price of nineteen point ninety-nine and a ten percent rate. The rounded result should be twenty-one point ninety-nine. Try it in the browser console and press Check task. The checker also tests zero rate and a different price, which catches a solution that only prints the sample answer. Complete the quiz, then explain to yourself why print(total) failed even though the function had computed a total.

9. 05:46

   If you can trace that boundary, many function bugs become much easier to diagnose. Try passing a price of zero and then a rate of zero. Ask what each call should return before running it. Defaults make common calls shorter, while an explicit override documents an unusual rate at the call site.