Variables, types, input and output in Python and pseudocode

Variables: named boxes in memory

A variable is a named place in memory that holds one value. The value can change while the program runs.

The name is called an identifier. Cambridge pseudocode writes identifiers in PascalCase, such as `TotalScore`.

`DECLARE` gives the name and the data type before the variable is used.

The arrow `←` means assignment: work out the value on the right, then store it in the variable on the left.

DECLARE Score : INTEGER
Score ← 0
Score ← Score + 5
OUTPUT Score

score = 0
score = score + 5
print(score)

Constants: values that never change

A constant is a named value that is set once. It cannot change while the program runs.

In pseudocode write `CONSTANT`, the name, `←` and the value. No data type is given: the value shows it.

Python has no true constants. Programmers write the name in CAPITALS to mean: do not change this.

CONSTANT VATRate ← 0.21
DECLARE Price : REAL
Price ← 50.0
OUTPUT "Price with VAT: ", Price * (1 + VATRate)

VAT_RATE = 0.21
price = 50.0
print("Price with VAT:", price * (1 + VAT_RATE))

The five data types

A data type says what kind of value a variable holds. It decides how the value is stored and what you can do with it.

Cambridge uses five data types. A CHAR goes in single quotes. A STRING goes in double quotes.

DECLARE Age : INTEGER
DECLARE Height : REAL
DECLARE Grade : CHAR
DECLARE FirstName : STRING
DECLARE IsMember : BOOLEAN
Age ← 15
Height ← 1.68
Grade ← 'A'
FirstName ← "Lucia"
IsMember ← TRUE

age = 15
height = 1.68
grade = "A"
first_name = "Lucia"
is_member = True
print(type(age), type(height), type(grade), type(first_name), type(is_member))

Choosing the right data type

Ask two questions. Will I do maths with it? Can it have a decimal part?

A phone number or a postcode is a STRING. You never add phone numbers, and an INTEGER would lose a leading 0.

Use BOOLEAN for anything with only two states: paid or not paid, logged in or not.

Input and output

Input is data going into the program, usually typed by the user. `INPUT Name` waits and stores what is typed in Name.

Output is data coming out, usually on screen. `OUTPUT` can show text and variables separated by commas.

Always show a message before an INPUT so the user knows what to type. This message is a prompt.

In Python, `input()` always gives a string. Wrap it in `int()` or `float()` to get a number.

DECLARE Name : STRING
DECLARE Age : INTEGER
OUTPUT "Enter your name"
INPUT Name
OUTPUT "Enter your age"
INPUT Age
OUTPUT "Hello ", Name, ", next year you will be ", Age + 1

name = input("Enter your name: ")
age = int(input("Enter your age: "))
print("Hello " + name + ", next year you will be", age + 1)

Sequence: one step after another

Sequence means the statements run one after another, in the order they are written.

The order matters. If a value is used before it is worked out, the answer is wrong.

CONSTANT TicketPrice ← 7.50
DECLARE Tickets : INTEGER
DECLARE Total : REAL
Tickets ← 3
Total ← Tickets * TicketPrice
OUTPUT "Total to pay: ", Total

TICKET_PRICE = 7.50
tickets = 3
total = tickets * TICKET_PRICE
print("Total to pay:", total)

Selection with IF

Selection means the program chooses which statements to run, using a condition.

A condition is a question with a TRUE or FALSE answer, such as `Mark >= 50`.

The THEN part runs when the condition is TRUE. The ELSE part runs when it is FALSE. ELSE is optional. ENDIF closes the IF.

DECLARE Mark : INTEGER
OUTPUT "Enter the mark"
INPUT Mark
IF Mark >= 50
  THEN
    OUTPUT "Pass"
  ELSE
    OUTPUT "Fail"
ENDIF

mark = int(input("Enter the mark: "))
if mark >= 50:
    print("Pass")
else:
    print("Fail")

Nested IF: up to three levels

A nested IF is an IF inside another IF. Use it when the next question depends on the first answer.

Cambridge questions use nesting up to three levels deep. More than that is hard to read.

