Local & Global Variables

If every variable in a program were visible everywhere, large programs would be impossible to debug — any line could change anything. The whole point of putting code inside a function is that the function's variables are its own business. Cambridge expects you to write efficient pseudocode (Section 11.3, AS Level), and that explicitly means declaring data locally where only that routine needs it.

A local variable is one declared inside a function. Two important facts follow:

• Lifetime. The variable comes into existence when the function starts running and is destroyed when the function ends. The next call gets a fresh variable.
• Visibility. Code outside the function cannot see the variable at all. Trying to use it produces a NameError in Python (or an undeclared-variable error in pseudocode).

def greet():
    message = "Hello, World!"  # local variable
    print(message)

greet()              # prints "Hello, World!"
print(message)       # NameError: name 'message' is not defined

PROCEDURE Greet()
    DECLARE message : STRING
    message <- "Hello, World!"
    OUTPUT message
ENDPROCEDURE

CALL Greet()
OUTPUT message  // ERROR — message does not exist here

Worked example — local variable and the outside error

Task: Write a Python function calculateSum that uses a local variable total to add the integers 15 and 27, then prints the result. State what happens if you try to print total immediately after calling the function. [3 marks]

def calculateSum():
    total = 15 + 27     # local variable
    print(total)        # 42

calculateSum()         # prints 42
print(total)           # NameError: name 'total' is not defined

Sometimes the whole program needs to share a piece of state — a player's score, a bank balance, a connection setting. These values belong to the program as a whole, not to any single function. That is exactly what a global variable is for.

A global is declared outside every function. Any function can read its value just by using the name. Modifying it from inside a function needs an extra step in Python (see section 6.4).

count = 0  # global variable

def showCount():
    # reads the global — no keyword needed
    print("Inside function:", count)

showCount()
print("Outside function:", count)

# Output:
# Inside function: 0
# Outside function: 0

DECLARE count : INTEGER  // global

PROCEDURE ShowCount()
    OUTPUT "Inside procedure: ", count
ENDPROCEDURE

count <- 0
CALL ShowCount()
OUTPUT "Outside procedure: ", count

Worked example — reading a global

Task: A program has a global integer score initialised to 0. Write a Python function showScore that prints the current value of score. Then set score to 50 and call showScore to verify it can see the new value. [3 marks]

score = 0  # global

def showScore():
    # reads the global — Python finds it automatically
    print("Score is:", score)

score = 50        # change the global from outside — no keyword needed
showScore()       # Score is: 50

This is one of the most common "predict the output" trap questions on Paper 4. The function looks like it changes the global — but it does not, because a new local has shadowed it.

If a function assigns to a variable with the same name as a global, the function creates a brand-new local variable. The global is unchanged. Inside the function, the name refers to the local; outside, the name still refers to the global.

x = 10  # global

def changeX():
    x = 5  # NEW local — global x is untouched
    print("Inside function:", x)

changeX()              # Inside function: 5
print("Outside function:", x)  # Outside function: 10

DECLARE x : INTEGER  // global

PROCEDURE ChangeX()
    DECLARE x : INTEGER  // new local, shadows global
    x <- 5
    OUTPUT "Inside procedure: ", x
ENDPROCEDURE

x <- 10
CALL ChangeX()
OUTPUT "Outside procedure: ", x  // 10

Worked example — Alice / Bob / Alice

Task: A program defines a global name = "Alice". A procedure changeName declares a local name = "Bob" and prints it. Trace the output of: print name; call changeName; print name. Explain why. [4 marks]

• Step 1 — First print, before the call: outside any function, name refers to the global, which is "Alice".
• Step 2 — Inside the procedure: the procedure declares its own name and assigns "Bob". This is a brand-new local that shadows the global. The print inside the procedure uses this local.
• Step 3 — Second print, after the call: the local name was destroyed when the procedure ended. The global name was never touched — it is still "Alice".

The UnboundLocalError trap

A subtle Python trap: total = total + 50 inside a function. Python sees total = ... as a local assignment. But the right-hand side total + 50 tries to read total before the local has been assigned — this raises UnboundLocalError.

total = 100

def addBonus():
    # total = ... makes total a LOCAL.
    # RHS reads local before assigned -> ERROR
    total = total + 50
    return total

print(addBonus())  # UnboundLocalError

total = 100

def addBonus():
    # read global (no assignment to total)
    # write a NEW local called newTotal
    newTotal = total + 50
    return newTotal

print(total)       # 100
print(addBonus())  # 150
print(total)       # 100 — global unchanged

Section 6.3 showed that assigning to a name inside a function normally creates a local. But what if you really do want the function to change the global? You have to tell the language that is what you mean. In Python the keyword is global. In Cambridge pseudocode it is GLOBAL.

score = 100  # global

def addBonus():
    global score  # declare intent — modify the global
    score = score + 10  # updates the global, not a local

addBonus()
print(score)  # 110

DECLARE score : INTEGER  // global

PROCEDURE AddBonus()
    GLOBAL score
    score <- score + 10
ENDPROCEDURE

score <- 100
CALL AddBonus()
OUTPUT score  // 110

Worked example — earnMoney

Task: A program uses a global integer money initialised to 50. Write a Python function earnMoney that adds 20 to money by modifying the global directly. Call the function and verify the global has changed. [3 marks]

money = 50  # global

def earnMoney():
    global money          # this function will modify the global
    money = money + 20

print("Before:", money)   # 50
earnMoney()
print("After: ", money)   # 70

Cambridge "discuss" and "explain" questions on Paper 3 and Paper 4 often ask for two advantages of local variables, or two reasons to prefer return values over global modification. You need to have the answers ready in your own words.

Three rules of thumb

• Prefer local. If a function can do its job with local variables and a return value, do that. The code is easier to test and easier to reuse.
• Use global only when the value really is program-wide. Examples: bank balance, current player score, login state.
• Never modify a global silently. If a function changes a global, that fact should be obvious from its name (addBonus, deposit, resetScore). A function named calculateSum should not secretly change a global.

This is the standard Paper 4 "extend the existing program" question type — you are given a small system with global state and must add functions that read or modify that state correctly. A bank account simulator with a global balance and three operations.

balance = 1000  # global

def deposit(amount):
    global balance
    balance = balance + amount
    print(f"Deposited {amount}. New balance: {balance}")

def withdraw(amount):
    global balance
    if amount <= balance:
        balance = balance - amount
        print(f"Withdrew {amount}. New balance: {balance}")
    else:
        print("Insufficient funds.")

def checkBalance():
    # reads global — no "global" needed
    print(f"Current balance: {balance}")

deposit(500)      # Deposited 500. New balance: 1500
withdraw(200)     # Withdrew 200. New balance: 1300
checkBalance()    # Current balance: 1300
withdraw(5000)    # Insufficient funds.

DECLARE balance : INTEGER  // global

PROCEDURE Deposit(amount : INTEGER)
    GLOBAL balance
    balance <- balance + amount
    OUTPUT "Deposited ", amount, ". New balance: ", balance
ENDPROCEDURE

PROCEDURE Withdraw(amount : INTEGER)
    GLOBAL balance
    IF amount <= balance THEN
        balance <- balance - amount
        OUTPUT "Withdrew ", amount, ". New balance: ", balance
    ELSE
        OUTPUT "Insufficient funds."
    ENDIF
ENDPROCEDURE

PROCEDURE CheckBalance()
    OUTPUT "Current balance: ", balance
ENDPROCEDURE

Fifteen exam-style scope tasks. Each shows only the question — click Hint for the thought process, or Help for the worked solution. Try each one yourself before revealing.