Variables, constants and data structures

What you'll learn

• Why algorithms need variables and constants
• How to follow algorithms by tracking changing values
• How strings, records and arrays organise data
• How to write simple algorithms using one-dimensional and two-dimensional structures

Algorithms work with data

An algorithm is a precise set of steps for solving a problem. In GCSE Computer Science, algorithms often use stored data: numbers, text, true/false values, or collections of related values.

A data type is the category of a value, such as an integer, real number, string or Boolean. The data type affects what operations make sense. For example, you can add two integers, but you would normally concatenate, or join, two strings.

In this topic, you are not just memorising names. You need to be able to follow algorithms that use stored data, and write algorithms that choose suitable ways to store that data.

Variables

A variable is a named storage location whose value can change while an algorithm runs. The name of a variable is an identifier: a meaningful label such as score, total or player_name.

In Python 3, assignment uses =:

score = 0
score = score + 1

This does not mean “score is mathematically equal to score plus 1”. It means: calculate the right-hand side first, then store the result back into score.

You often need to initialise a variable, which means giving it a starting value before it is used.

total = 0
total = total + 6
total = total + 4
average = total / 2

Constants

A constant is a named value that should not change while the algorithm runs. Constants are useful for fixed values such as a pass mark, VAT rate, maximum number of attempts, or board size in a game.

In Python, constants are usually written in capitals by convention:

PASS_MARK = 50
MAX_ATTEMPTS = 3

Python does not physically stop you changing them, but using capitals tells the programmer: “this value should stay fixed”.

PASS_MARK = 50
percentage = 47 / 60 * 100

if percentage >= PASS_MARK:
    result = "pass"
else:
    result = "fail"

Data structures

A data structure is a way of organising multiple pieces of data so an algorithm can use them efficiently.

If a class has 30 test scores, it would be poor design to create variables called score1, score2, score3 and so on. A data structure lets you store the scores together and process them using loops.

This diagram shows the main structures you need for this section.

Strings

A string is a sequence of characters. A character is a single letter, digit, symbol or space. Examples of strings include "GCSE", "Alex" and "Room 12".

Each character in a string has a position called an index. In Python, indexing starts at 0:

word = "GCSE"

So:

• word[0] is "G"
• word[1] is "C"
• word[2] is "S"
• word[3] is "E"

You can also find the length of a string using len(word).

first_name = "Mina"
surname = "Patel"
initials = first_name[0] + surname[0]

Records

A record stores related pieces of data about one thing. Each part of the record is called a field.

For example, a student record might contain a name, age and grade. These fields can have different data types.

In Python, a dictionary is often used to represent a record:

student = {
    "name": "Alex",
    "age": 16,
    "grade": 7
}

You access a field by its field name:

student["name"]

Records are useful when the data belongs together. A student’s name, age and grade describe the same student, so they make sense as one record.

student = {"name": "Alex", "attendance": 96, "points": 12}

if student["attendance"] >= 95:
    student["points"] = student["points"] + 5

One-dimensional arrays

An array is an ordered collection of values. Each value is called an element, and each element is accessed using an index.

In Python, a list is used like an array:

scores = [12, 15, 9, 18]

Using Python indexing:

• scores[0] is 12
• scores[1] is 15
• scores[2] is 9
• scores[3] is 18

Arrays are useful when you want to apply the same process to lots of values, such as finding a total, searching for a value, or finding the highest score.

scores = [12, 15, 9, 18]
highest = scores[0]

for score in scores:
    if score > highest:
        highest = score

Two-dimensional arrays

A two-dimensional array stores data in rows and columns, like a table or grid. Each element is accessed using two indexes: one for the row and one for the column.

In Python, a two-dimensional array can be represented as a list of lists:

grid = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

Using Python indexing:

grid[0][0]  # 1
grid[1][2]  # 6
grid[2][1]  # 8

The first index chooses the row. The second index chooses the column.

rainfall = [
    [2, 0, 1],
    [3, 1, 4]
]

total = 0

for row in range(2):
    for column in range(3):
        total = total + rainfall[row][column]

Choosing the right structure

Use the simplest structure that matches the problem:

Following and writing algorithms

When you follow an algorithm, track the value of each variable as it changes. For arrays and strings, pay close attention to indexes. For records, pay attention to field names.

When you write an algorithm, think about:

• what data needs to be remembered
• whether any values should be constants
• whether repeated data should be stored in an array
• whether related fields should be grouped in a record
• whether the data is a list or a grid