How does a game turn 135 seconds into 2:15 on its timer?

Variables, constants, input and output

• A variable is a named memory location whose value can change while the program runs.
• A constant is a named value that cannot change while the program runs. Naming it means one place to update it, and clearer code.
• Assignment puts a value into a variable; the first assignment is initialisation. Use meaningful identifiers like lives, not x.

MAX_LIVES = 3
lives = MAX_LIVES
name = input("Enter your name: ")
print("Good luck, " + name)
lives = lives - 1
print(lives)

Data types

• A data type tells the computer what kind of data a variable holds and which operations make sense.

• In Python these are int, float, bool and str (a character is a str of length 1).

Arithmetic operators

• +, - and * work as in maths. Real division / can give a fractional answer.
• Integer division gives only the whole-number part. The remainder (modulus) is what is left over.

total = 200
minutes = total // 60    # 3
seconds = total % 60     # 20

Casting

• Casting converts a value from one data type to another, e.g. the string '15' to the integer 15.
• Keyboard input usually arrives as a string, so cast it before doing arithmetic.
• Cast numbers to strings to join them into a message.
• Python: int(), float(), str(), bool().

age = int(input("Enter your age: "))
print(age + 1)
print("Next year: " + str(age + 1))

How can a few lines of code print all 100 times-table answers?

Sequence and selection

• Sequence: statements run one after another, in order.
• Selection: a condition that is true or false decides which block of code runs.
• Compare with <, >, <=, >=, equal to == and not equal to !=.
• Join conditions with and, or, not.

mark = 72
if mark >= 70:
    print("Distinction")
elif mark >= 40:
    print("Pass")
else:
    print("Fail")

Count-controlled loops

• Repetition repeats a block of code.
• A count-controlled loop repeats a fixed number of times. A counter variable goes up by 1 each time unless a step is given.
• range(1, 6) stops before 6, so the loop runs for 1, 2, 3, 4, 5.

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

All output 3, 6, 9, 12, 15.

Condition-controlled loops

• A condition-controlled loop repeats until a condition changes, so you need not know the number of passes.
• A WHILE loop tests the condition at the start: it may run zero times.

total = 1
while total < 50:
    total = total * 2
print(total)

All output 64.

Nesting

• Nesting puts one construct inside another: an IF inside a loop, a loop inside an IF, or a loop inside a loop.
• With nested loops, the inner loop runs in full for every pass of the outer loop.
• Total passes of the inner block = outer passes × inner passes.

for row in range(1, 4):
    for col in range(1, 4):
        print(row * col)

Output: 1, 2, 3, 2, 4, 6, 3, 6, 9 (9 values).

How can one name hold all 9 squares of a noughts and crosses board?

Arrays

• An array is a data structure: it stores many values under one identifier. Each value is an element.
• All elements have the same data type.
• An index picks out one element. The first element has index 0.
• Python uses a list as an array.

scores = [12, 7, 9, 15, 4]
print(scores[1])      # 7
scores[3] = 20        # 15 becomes 20

Looping through an array

• Use a variable as the index in a count-controlled loop to visit every element in turn.
• The counter runs from 0 to length − 1.
• You can also loop over every item directly: for t in temps:, which Edexcel calls iteration.

temps = [18, 21, 17, 22, 19]
total = 0
for i in range(len(temps)):
    total = total + temps[i]
print(total)

All output 97.

2D arrays

• A two-dimensional (2D) array is like a table: one identifier, with rows and columns.
• Each element needs two indexes: board[row][col] (row first here).
• A noughts and crosses board is a 3 × 3 2D array of characters.

board = [[" ", " ", " "],
         [" ", " ", " "],
         [" ", " ", " "]]
board[1][1] = "X"    # centre square
board[2][0] = "O"    # bottom-left square

Records

• A record groups related data about one item under one name.
• Each item of data in a record is a field. Fields can have different data types.
• Compare: an array's elements all share one data type, but a record mixes types.

Records in code

• The PLS stores a record as a list of mixed types; reach a field by its index. A list of records is a 2D structure, and every record has the same number of fields.

# record fields: name, species, age, weight
myPet = ["Biscuit", "dog", 4, 12.5]
myPet[2] = 5
print(myPet[0])       # Biscuit
pets = [["Biscuit", "dog", 5, 12.5],
        ["Pip", "cat", 2, 4.1]]
