Pseudocode ↔ Python

CAIE pseudocode
// this procedure swaps
// values of X and Y
PROCEDURE SWAP(BYREF X : INTEGER, Y : INTEGER)
   DECLARE Temp : INTEGER
   Temp ← X   // temporarily store X
   X ← Y
   Y ← Temp
ENDPROCEDURE

Python# this procedure swaps
# values of x and y
def swap(x, y):
    return y, x

CAIE pseudocode
REPEAT
   <statement(s)>
UNTIL <condition>

Python# <…> means “substitute something here”

CAIE pseudocode
DECLARE Count : INTEGER      // 5, -3
DECLARE Price : REAL         // 4.7, 0.3, -4.0 (a digit each side of the point)
DECLARE Grade : CHAR         // 'x', 'C', '@'  (single quotes)
DECLARE Name : STRING        // "This is a string", ""  (double quotes)
DECLARE Found : BOOLEAN      // TRUE, FALSE
DECLARE DOB : DATE           // 02/01/2005 (dd/mm/yyyy)
Count ← -3
Price ← 4.7
Grade ← 'C'
Name ← ""
Found ← TRUE
DOB ← 02/01/2005
OUTPUT Count, " ", Price, " ", Grade, " ", Found, " ", DOB

Pythoncount = -3
price = 4.7
grade = 'C'
name = ""
found = True
from datetime import date
dob = date(2005, 1, 2)

CAIE pseudocode
DECLARE Counter : INTEGER
DECLARE TotalToPay : REAL
DECLARE GameOver : BOOLEAN

Pythoncounter: int = 0
total_to_pay: float = 0.0
game_over: bool = False

CAIE pseudocode
CONSTANT HourlyRate = 6.50
CONSTANT DefaultText = "N/A"
OUTPUT HourlyRate * 40, " ", DefaultText

PythonHOURLY_RATE = 6.50
DEFAULT_TEXT = "N/A"

CAIE pseudocode
DECLARE Counter, NumberOfHours : INTEGER
DECLARE TotalToPay : REAL
CONSTANT HourlyRate = 6.50
Counter ← 0
Counter ← Counter + 1
NumberOfHours ← 12
TotalToPay ← NumberOfHours * HourlyRate
OUTPUT Counter, " ", TotalToPay

Pythoncounter = 0
counter = counter + 1
total_to_pay = number_of_hours * HOURLY_RATE

CAIE pseudocode
DECLARE StudentNames : ARRAY[1:30] OF STRING
DECLARE NoughtsAndCrosses : ARRAY[1:3,1:3] OF CHAR

Pythonstudent_names = [""] * 30
noughts_and_crosses = [[' '] * 3 for _ in range(3)]

CAIE pseudocode
DECLARE StudentNames : ARRAY[1:30] OF STRING
DECLARE NoughtsAndCrosses : ARRAY[1:3,1:3] OF CHAR
DECLARE n : INTEGER
n ← 1
StudentNames[1] ← "Ali"
NoughtsAndCrosses[2,3] ← 'X'
StudentNames[n+1] ← StudentNames[n]
OUTPUT StudentNames[2], " ", NoughtsAndCrosses[2,3]

Pythonstudent_names[0] = "Ali"
noughts_and_crosses[1][2] = 'X'
student_names[n] = student_names[n - 1]

CAIE pseudocode
DECLARE StudentNames : ARRAY[1:30] OF STRING
DECLARE Backup : ARRAY[1:30] OF STRING
DECLARE Index : INTEGER
FOR Index ← 1 TO 30
   StudentNames[Index] ← ""
NEXT Index
StudentNames[7] ← "Sara"
Backup ← StudentNames      // allowed: same size and type
OUTPUT Backup[7]

Pythonstudent_names = [""] * 30
backup = student_names.copy()

CAIE pseudocode
TYPE Season = (Spring, Summer, Autumn, Winter)
DECLARE ThisSeason, NextSeason : Season
ThisSeason ← Spring
NextSeason ← ThisSeason + 1
OUTPUT NextSeason

Pythonfrom enum import Enum
class Season(Enum):
    SPRING = 1; SUMMER = 2; AUTUMN = 3; WINTER = 4
this_season = Season.SPRING
next_season = Season(this_season.value + 1)

