10. Further programming and testing

• A global variable is created in the main program (outside every function) and can be read anywhere in the program.
• A local variable is created inside a procedure or function and exists only while that subroutine runs; nothing outside can use it.
• To change a global variable inside a function, Python needs the global keyword.

VAT_RATE = 0.2          # global constant

total_sales = 0         # global variable

def add_sale(price):
    global total_sales
    with_vat = price + price * VAT_RATE   # local variable
    total_sales = total_sales + with_vat
    return with_vat

print(add_sale(10))
print(add_sale(5))
print(total_sales)

Output: 12.0, 6.0, 18.0. Using with_vat in the main program would cause a run-time error (NameError): it is local.

• A global constant (e.g. VAT_RATE) is declared once at the top and used by every subroutine — ideal for values the whole program shares.
• A local constant is declared inside one subroutine because only that subroutine needs it.

def pass_mark(mark):
    PASS = 50             # local constant
    return mark >= PASS

• A subroutine is a named, self-contained block of code that performs a specific task; it runs when it is called.
• A procedure performs a task and does not return a value (e.g. displays a menu).
• A function performs a task and returns a value with return to where it was called (e.g. calculates an area), so it is used in an expression or assignment.
• A parameter is the variable named in the definition that receives a value; the value passed in the call is the argument.

• Code is written once and called many times — shorter programs, no repetition.
• Each one can be tested on its own, making errors easier to find.
• The program is decomposed into clear parts that different programmers can write.
• Easier to maintain: change the code in one place.
• Can be reused in other programs (a library).

def show_line(length):          # procedure: does a job, returns nothing
    print("-" * length)

def area(width, height):        # function: returns a value
    return width * height

def greeting():                 # function with no parameters
    return "Welcome!"

show_line(10)
print(greeting())
room = area(4, 3.5)
print("Area:", room)

Output: ----------, Welcome!, Area: 14.0. Arguments are matched to parameters in order.

import random
import statistics

marks = [56, 72, 91, 45, 72, 68]
print("Total:", sum(marks))
print("Highest:", max(marks), "Lowest:", min(marks))
print("How many 72s:", marks.count(72))
print("Mean:", round(statistics.mean(marks), 1))
dice = random.randint(1, 6)        # 1 to 6 inclusive
even = random.randrange(0, 10, 2)  # 0, 2, 4, 6 or 8 (10 excluded)

Output: Total: 404, Highest: 91 Lowest: 45, How many 72s: 2, Mean: 67.3.

A list is a data structure that stores a collection of values under one identifier.

• Each item is accessed by its index; the first index is 0.
• Items are kept in order; a list can grow and shrink.
• Avoids needing many separate variables (mark1, mark2…), and lets a loop process every item.

names = ["Ali", "Sara", "Omar"]
print(names[0])               # Ali
names[2] = "Bilal"            # write into index 2
for index in range(len(names)):
    print(index, names[index])  # using a variable for the index
for name in names:
    print(name)                 # iterating through each element
marks = []
for count in range(3):
    marks.append(int(input("Mark: ")))   # filling a list from input

A 2D list is a list of lists — a table of rows and columns. Access an item with two indexes: [row][column], and process it with nested loops.

# 3 students x 4 test scores
scores = [[12, 15, 9, 18],
          [20, 17, 14, 16],
          [8, 11, 13, 10]]
print(scores[1][2])            # row 1, column 2
for row in range(len(scores)):
    total = 0
    for col in range(len(scores[row])):
        total = total + scores[row][col]
    print("Student", row, "total", total)
grid = [[0] * 3 for _ in range(2)]
grid[1][0] = 5
print(grid)

Output: 14, Student 0 total 54, Student 1 total 67, Student 2 total 42, [[0, 0, 0], [5, 0, 0]].

names = ["Ali", "Sara", "Omar"]
names.append("Zara")          # add to the end
names.insert(1, "Bilal")      # put at index 1
print(names)
removed = names.pop()         # remove the last item
print(removed, names)
names.sort()
print(names)
print("Omar" in names, "Hina" not in names)
print(len(names))

Output:

• ['Ali', 'Bilal', 'Sara', 'Omar', 'Zara']
• Zara ['Ali', 'Bilal', 'Sara', 'Omar']
• ['Ali', 'Bilal', 'Omar', 'Sara']
• True True
• 4

sum(), max(), min() and len() work on number lists too. .pop(i) removes the item at index i; .sort() sorts the list itself (ascending).

You must be able to write both without using in or .sort() — the examiner wants the algorithm. Use the code in §9.3: a loop with an index variable and a found flag for the search; nested loops, comparison of list[i] with list[i + 1], a temporary variable for the swap and a swapped flag for the sort.

