What Calling a Procedure Does

A procedure (also called a function or a method) is a named group of programming instructions. Writing the procedure is one job; calling it is another. When you call a procedure, the program pauses where it is, jumps to the procedure, runs the statements inside it, and then returns control to the exact spot where the call happened. Execution continues from there. This topic is about using procedures that already exist. Writing your own is the next topic.

def greet(name):
    print("Hi " + name)

greet("Sam")
print("done")

PROCEDURE greet(name)
{
    DISPLAY("Hi " name)
}
greet("Sam")
DISPLAY("done")

Reading top to bottom: the def block only defines greet; nothing runs yet. The first line that actually executes is greet("Sam"), which jumps into the procedure, displays Hi Sam, and then hands control back so that print("done") runs next. Two lines are displayed, in order, because control always returns to the caller.

def f(a, b):
    return a - b
print(f(10, 4))

Arguments and Parameters: Matched by Order

When you call a procedure you may pass it values. Those values are the arguments. The names inside the procedure that receive them are the parameters. The connection between them is position: the first argument is copied into the first parameter, the second argument into the second parameter, and so on. The names do not have to match; only the order matters.

def power(base, exp):
    return base ** exp

x = power(2, 3)
print(x)

PROCEDURE power(base, exp)
{
    RETURN(base ^ exp)
}
x <- power(2, 3)
DISPLAY(x)

In power(2, 3) the argument 2 lands in the parameter base and 3 lands in exp, so the procedure returns 2 ** 3, which is 8. If you called power(3, 2) instead, you would get 3 ** 2, which is 9. Same procedure, different argument order, different result. This is a favorite exam trap.

# wanted 10 - 3, but the call is swapped
def minus(a, b):
    return a - b

print(minus(3, 10))   # prints -7, wrong

PROCEDURE minus(a, b)
{
    RETURN(a - b)
}
DISPLAY(minus(10, 3))

The procedure never changed. Only the call did. When you trace a call, always line up each argument with the parameter in the same position before you compute anything.

def diff(a, b):
    return a - b
print(diff(4, 10))

Return a Value or Perform an Action

Procedures come in two flavors. Some return a value that the caller can store or use in a larger expression. Others just perform an action, such as displaying text, and hand back no useful value. Knowing which kind you are calling tells you whether you need to capture the result.

The critical habit: if a procedure returns a value, you must use that value by storing it in a variable or placing the call inside another expression such as print(...). A call like double(5) on a line by itself computes 10 and then throws it away, because nothing catches the return value. Nothing is displayed. Compare the two calls below.

def double(n):
    return n * 2

double(5)          # return value discarded
print(double(5))   # return value used, prints 10

PROCEDURE double(n)
{
    RETURN(n * 2)
}
double(5)
DISPLAY(double(5))

The first call, double(5), runs and returns 10, but the 10 is discarded because it is not stored or printed. The second call, print(double(5)), uses the return value, so 10 appears. A returned value is only useful if the caller does something with it.

def twice(n):
    return n * 2
print(twice(twice(3)))

Tracing Programs That Call Procedures

Calls can happen many times, and each one runs the whole procedure again from the top. Use one disciplined routine and these traces become mechanical:

1. Find the call. Match each argument to the parameter in the same position.
2. Run the procedure's statements with those values. Note whether it returns a value or just acts.
3. When it finishes, send any returned value back to the call, then continue right after the call.
4. If a call is inside a loop, the procedure runs once per iteration, so count the iterations.
5. Only a used return value affects the output. A discarded one changes nothing you can see.

For example, if add(a, b) returns a + b and you write a loop that calls t = add(t, k) for k in range(3) starting from t = 0, the procedure runs three times: t becomes 0, then 1, then 3. The final print(t) displays 3. Each call returned a value that the caller stored back into t, so the results accumulated.

Key Vocabulary