CAIE pseudocode
TYPE TIntPointer = ^INTEGER
DECLARE MyPointer : TIntPointer
DECLARE Count : INTEGER
Count ← 5
MyPointer ← ^Count        // address of Count
MyPointer^ ← MyPointer^ + 1   // access the value stored at the memory address
OUTPUT Count

Python# Python has no raw pointers; the closest idea is
# two names bound to one mutable object.
count = [5]
my_pointer = count
my_pointer[0] += 1
print(count[0])

CAIE pseudocode
TYPE StudentRecord
   DECLARE LastName : STRING
   DECLARE FirstName : STRING
   DECLARE DateOfBirth : DATE
   DECLARE YearGroup : INTEGER
   DECLARE FormGroup : CHAR
ENDTYPE
DECLARE Pupil1, Pupil2 : StudentRecord
Pupil1.LastName ← "Johnson"
Pupil1.FirstName ← "Leroy"
Pupil1.DateOfBirth ← 02/01/2005
Pupil1.YearGroup ← 6
Pupil1.FormGroup ← 'A'
Pupil2 ← Pupil1
OUTPUT Pupil2.FirstName, " ", Pupil2.LastName

Pythonfrom dataclasses import dataclass
from datetime import date
@dataclass
class StudentRecord:
    last_name: str = ""
    first_name: str = ""
    date_of_birth: date = date(2000, 1, 1)
    year_group: int = 0
    form_group: str = ""
pupil1 = StudentRecord("Johnson", "Leroy", date(2005, 1, 2), 6, 'A')
import copy; pupil2 = copy.copy(pupil1)

CAIE pseudocode
TYPE StudentRecord
   DECLARE LastName : STRING
   DECLARE YearGroup : INTEGER
ENDTYPE
DECLARE Form : ARRAY[1:30] OF StudentRecord
DECLARE Index : INTEGER
FOR Index ← 1 TO 30        // every field must be given a value before it is read
   Form[Index].YearGroup ← 7
NEXT Index
FOR Index ← 1 TO 30
   Form[Index].YearGroup ← Form[Index].YearGroup + 1
NEXT Index
OUTPUT Form[30].YearGroup

Pythonform = [StudentRecord() for _ in range(30)]
for s in form:
    s.year_group += 1

CAIE pseudocode
TYPE LetterSet = SET OF CHAR
DEFINE Vowels ('A','E','I','O','U') : LetterSet
DECLARE Ch : CHAR
Ch ← 'E'
IF Ch IN Vowels THEN
   OUTPUT Ch, " is a vowel"
ENDIF

Pythonvowels = {'A', 'E', 'I', 'O', 'U'}
if ch in vowels:
    print(ch, "is a vowel")

CAIE pseudocode
DECLARE Answer : STRING
DECLARE Score, Lives : INTEGER
Score ← 120
Lives ← 3
INPUT Answer
OUTPUT Score
OUTPUT "You have ", Lives, " lives left"

Pythonanswer = input()
print(score)
print("You have", lives, "lives left")

CAIE pseudocode
OUTPUT 7 / 2      // 3.5 (REAL even for integer operands)
OUTPUT 7 DIV 2    // 3 (quotient)
OUTPUT 7 MOD 2    // 1 (remainder)
OUTPUT (2 + 3) * 4  // use brackets to make order explicit