names = ["Hina", "Ali", "Omar", "Bilal"]
search = input("Name to find: ")
found = False
for index in range(len(names)):
    if names[index] == search:
        print("Found at position", index)
        found = True
if not found:
    print("Not in the list")

• Data is kept permanently (non-volatile) after the program closes or the computer is switched off.
• Data can be used again the next time the program runs (high scores, settings, records).
• Data can be shared with other programs or users, or moved to another computer.
• Large amounts of data can be stored without typing them in each time.

open(filename, mode) opens a file and .close() closes it (saving the data and releasing the file). with open(...) as file: closes the file automatically at the end of the indented block, even if an error happens.

with open("scores.txt", "w") as file:
    file.write("Ali,72\n")
    file.write("Sara,88\n")
file = open("scores.txt", "a")
file.write("Omar,65\n")
file.close()
with open("scores.txt", "r") as file:
    first = file.readline()
    rest = file.readlines()
print(first.strip())
print(rest)
with open("scores.txt", "r") as file:
    everything = file.read()
print(everything.count("\n"), "lines")

Output: Ali,72, ['Sara,88\n', 'Omar,65\n'], 3 lines.

• .write(text) writes a string (cast numbers with str() and add "\n" yourself for a new line).
• .read() — the whole file as one string.
• .readline() — the next line (including its "\n"; .strip() removes it).
• .readlines() — every remaining line as a list of strings.

Validation is an automatic check by the program that data entered is reasonable/sensible and follows the rules before it is accepted. It cannot tell if data is correct.

Inclusive limits accept the boundary values (0 <= mark <= 100); exclusive limits reject them (11 <= age < 19 excludes 19).

# range check, inclusive: 0 to 100 allowed
mark = int(input("Mark (0-100): "))
while mark < 0 or mark > 100:
    print("Out of range")
    mark = int(input("Mark (0-100): "))
print("Accepted", mark)

# presence, length and format checks on a product code like AB1234
while True:
    code = input("Product code: ")
    if code == "":
        print("Presence check: you must enter something")
    elif len(code) != 6:
        print("Length check: must be 6 characters")
    elif not (code[0:2].isalpha() and code[0:2].isupper() and code[2:].isdigit()):
        print("Format check: two capital letters then four digits")
    else:
        break
print("Valid code", code)

# type check, then an exclusive range check
while True:
    text = input("Age: ")
    if text.isdigit():
        age = int(text)
        if 11 <= age < 19:          # exclusive upper limit: 19 is rejected
            break
        print("Range check: 11 to 18 only")
    else:
        print("Type check: whole number please")
print("Age accepted:", age)

With inputs ten, 19, 15 the last program prints the type message, the range message, then Age accepted: 15.

def check_digit(code):
    weights = [4, 3, 2]
    total = 0
    for i in range(3):
        total = total + int(code[i]) * weights[i]
    remainder = total % 11
    digit = (11 - remainder) % 11
    return "X" if digit == 10 else str(digit)

print(check_digit("573"))

For 573: 5×4 + 7×3 + 3×2 = 47; 47 % 11 = 3; 11 − 3 = 8, so the full code is 5738. If someone types 5733, the recalculated check digit (8) does not match, so the error is detected.

Verification checks that data has been copied/entered accurately — that it matches the original source.

• Visual check — the user reads the data on screen and compares it with the original document, then confirms.
• Double entry — the data is entered twice and the computer compares the two; if they differ, it must be re-entered (e.g. new password, email address).

Validation = is it sensible? Verification = is it what was meant/the same as the source?

while True:
    password = input("New password: ")
    again = input("Type it again: ")
    if password == again:
        break
    print("They do not match - try again")
print("Password saved")

For a mark that must be 0 to 100 inclusive:

Always state the expected result alongside each test value.

• Read the error message: the line number and type (SyntaxError, NameError, IndexError, ValueError, ZeroDivisionError).
• Use a trace table / dry run to find logic errors.
• Add temporary print() statements to show variable values.
• Test with data whose result you already know.

# Should output the average of the three numbers
total = 0
for count in range(3):
    total = total + int(input())
average = total / 2          # logic error: should be / 3
print(average)

• Meaningful identifiers — total_price not tp, so the purpose of each variable is clear.
• Appropriate commenting — # comments explain what each part does and why (not every line).
• Procedures and functions — split the code into named, reusable parts that can be tested and changed separately.
• Relevant program layout — consistent indentation, blank lines between sections, constants at the top.

These make code easier for another programmer (or you, later) to understand, debug, update and extend.