Key vocabulary

Grouping related data with records

What is a record?

SDD5 stored related attributes in separate parallel arrays, linked only by a shared index. A record takes a different approach: it groups every field describing one item — a name, a price, a stock level — into a single structured variable. In Python, a record is implemented using the @dataclass decorator, which defines a reusable template — a class — describing a record's field names once. For example, a template Item with fields name, price, and stock can then be used to create Item("Chocolate", 75, 30): one record, a single variable holding three related fields about one item, rather than three separate array elements spread across three different arrays.

Why use records instead of parallel arrays?

Because all of a record's fields live inside one structured variable, they can never become misaligned with each other in the way parallel arrays can. There is no risk of one field's array becoming a different length, or falling out of order relative to another — the fields are inseparably bundled together as a single item. This makes records the safer choice once a problem involves more than one or two attributes per item, which is exactly why records and arrays of records are named separately from parallel arrays in the Higher specification.

Declaring records and arrays of records in Python

Before defining a record template, the dataclass decorator must be imported: from dataclasses import dataclass. A record template is then written as a class, with the @dataclass decorator placed directly above it, and each field listed on its own line with a type hint, for example name: str. Once the template exists, individual records are created by calling the template's name with the field values in order, e.g. Item("Chocolate", 75, 30). An array of records is simply a list containing several such objects — one per item, in order. Every record in the list is built from the same template, so code written to process one record (for example, reading its price field) works consistently for every record in the list.

Traversing an array of records with an index

An array of records is traversed with a fixed loop in exactly the same way as a 1D array or parallel arrays: a single index variable, such as i, is used to select which record to work with — itemRecords[i]. Once a specific record has been selected using the list index, its individual fields are then accessed using dot notation, for example itemRecords[i].price. Both the index and the field name are needed together — the index picks the item, and the field name picks which piece of data about that item to read or change. This same double-lookup pattern is exactly what the standard algorithms in SDD15 rely on when they search or process arrays of records.

Worked examples

from dataclasses import dataclass

@dataclass
class Item:
    name: str
    price: int
    stock: int

tuckShopItem = Item("Chocolate", 75, 30)

print(tuckShopItem.name, tuckShopItem.price, tuckShopItem.stock)

itemRecords = [
    Item("Crisps", 60, 24),
    Item("Juice", 90, 15),
    Item("Chocolate", 75, 30),
    Item("Water", 50, 40)
]

for i in range(len(itemRecords)):
    print(itemRecords[i].name, "costs", itemRecords[i].price, "pence, stock:", itemRecords[i].stock)

itemRecords[2].stock = itemRecords[2].stock - 1

totalStock = 0
for i in range(len(itemRecords)):
    totalStock = totalStock + itemRecords[i].stock
print(totalStock)

for i in range(len(bookRecords)):
    print(bookRecords[i].title, "by", bookRecords[i].author, "— due", bookRecords[i].dueDate)

Task Set A — Core questions

from dataclasses import dataclass

@dataclass
class Book:
    title: str
    author: str

bookRecords = [
    Book("Wasp Factory", "Iain Banks"),
    Book("Room", "Emma Donoghue")
]

for i in range(len(bookRecords)):
    print(bookRecords[i].title, "by", bookRecords[i].author)

Task Set B — Extension