print(pets[1][0])     # Pip

Two subroutines both use a variable called total. Why no clash?

Subroutines

• A subroutine is a named, out-of-line block of code. It runs when you call it by its name, then control returns to the line after the call.
• A procedure carries out a task. A function carries out a task and returns a value.
• Your board calls subroutines subprograms.

def welcome():
    print("Welcome to the quiz")

welcome()
welcome()

Parameters and return values

• A parameter passes data into a subroutine when it is called. Values are matched to parameters in order.
• A function sends its result back with return. The returned value replaces the call, so store it or use it straight away.

def area(width, height):
    result = width * height
    return result

roomArea = area(4, 5)
print(roomArea)    # 20

Local and global variables

• A local variable is declared inside a subroutine: it only exists while that subroutine runs and is only usable inside it.
• A global variable is declared in the main program and can be used anywhere.
• Good practice: nothing outside can change a local variable, and its name can be reused elsewhere.

bonus = 5                       # global variable
def addBonus(score):
    newScore = score + bonus    # local variable
    return newScore

print(addBonus(10))    # 15
print(newScore)        # error: newScore does not exist here

Why use subroutines?

• Reuse: write code once and call it many times, so there is less to write and check.
• Decomposition: each subroutine solves one part and can be written and tested on its own.
• Maintenance: fix or improve the code in one place.
• Library routines are ready-made subroutines, e.g. len(), random.randint().
• Each code block and subprogram should have a single entry and exit point.

How does an app show only the last 4 digits of your card number?

Strings have positions

• A string is a sequence of characters. Each character has a position, its index.
• The first character is at index 0, so the last is at length − 1.
• The length of a string is how many characters it holds, spaces included.
• A card number is stored as a string, not an integer: it is never used in arithmetic.

card = "4929123456789012"
print(len(card))
# prints 16

Taking a substring

• A substring is part of a string, picked out by position.
• Slicing: string[start:stop] takes from index start up to, but not including, stop.
• Using the length makes the code work for any card length.

card = "4929123456789012"
last4 = card[len(card) - 4:len(card)]
print("****" + last4)

More string tools

• Concatenation joins strings with +.
• Position: "keyboard".find("b") gives 3, the index of the first "b" (−1 if not found).
• Case conversion: .upper() and .lower(), e.g. "Hi".upper() gives "HI".

Random numbers

• Games, quizzes and simulations need unpredictable values, such as a dice roll.
• The range you give includes both ends: (1, 6) can give 1, 2, 3, 4, 5 or 6.

import random
dice = random.randint(1, 6)
print(dice)

Reading and writing files

• Variables are lost when a program ends. A file in secondary storage keeps data, such as high scores, for next time.
• Open the file, read or write it, then close it so the data is saved and the file is freed.
• Files are comma separated values (CSV): use "r" to read, "w" to write a new file and "a" to append, then split(",") each line into fields.

file = open("scores.csv", "a")
file.write("Zara,42\n")
file.close()
file = open("scores.csv", "r")
for line in file:
    fields = line.strip("\n").split(",")
    print(fields[0] + " scored " + fields[1])
file.close()

Big ideas

• A variable is a named memory location whose value can change; a constant keeps one value while the program runs.
• Choose the data type that fits the data: integer, real, Boolean, character or string, and cast between types when needed (input text to an integer).
• Integer division gives the whole-number part; the remainder (modulus) gives what is left over.
• Sequence runs statements in order; selection uses a true/false condition to choose a branch.
• Count-controlled loops repeat a fixed number of times; condition-controlled loops repeat until a condition changes.
• In nested loops the inner loop runs fully for every pass of the outer loop.
• An array holds many values of one data type under one identifier; an index picks out an element (the first is index 0).
• A 2D array is a table of rows and columns, so each element needs two indexes.
• A record groups fields of different data types about one item.
• A subroutine is a named block of code called by its name; a function returns a value and a procedure does not.
• Parameters pass data in, in order; return passes a result back to the call.
• Local variables exist only inside their subroutine while it runs, so the same name can be reused safely; global variables can be used anywhere.
• A string is a sequence of characters, each with an index; the length is how many characters it has. Indexes start at 0.
• A substring picks out part of a string by position.
• Concatenation joins strings with +.
• Files keep data after a program ends: open, read or write, close.
• Random number functions give a value in a range, including both ends.