Writing Your Own Procedure

A procedure is a named block of code that you can call by name. Until now you have mostly called procedures other people wrote, like print or len. Now you will define your own. In Python you write def name(parameters): and then the indented body. The definition does not run on its own. The body only executes when the procedure is called.

Two pieces make a procedure powerful. A parameter is a placeholder listed in the header that stands for a value the caller will supply. A return value is the result the procedure hands back with the return keyword, so the caller can store it or print it. Python uses def and return; AP pseudocode uses PROCEDURE name(param) and RETURN(...). They express the same idea.

def double(n):
    return n * 2

print(double(5))

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

DISPLAY(double(5))

Here double is defined once with a parameter n. The call double(5) sends the value 5 into n, the body computes 5 * 2, and return hands 10 back to the caller, which then prints 10. The parameter is what lets one definition work for any number you pass.

def double(n):
    return n * 2
print(double(6))

Return vs No Return: the None Trap

A procedure only hands back a value if you actually write return. If the body computes something but never returns it, the procedure finishes and hands back the special value None. This is one of the most common bugs in early code: you compute the right answer inside the procedure, but forget to return it, so storing or printing the call gives None.

# forgot to return
def area(s):
    a = s * s

x = area(5)
print(x)

# fixed: hand back the value
PROCEDURE area(s)
{
    a <- s * s
    RETURN(a)
}

DISPLAY(area(5))

On the left, area computes a but never returns it, so x receives None and the program prints None instead of 25. The fix on the right adds RETURN(a) so the value actually leaves the procedure. Always ask: does the value I computed ever get returned?

def f(n):
    result = n + 1
print(f(3))

Parameters Are Local Placeholders

A parameter is a local name that exists only inside the procedure while it runs. When you call double(5), the parameter n becomes 5 for that call, then disappears when the procedure ends. A parameter is not the same variable as the one in the caller, even if they happen to share a name. Reassigning a parameter inside the body does not change the caller's variable.

The whole point of a parameter is to generalize. Instead of writing one block for a square of side 4 and another block for a square of side 7, you write one procedure with a parameter and call it with 4, then 7, then any value. One definition, many uses. That is exactly the repetition that procedures remove.

def label(score):
    if score >= 60:
        return "pass"
    else:
        return "fail"

print(label(72))

PROCEDURE label(score)
{
    IF (score >= 60)
    {
        RETURN("pass")
    }
    ELSE
    {
        RETURN("fail")
    }
}

The label procedure has a parameter score and uses selection to return one of two results. Calling label(72) returns "pass"; calling label(40) returns "fail". The parameter is what makes the single procedure answer for every possible score.

Procedural Abstraction and Its Benefits

Procedural abstraction (AAP-3.C) means giving a name to a process and then using that name without worrying about the details inside. Once double exists, you write double(5) and think "double it," not "multiply by two." The details are hidden behind the name. This is the same idea as calling print: you use it constantly without knowing how it works internally.

The benefits are practical, and the exam names them directly:

• it removes duplicate code by naming a process once and reusing it
• it makes a program easier to read, because a good name explains intent
• it makes a program easier to change, because you fix the logic in one place
• it hides the implementation detail so you can reason about what, not how

Notice what abstraction does not do: it does not change the result the program computes. Replacing three copied blocks with one procedure produces the exact same output; it just organizes the program better. That distinction is a favorite exam trap.

def square(n):
    return n * n
print(square(4))

Key Vocabulary

Bonus Game: Robot Director

The dreaded robot problems, made playable. Plan a sequence of MOVE_FORWARD, ROTATE_LEFT, and ROTATE_RIGHT commands to steer the AP robot to the flag in as few commands as possible.