Giving Measurements a Place

Suppose Botie checks three greenhouses each morning. Today the thermometers read 12, 18, and 24 degrees Celsius. We can write those readings on paper, but a program needs them in a form it can work with.

Let's start with one reading, then work out how to keep all three together. Python gives us several ways to organise information. We will see why a list is useful for keeping entries in order, a dictionary is useful for finding a named reading, and a NumPy array is useful for calculating with the readings.

A conversion is only useful if we still know whose reading it is. Change a Celsius value below and follow that position through the multiplication and addition.

Suppose we only had one thermometer. We could keep its reading under one name and use that name whenever we needed the temperature. Now suppose Botie has a hundred thermometers. Giving every reading its own variable would make even a simple calculation tedious. We need a way to keep related readings together.

A data structure is a way of organising information so that we can find it and work with it. Python gives us several choices. We will start with a list, which keeps items in a sequence. The position of an item is called its index.

Position:      0    1    2
Greenhouse: North Middle South
Celsius:      12   18   24

Positions start at zero. Position zero identifies the first reading; it does not mean that the temperature is zero. We have decided that the first position belongs to the north greenhouse.

north = 12
readings = [north, 18, 24]

print(north)
print(readings)
print(readings[0])
print(len(readings))

12
[12, 18, 24]
12
3

readings = [12, 18, 24]
readings[1] = 19
readings.append(21)

print(readings)
print(readings[1:3])

[12, 19, 24, 21]
[19, 24]

Before asking Python to calculate for a whole collection, let's work through one reading. Celsius and Fahrenheit use different sized degrees and different zero points. We first multiply by the scale between their degree sizes. Then we add the offset between their zero points.

North:  (12 × 1.8) + 32 = 53.6
Middle: (18 × 1.8) + 32 = 64.4
South:  (24 × 1.8) + 32 = 75.2

These are three separate conversions. We are changing the units of each observation, so we still need one answer per greenhouse.

celsius = 12
scaled = celsius * 1.8
fahrenheit = scaled + 32

print(scaled)
print(fahrenheit)

21.6
53.6

Our list keeps the readings together, but Python does not interpret every list operation as arithmetic on its entries. We need a numerical collection whose operations have that meaning. NumPy supplies one: the array, whose Python type is called ndarray.

For the ordinary numerical arrays in these lessons, every entry uses the same data type, or dtype. Integers store whole numbers. Floating-point numbers allow fractional readings, although many decimals are represented approximately. The data type describes how values are stored; it does not record their units.

We will explicitly request floating-point storage because temperatures and their conversions may contain fractions.

import numpy as np

readings = [12, 18, 24]
celsius = np.array(readings, dtype=float)

print(celsius.tolist())
print(celsius.dtype)

[12.0, 18.0, 24.0]
float64

import numpy as np

readings = [12, 18, 24]
celsius = np.array(readings)

print(readings * 2)
print((celsius * 2).tolist())

[12, 18, 24, 12, 18, 24]
[24, 36, 48]

import numpy as np

celsius = np.array([12, 18, 24], dtype=float)
scaled = celsius * 1.8
fahrenheit = scaled + 32
displayed = np.round(fahrenheit, 1)

print(displayed.tolist())
print(celsius.tolist())

[53.6, 64.4, 75.2]
[12.0, 18.0, 24.0]

A plausible number is not enough. We need the right units, the right order, and the right number of results. A familiar reference temperature helps us check the conversion.

Freezing point: (0 × 1.8) + 32 = 32
Boiling point at standard atmospheric pressure: (100 × 1.8) + 32 = 212

There is another question our array cannot answer on its own: which entry belongs to which greenhouse? We must keep that information with the report.

by_greenhouse = {
    "north": 12,
    "middle": 18,
    "south": 24,
}

print(by_greenhouse["north"])
ordered_readings = [
    by_greenhouse["north"],
    by_greenhouse["middle"],
    by_greenhouse["south"],
]
print(ordered_readings)

12
[12, 18, 24]

Suppose Botie wants to double three temperature differences. We put the numbers in a Python list and multiply by two. That sounds reasonable, but Python repeats the list instead of doubling its entries. Why? A list stores references to objects, and its multiplication operation means repeat the collection.

A NumPy array gives multiplication a different meaning: apply it to each entry. We will see both results below. Lists are useful while collecting entries, including records of different lengths. For a rectangular numerical table, an array lets us give the entries a common data type and calculate across them.

import numpy as np
readings = [2, 3, 5]
print(readings * 2)
array = np.array(readings, dtype=float)
print((array * 2).tolist())
print(array.shape, array.dtype.kind)

[2, 3, 5, 2, 3, 5]
[4.0, 6.0, 10.0]
(3,) f

Botie saves his readings under another variable name, then changes one value. Both names now show the change. Assignment gave the existing array another name; it did not make a second array.

If we want to keep the original while trying a correction, we need copy. Give the saved copy a name that tells us what it holds. Later we will look at views, which can also share data, but here we have only one array with two names.

original = np.array([12., 18.])
alias = original
saved = original.copy()
alias[0] = 99
# original is now [99., 18.]; saved is still [12., 18.]

Before building a table, decide whether a row means a greenhouse, a day, or a sensor event. Keep identifiers alongside it. If a sensor has no reading for one day, silently shortening that row does not produce the same measurement table.

A regular numerical array needs a consistent layout. Represent a missing measurement explicitly, or keep irregular records in a more suitable structure until they can be aligned. The array's shape describes the storage layout. Our record of the row and column meanings gives that layout its interpretation.