Pythonprint(7 / 2)   # 3.5
print(7 // 2)  # 3
print(7 % 2)   # 1
print((2 + 3) * 4)

CAIE pseudocode
DECLARE A, B : INTEGER
A ← 5
B ← 8
OUTPUT A > B, " ", A <= B, " ", A = 5, " ", A <> B
OUTPUT (A < B) AND NOT (B = 8)
OUTPUT (A > B) OR (B > A)

Pythonprint(a > b, a <= b, a == 5, a != b)
print((a < b) and not (b == 8))
print((a > b) or (b > a))

CAIE pseudocode
OUTPUT RIGHT("ABCDEFGH", 3)     // "FGH"
OUTPUT LENGTH("Happy Days")      // 10
OUTPUT MID("ABCDEFGH", 2, 3)    // "BCD"  (start position, length)
OUTPUT LCASE('W')                // 'w'
OUTPUT UCASE('h')                // 'H'
OUTPUT "Summer" & " " & "Pudding"  // & concatenates

Python"ABCDEFGH"[-3:]          # RIGHT
len("Happy Days")          # LENGTH
"ABCDEFGH"[1:4]           # MID(s, 2, 3) → start index 1, length 3
'W'.lower(); 'h'.upper()
"Summer" + " " + "Pudding"

CAIE pseudocode
OUTPUT INT(27.5415)      // 27 — the integer part
OUTPUT RAND(87) < 87     // RAND(x): random REAL from 0 up to (not including) x
OUTPUT INT(RAND(6)) + 1  // a dice roll 1–6

Pythonint(27.5415)
import random
random.random() * 87
random.randint(1, 6)

CAIE pseudocode
DECLARE ChallengerScore, ChampionScore, HighestScore : INTEGER
DECLARE ChallengerName, ChampionName : STRING
ChallengerScore ← 90
ChampionScore ← 85
HighestScore ← 95
ChallengerName ← "Ayesha"
ChampionName ← "Bilal"
IF ChallengerScore > ChampionScore THEN
   IF ChallengerScore > HighestScore THEN
      OUTPUT ChallengerName, " is champion and highest scorer"
   ELSE
      OUTPUT ChallengerName, " is the new champion"
   ENDIF
ELSE
   OUTPUT ChampionName, " is still the champion"
   IF ChampionScore > HighestScore THEN
      OUTPUT ChampionName, " is also the highest scorer"
   ENDIF
ENDIF

Pythonif challenger_score > champion_score:
    if challenger_score > highest_score:
        print(challenger_name, "is champion and highest scorer")
    else:
        print(challenger_name, "is the new champion")
else:
    print(champion_name, "is still the champion")
    if champion_score > highest_score:
        print(champion_name, "is also the highest scorer")

CAIE pseudocode
DECLARE Move : CHAR
DECLARE Position : INTEGER
Position ← 50
INPUT Move
CASE OF Move
   'W' : Position ← Position - 10
   'S' : Position ← Position + 10
   'A' : Position ← Position - 1
   'D' : Position ← Position + 1
   OTHERWISE : OUTPUT "Beep"
ENDCASE
OUTPUT Position

Pythonmatch move:
    case 'W': position -= 10
    case 'S': position += 10
    case 'A': position -= 1
    case 'D': position += 1
    case _: print("Beep")

CAIE pseudocode
DECLARE Mark : INTEGER
Mark ← 67
CASE OF Mark
   80 TO 100 : OUTPUT "A"
   60 TO 79  : OUTPUT "B"
   40 TO 59  : OUTPUT "C"
   OTHERWISE : OUTPUT "U"
ENDCASE

Pythonif 80 <= mark <= 100: print("A")
elif 60 <= mark <= 79: print("B")
elif 40 <= mark <= 59: print("C")
else: print("U")

CAIE pseudocode
CONSTANT MaxRow = 3
DECLARE Amount : ARRAY[1:3, 1:10] OF INTEGER
DECLARE Row, Column, RowTotal, Total : INTEGER
FOR Row ← 1 TO MaxRow
   FOR Column ← 1 TO 10
      Amount[Row, Column] ← Row * Column
   NEXT Column
NEXT Row
Total ← 0
FOR Row ← 1 TO MaxRow
   RowTotal ← 0
   FOR Column ← 1 TO 10
      RowTotal ← RowTotal + Amount[Row, Column]
   NEXT Column
   OUTPUT "Total for Row ", Row, " is ", RowTotal
   Total ← Total + RowTotal
NEXT Row
OUTPUT "The grand total is ", Total

Pythontotal = 0
for row in range(MAX_ROW):
    row_total = 0
    for column in range(10):
        row_total += amount[row][column]
    print("Total for Row", row + 1, "is", row_total)
    total += row_total
print("The grand total is", total)

CAIE pseudocode
DECLARE i : INTEGER
FOR i ← 10 TO 1 STEP -3
   OUTPUT i
NEXT i

Pythonfor i in range(10, 0, -3):
    print(i)

CAIE pseudocode
DECLARE Password : STRING
REPEAT
   OUTPUT "Please enter the password"
   INPUT Password
UNTIL Password = "Secret"
OUTPUT "Welcome"

Pythonwhile True:
    print("Please enter the password")
    password = input()
    if password == "Secret":
        break

CAIE pseudocode
DECLARE Number : INTEGER
Number ← 25
WHILE Number > 9
   Number ← Number - 9
ENDWHILE
OUTPUT Number

Pythonwhile number > 9:
    number = number - 9

CAIE pseudocode
CONSTANT Default = 100
DECLARE Size : INTEGER
 
PROCEDURE MoveForward(Distance : INTEGER)
   OUTPUT "forward ", Distance
ENDPROCEDURE
PROCEDURE Turn(Angle : INTEGER)
   OUTPUT "turn ", Angle
ENDPROCEDURE
PROCEDURE Square(Size : INTEGER)
   DECLARE Side : INTEGER
   FOR Side ← 1 TO 4
      CALL MoveForward(Size)
      CALL Turn(90)
   NEXT Side
ENDPROCEDURE
PROCEDURE DefaultSquare()
   CALL Square(100)
ENDPROCEDURE
 
Size ← 50
IF Size = Default THEN
   CALL DefaultSquare()
ELSE
   CALL Square(Size)
ENDIF

Pythondef square(size):
    for side in range(4):
        move_forward(size)
        turn(90)

def default_square():
    square(100)

if size == DEFAULT:
    default_square()
else:
    square(size)

CAIE pseudocode
DECLARE Distance : INTEGER
Distance ← 7
 
FUNCTION Max(Number1 : INTEGER, Number2 : INTEGER) RETURNS INTEGER
   IF Number1 > Number2 THEN
      RETURN Number1
   ELSE
      RETURN Number2
   ENDIF
ENDFUNCTION
 
OUTPUT "Penalty Fine = ", Max(10, Distance*2)

Pythondef max_(number1, number2):
    if number1 > number2:
        return number1
    return number2

print("Penalty Fine =", max_(10, distance * 2))

CAIE pseudocode
PROCEDURE SWAP(BYREF X : INTEGER, Y : INTEGER)
   DECLARE Temp : INTEGER
   Temp ← X
   X ← Y
   Y ← Temp
ENDPROCEDURE
 
DECLARE A, B : INTEGER
A ← 1
B ← 2
CALL SWAP(A, B)
OUTPUT A, " ", B

Python# Python passes references to objects; ints are immutable,
# so return the new values instead:
def swap(x, y):
    return y, x
a, b = swap(a, b)

CAIE pseudocode
DECLARE LineOfText : STRING
// make FileA.txt first
OPENFILE "FileA.txt" FOR WRITE
WRITEFILE "FileA.txt", "first line"
WRITEFILE "FileA.txt", ""
WRITEFILE "FileA.txt", "third line"
CLOSEFILE "FileA.txt"
 
OPENFILE "FileA.txt" FOR READ
OPENFILE "FileB.txt" FOR WRITE
WHILE NOT EOF("FileA.txt")
   READFILE "FileA.txt", LineOfText
   IF LineOfText = "" THEN
      WRITEFILE "FileB.txt", " ----------------------------"
   ELSE
      WRITEFILE "FileB.txt", LineOfText
   ENDIF
ENDWHILE
CLOSEFILE "FileA.txt"
CLOSEFILE "FileB.txt"
OUTPUT "copied — see the Files panel"

Pythonwith open("FileA.txt") as src, open("FileB.txt", "w") as dst:
    for line in src:
        line = line.rstrip("\n")
        dst.write((" " + "-" * 28 if line == "" else line) + "\n")

CAIE pseudocode
TYPE Student
   DECLARE LastName : STRING
   DECLARE YearGroup : INTEGER
ENDTYPE
DECLARE Pupil, NewPupil : Student
DECLARE Position : INTEGER
 
OPENFILE "StudentFile.Dat" FOR RANDOM
FOR Position ← 10 TO 12
   Pupil.LastName ← "Pupil" & NUM_TO_STR(Position)
   Pupil.YearGroup ← 6
   SEEK "StudentFile.Dat", Position
   PUTRECORD "StudentFile.Dat", Pupil
NEXT Position
 
// move records 12..10 up one place, then insert at 10
FOR Position ← 12 TO 10 STEP -1
   SEEK "StudentFile.Dat", Position
   GETRECORD "StudentFile.Dat", Pupil
   SEEK "StudentFile.Dat", Position + 1
   PUTRECORD "StudentFile.Dat", Pupil
NEXT Position
NewPupil.LastName ← "Johnson"
NewPupil.YearGroup ← 6
SEEK "StudentFile.Dat", 10
PUTRECORD "StudentFile.Dat", NewPupil
CLOSEFILE "StudentFile.Dat"
OUTPUT "done — see the Files panel"

Pythonimport pickle, os
# Python: use a fixed record size and f.seek(pos * SIZE)
# with struct/pickle, or a shelve/dbm for keyed records.

CAIE pseudocode
CLASS PlayerClass
   PRIVATE Attempts : INTEGER
   PUBLIC PROCEDURE NEW()
      Attempts ← 3
   ENDPROCEDURE
   PUBLIC PROCEDURE SetAttempts(Number : INTEGER)
      Attempts ← Number
   ENDPROCEDURE
   PUBLIC FUNCTION GetAttempts() RETURNS INTEGER
      RETURN Attempts
   ENDFUNCTION
ENDCLASS
 
DECLARE Player : PlayerClass
Player ← NEW PlayerClass()
Player.SetAttempts(5)
OUTPUT Player.GetAttempts()

Pythonclass Player:
    def __init__(self):
        self.__attempts = 3
    def set_attempts(self, number):
        self.__attempts = number
    def get_attempts(self):
        return self.__attempts

player = Player()
player.set_attempts(5)
print(player.get_attempts())

CAIE pseudocode
CLASS Pet
   PRIVATE Name : STRING
   PUBLIC PROCEDURE NEW(GivenName : STRING)
      Name ← GivenName
   ENDPROCEDURE
   PUBLIC FUNCTION GetName() RETURNS STRING
      RETURN Name
   ENDFUNCTION
ENDCLASS
 
CLASS Cat INHERITS Pet
   PRIVATE Breed : STRING
   PUBLIC PROCEDURE NEW(GivenName : STRING, GivenBreed : STRING)
      SUPER.NEW(GivenName)
      Breed ← GivenBreed
   ENDPROCEDURE
   PUBLIC FUNCTION Describe() RETURNS STRING
      RETURN GetName() & " is a " & Breed
   ENDFUNCTION
ENDCLASS
 
DECLARE MyCat : Cat
MyCat ← NEW Cat("Kitty", "Shorthaired")
OUTPUT MyCat.Describe()

Pythonclass Pet:
    def __init__(self, given_name):
        self.__name = given_name
    def get_name(self):
        return self.__name

class Cat(Pet):
    def __init__(self, given_name, given_breed):
        super().__init__(given_name)
        self.__breed = given_breed
    def describe(self):
        return f"{self.get_name()} is a {self.__breed}"

my_cat = Cat("Kitty", "Shorthaired")
print(my_cat.describe())

CAIE pseudocode
DECLARE Entry : STRING
DECLARE N : INTEGER
INPUT Entry
TRY
   N ← STR_TO_NUM(Entry)
   OUTPUT 100 / N
EXCEPT
   OUTPUT "Error: ", ERRORMESSAGE()
ENDTRY
OUTPUT "Still running"

Pythontry:
    n = int(entry)
    print(100 / n)
except Exception as e:
    print("Error:", e)
print("Still running")

CAIE pseudocode
OUTPUT LENGTH("Computer")           // 8
OUTPUT SUBSTRING("Computer", 1, 4)  // "Comp" (start, length)
OUTPUT UCASE("hello")               // "HELLO" — whole strings in 2210
OUTPUT LCASE("HELLO")
OUTPUT ROUND(3.14159, 2)            // 3.14
OUTPUT RANDOM() < 1                 // random REAL 0 ≤ x < 1
OUTPUT 17 DIV 5, " ", 17 MOD 5      // 3 2

Pythonlen("Computer")
"Computer"[0:4]
"hello".upper()
round(3.14159, 2)
import random; random.random()
17 // 5, 17 % 5

CAIE pseudocode
DECLARE Total, Count, Num : INTEGER
Total ← 0
Count ← 0
INPUT Num
WHILE Num <> -1 DO
   Total ← Total + Num
   Count ← Count + 1
   INPUT Num
ENDWHILE
OUTPUT "Total ", Total, " Count ", Count

Pythontotal = count = 0
num = int(input())
while num != -1:
    total += num
    count += 1
    num = int(input())

CAIE pseudocode
DECLARE Line : STRING
OPENFILE "data.txt" FOR WRITE
WRITEFILE "data.txt", "Zak"
CLOSEFILE "data.txt"
OPENFILE "data.txt" FOR READ
READFILE "data.txt", Line
CLOSEFILE "data.txt"
OUTPUT Line

Pythonwith open("data.txt", "w") as f: f.write("Zak\n")
with open("data.txt") as f: line = f.readline().rstrip()