In pseudocode the next IF goes inside the ELSE. Python can shorten ELSE followed by IF to `elif`.

DECLARE Mark : INTEGER
Mark ← 58
IF Mark >= 70
  THEN
    OUTPUT "Grade A"
  ELSE
    IF Mark >= 55
      THEN
        OUTPUT "Grade B"
      ELSE
        IF Mark >= 40
          THEN
            OUTPUT "Grade C"
          ELSE
            OUTPUT "Ungraded"
        ENDIF
    ENDIF
ENDIF

mark = 58
if mark >= 70:
    print("Grade A")
elif mark >= 55:
    print("Grade B")
elif mark >= 40:
    print("Grade C")
else:
    print("Ungraded")

Selection with CASE

`CASE OF` picks one path from many, using the value of one variable.

Each line has a value, a colon, then the statement to run. `OTHERWISE` catches every value that is not listed. ENDCASE closes it.

CASE is neater than a long chain of IFs when one variable is compared with fixed values.

Python 3.10 and later has `match` and `case`. `case _` works like OTHERWISE. Older Python uses if, elif and else.

DECLARE Choice : CHAR
OUTPUT "A = add, S = subtract, Q = quit"
INPUT Choice
CASE OF Choice
  'A' : OUTPUT "Adding"
  'S' : OUTPUT "Subtracting"
  'Q' : OUTPUT "Goodbye"
  OTHERWISE : OUTPUT "Unknown choice"
ENDCASE

choice = input("A = add, S = subtract, Q = quit: ")
match choice:
    case "A":
        print("Adding")
    case "S":
        print("Subtracting")
    case "Q":
        print("Goodbye")
    case _:
        print("Unknown choice")

Relational and logical operators

Relational operators compare two values. The answer is always TRUE or FALSE.

Logical operators join conditions. `AND` needs both to be TRUE. `OR` needs at least one TRUE. `NOT` swaps TRUE and FALSE.

The table uses Age = 15.

DECLARE Age : INTEGER
DECLARE HasCard : BOOLEAN
Age ← 15
HasCard ← TRUE
IF (Age < 26 OR Age >= 65) AND HasCard = TRUE
  THEN
    OUTPUT "Discount fare"
  ELSE
    OUTPUT "Full fare"
ENDIF

age = 15
has_card = True
if (age < 26 or age >= 65) and has_card == True:
    print("Discount fare")
else:
    print("Full fare")

Arithmetic operators, DIV and MOD

Cambridge uses seven arithmetic operators: `+`, `-`, `*`, `/`, `^`, `DIV` and `MOD`.

`/` gives the full answer, which can have a decimal part. `DIV` gives only the whole-number part. `MOD` gives the remainder.

You may see `DIV(17, 5)` or `17 DIV 5`. Both mean the same.

Try the toy: share 17 sweets between 5 friends. Each friend gets DIV(17, 5) = 3. MOD(17, 5) = 2 sweets are left over.

DECLARE Minutes : INTEGER
Minutes ← 135
OUTPUT DIV(Minutes, 60), " hours and ", MOD(Minutes, 60), " minutes"

