Week 4 Lesson 3 FINAL

Main ideas and lessons (about advanced functions)

1) How a function call executes (control flow + environment)

Execution model

• Code normally runs top-down (linear execution).
• When a function is called, control flow changes:
  • An imaginary execution pointer “jumps” to the start of the function definition.
  • The function runs, then execution resumes back at the call site.

What happens when calling a function (step-by-step)

1. Evaluate arguments
   • Compute the values of the expressions passed as arguments.
   • Convert argument values to a canonical (fully reduced) form if needed
     • Example: 2 + 2 must be reduced to 4.
2. Create a new variable table (local scope)
   • A new scope/variable table is created for the function call.
   • The argument values are assigned to the function parameters as local variables.
3. Transfer control to the function body
   • Function body statements execute in order.
4. Stop when a return is encountered
   • A return statement does two major things:
     1. Stops function execution immediately.
     2. Produces a returned “package” (the value computed by return).
5. Determine the returned value
   • If return <expression> is used:
     • the expression after return is evaluated and returned.
   • If no explicit return is written:
     • an implicit return None occurs at the end of the function body.
   • If return is written with no expression:
     • it is assumed to return None.
6. Destroy the function’s local environment
   • The function’s local variable table is cleared/destroyed.
   • Local variables disappear permanently.
   • Any side effects (e.g., printing/displaying) may have changed the broader environment, but local computation results are not kept unless returned.
7. Assign the returned value to where it’s used
   • The returned value becomes the result of the function call expression.
   • Example: A = f(...) means A receives the returned value.
   • Execution continues at the statement after the call.

2) Call graphs for tracking execution

Purpose

• A function call graph is like a stack/activation record diagram, but more detailed.
• It helps track:
  • which functions run
  • what values/arguments are passed
  • what return values are produced
  • variable tables and scopes (each function has its own scope)

How scoping affects variables

• Variables (e.g., it, x, y) exist only within their function’s scope.
• Even if two functions both use a variable named it, they are different variables because they belong to different scopes.

Example described: add_and_greet, add and greet, greet_user

• Main program
  • x = 39
  • y = add_and_greet(1 + 2, x)
• Inside add_and_greet
  • Parameters receive arguments (implicit assignment):
    • X gets 1 + 2 = 3
    • Y gets x = 39
  • Computes it = X + Y = 42
  • Calls greet_user() with no arguments
    • greet_user uses its own local it
    • Calls Python built-in print(...)
      • print displays something (environment change)
      • print returns None
    • No explicit return from greet_user → it ends with implicit return None
• Returning from add_and_greet
  • Even though greet_user returns None, add_and_greet still returns its own it value (42)
  • Main program’s y becomes 42

3) Capturing return values vs. “seeing output”

Key distinction

• You must capture returned values to use them later:
  • store in a variable: x = double(2)
  • or pass into another function: print(double(2))

Interactive vs script behavior (subtlety)

• In interactive runs:
  • values may appear on screen due to implicit display, but they may not be usable as values in the same way.
• In scripts:
  • returned values are not shown unless you explicitly print them.

4) Function composition (chaining)

• Functions can be nested, analogous to resolving parentheses.
• Example pattern:
  • print(double(2)) (double(2) is computed first, then passed to print)

5) print vs return (two separate concepts)

print

• Causes output to be displayed / changes the environment (screen/pixels/text).
• **Returns None** (the example emphasizes it isn’t useful as a computation value).

return

• Provides information back to the calling code.
• All functions have a return value:
  • if you don’t explicitly return, you get implicit return None.

6) Practice exercise concept (which function prints vs returns)

• Two functions both “double,” but one prints while the other returns.
• Intended reasoning:
  • the function containing print(...) produces screen output
  • the function without print produces no output, but still returns a value (explicitly or implicitly None, depending on its structure)
• Call graphs can show:
  • one function returns an unhelpful/meaningless value (often implicit None)
  • the other returns an explicit computed value (or vice versa)

---

Methodology / instructions presented (bullet format)

A) Drawing and using a call graph (method)

• Identify which parts run outside functions (the main script).
• For each function call:
  • Add a frame/node for the called function.
  • Record the arguments sent from the caller.
  • Map arguments to parameters inside the function frame (implicit assignment).
  • Track local variables in that frame’s scope only.
• When encountering another nested call inside a function:
  • Add another frame for the nested call.
  • Track its returned value (including None cases).
• When return is reached:
  • Record the value/package being returned.
  • Remove/ignore local variables after returning (scope ends).
• Finally:
  • Propagate the returned value back to where the call happened.

B) Using return values correctly (how to “use what a function returns”)

• To use a function’s result:
  • Store it: result = f(args)
  • Or pass it directly: print(f(args)) (composition)
• If you only call a function without capturing/using its return:
  • you can’t later use that value (unless you printed it or otherwise used it immediately).

---

Speakers / sources featured

• Primary speaker/instructor: The course lecturer (unnamed in subtitles), delivering “Week 4 Lesson 3 FINAL” lecture on functions.
• Software/library mentioned: Python built-in print (as a built-in function in the example).