minutes = 135
print(minutes // 60, "hours and", minutes % 60, "minutes")

There is something to try for this step in the IGCSE library.

Iteration: the count-controlled FOR loop

Iteration means repeating a block of statements. A block that repeats is called a loop.

A count-controlled loop repeats a set number of times. Cambridge writes it `FOR … TO … NEXT`.

The loop variable counts for you. `STEP` sets how much it goes up, or down, each time.

DECLARE Count : INTEGER
FOR Count ← 1 TO 5
  OUTPUT Count * 3
NEXT Count
FOR Count ← 10 TO 0 STEP -2
  OUTPUT Count
NEXT Count

for count in range(1, 6):
    print(count * 3)
for count in range(10, -1, -2):
    print(count)

The pre-condition WHILE loop

A pre-condition loop checks its condition before each pass. Cambridge writes it `WHILE … DO … ENDWHILE`.

It repeats while the condition is TRUE. If the condition is FALSE at the start, the loop body never runs.

Use it when you do not know how many passes are needed.

DECLARE Savings : REAL
DECLARE Years : INTEGER
Savings ← 1000.0
Years ← 0
WHILE Savings < 1500 DO
  Savings ← Savings * 1.1
  Years ← Years + 1
ENDWHILE
OUTPUT "Years needed: ", Years

savings = 1000.0
years = 0
while savings < 1500:
    savings = savings * 1.1
    years = years + 1
print("Years needed:", years)

The post-condition REPEAT UNTIL loop

A post-condition loop checks its condition after each pass. Cambridge writes it `REPEAT … UNTIL`.

The body always runs at least once. The loop stops when the condition becomes TRUE.

It suits validation: ask for the input, and ask again until it is acceptable.

Python has no REPEAT UNTIL. Use `while True:` and `break` out of the loop when the stop condition is TRUE.

DECLARE Mark : INTEGER
REPEAT
  OUTPUT "Enter a mark from 0 to 100"
  INPUT Mark
UNTIL Mark >= 0 AND Mark <= 100
OUTPUT "Accepted: ", Mark

while True:
    mark = int(input("Enter a mark from 0 to 100: "))
    if mark >= 0 and mark <= 100:
        break
print("Accepted:", mark)

Choosing the right loop

First ask: do I know how many times? If yes, use FOR.

If not, ask: must it run at least once? If yes, use REPEAT UNTIL. If it might need to run zero times, use WHILE.

Totalling and counting

Totalling keeps a running total: `Total ← Total + Value`.

Counting adds 1 each time something happens: `Count ← Count + 1`.

Set both to 0 before the loop starts.

DECLARE Total : INTEGER
DECLARE PassCount : INTEGER
DECLARE Mark : INTEGER
DECLARE Count : INTEGER
Total ← 0
PassCount ← 0
FOR Count ← 1 TO 5
  OUTPUT "Enter mark"
  INPUT Mark
  Total ← Total + Mark
  IF Mark >= 50
    THEN
      PassCount ← PassCount + 1
  ENDIF
NEXT Count
OUTPUT "Total: ", Total
OUTPUT "Average: ", Total / 5
OUTPUT "Passes: ", PassCount

total = 0
pass_count = 0
for count in range(1, 6):
    mark = int(input("Enter mark: "))
    total = total + mark
    if mark >= 50:
        pass_count = pass_count + 1
print("Total:", total)
print("Average:", total / 5)
print("Passes:", pass_count)

String handling: LENGTH, UCASE, LCASE

A string is a sequence of characters. Each character has a position number.

`LENGTH(s)` gives the number of characters, and spaces count.

`UCASE(s)` gives the string in capitals. `LCASE(s)` gives it in lower case. The variable itself only changes if you assign the result back.

DECLARE City : STRING
City ← "Madrid Spain"
OUTPUT LENGTH(City)
OUTPUT UCASE(City)
OUTPUT LCASE(City)

city = "Madrid Spain"
print(len(city))
print(city.upper())
print(city.lower())

SUBSTRING and the first position: 1 or 0

`SUBSTRING(s, start, length)` takes a piece out of a string. You give the start position and how many characters you want.

In Cambridge pseudocode the first character is position 1. In Python the first character is position 0.

Python uses slicing: `s[start:end]` takes characters from start up to, but not including, end.

Try the toy: type MADRID as the string. Set the start to 4 and the length to 3, and check you get RID. Then try LENGTH, UCASE and LCASE on the same string.

DECLARE Word : STRING
Word ← "MADRID"
OUTPUT SUBSTRING(Word, 1, 3)
OUTPUT SUBSTRING(Word, 4, 3)
OUTPUT SUBSTRING(Word, 1, 1)

word = "MADRID"
print(word[0:3])
print(word[3:6])
print(word[0])

There is something to try for this step in the IGCSE library.

Procedures and parameters

A subroutine is a named block of code that does one job. You write it once and call it whenever you need it.

A procedure is a subroutine that does a task but does not give a value back. You run it with `CALL`.

A parameter is a variable in the heading that receives a value when the subroutine is called. Cambridge uses up to three.

The value you pass in is called the argument. Here "Ana" and 2 are the arguments.

PROCEDURE Greet(Name : STRING, Times : INTEGER)
  DECLARE Count : INTEGER
  FOR Count ← 1 TO Times
    OUTPUT "Hello ", Name
  NEXT Count
ENDPROCEDURE

CALL Greet("Ana", 2)

def greet(name, times):
    for count in range(1, times + 1):
        print("Hello", name)

greet("Ana", 2)

Functions: subroutines that return a value

A function is a subroutine that returns a value to the place where it was called.

The heading gives the type of the value it returns, such as `RETURNS REAL`. `RETURN` sends the value back.

A function gives a value, so you use it inside an expression or an OUTPUT. You do not use CALL.

FUNCTION Average(Mark1 : REAL, Mark2 : REAL, Mark3 : REAL) RETURNS REAL
  RETURN (Mark1 + Mark2 + Mark3) / 3
ENDFUNCTION

DECLARE Result : REAL
Result ← Average(70, 64, 85)
OUTPUT "Average: ", Result

def average(mark1, mark2, mark3):
    return (mark1 + mark2 + mark3) / 3

result = average(70, 64, 85)
print("Average:", result)

Local and global variables

Scope means the part of the program where a variable can be used.

A global variable is declared in the main program. Every part of the program can use it.

A local variable is declared inside a subroutine. It exists only while that subroutine runs, and nothing outside can see it.

In Python a function can read a global variable. To change it, the function must first say `global`.

DECLARE Score : INTEGER        // global
Score ← 0

PROCEDURE AddBonus(Bonus : INTEGER)
  DECLARE Doubled : INTEGER    // local
  Doubled ← Bonus * 2
  Score ← Score + Doubled
ENDPROCEDURE

CALL AddBonus(5)
OUTPUT Score

score = 0  # global

def add_bonus(bonus):
    global score
    doubled = bonus * 2  # local
    score = score + doubled

add_bonus(5)
print(score)

Library routines: MOD, DIV, ROUND, RANDOM

A library routine is a ready-made, tested subroutine that comes with the language. You use it without writing it.

Cambridge expects four: `MOD`, `DIV`, `ROUND` and `RANDOM`. MOD and DIV were in the arithmetic step.

`ROUND(Value, Places)` rounds to a number of decimal places. `ROUND(6.97354, 2)` gives 6.97.

`RANDOM()` gives a random REAL number from 0 to 1. Multiply it and round it to get the range you want.

DECLARE Price : REAL
DECLARE Dice : INTEGER
Price ← 19.987
OUTPUT ROUND(Price, 2)
Dice ← ROUND(RANDOM() * 5, 0) + 1
OUTPUT "You rolled ", Dice

import random
price = 19.987
print(round(price, 2))
dice = random.randint(1, 6)
print("You rolled", dice)

Writing maintainable programs

A maintainable program is easy for another programmer, or you months later, to read, fix and update.

Use meaningful identifiers: `TotalPrice`, not `tp` or `x`.

Add comments that explain what a part does and why. Pseudocode comments start with `//`. Python comments start with `#`.

Use procedures and functions so each job lives in one named place. Use constants for fixed values, and indent code inside IFs, loops and subroutines.

// Works out the cost of a school trip for one pupil
CONSTANT CoachCost ← 600.0
CONSTANT EntryFee ← 8.5

FUNCTION CostPerPupil(Pupils : INTEGER) RETURNS REAL
  // the coach is shared, the entry fee is paid by each pupil
  RETURN CoachCost / Pupils + EntryFee
ENDFUNCTION

OUTPUT "Cost per pupil: ", CostPerPupil(30)

# Works out the cost of a school trip for one pupil
COACH_COST = 600.0
ENTRY_FEE = 8.5

def cost_per_pupil(pupils):
    # the coach is shared, the entry fee is paid by each pupil
    return COACH_COST / pupils + ENTRY_FEE

print("Cost per pupil:", cost_per_pupil(30))