Giving Measurements a Place

Start with one reading, then keep three together

The equals sign assigns a value to a name. Here, north refers to one number, which we call a scalar. Square brackets with comma-separated items create a list. Putting square brackets after the list's name retrieves an item instead.

The print function displays what we give it. The len function tells us how many items the list contains. Parentheses hold the information passed to a function.

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

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

12
[12, 18, 24]
12
3

The first line is one number. The second is our collection. The third retrieves the north greenhouse's reading, and the fourth counts the entries. A list can contain other kinds of values too, but this one contains only temperatures.

Correct one entry without replacing the whole report

Suppose the middle thermometer was misread, and Botie also checks a fourth greenhouse. A list is mutable: we can change its contents after creating it. Assigning to an index replaces that item. Calling append adds an item at the end. An operation attached to an object with a dot, such as append, is called a method.

A slice retrieves a range of positions. The starting position is included and the stopping position is excluded. This example asks for positions one and two.

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

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

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

The corrected reading stays in the middle greenhouse's position. The fourth greenhouse goes at the end. Taking the slice does not remove entries from the original list. Each worked example on these pages starts with its own data, so this correction does not carry into the next example.

Give each step a name

In Python, the asterisk means multiplication. We can store the intermediate result under a name, then use it in the next instruction. This lets us inspect each step before applying the rule to all three readings.

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

print(scaled)
print(fahrenheit)

21.6
53.6

The scaled value is only an intermediate result. We must also shift the zero point before reporting Fahrenheit. Both variables here refer to single numbers, not lists.

Turn the list into a numerical array

Importing NumPy makes its tools available. The name np is a short name we choose for it. The array function takes our Python list and creates an array. The named argument dtype tells it which kind of values to store.

The dtype attribute reports that choice. The tolist method returns an ordinary Python list, which gives us a convenient way to print the entries. It does not change the array into a list in place.

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

The decimal points show the floating-point values in the returned list. The reported float64 is NumPy's 64-bit floating-point type used here. The three positions still belong to the same three greenhouses.

The same multiplication sign can do two different things

Let's multiply a list and an array by the same whole number. Before reading the output, consider what each collection is designed to do: the list supports repeating a sequence; the numerical array supports multiplying its entries.

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]

Repeating the list gives six entries. Multiplying the array gives three doubled values. If we want to calculate a new temperature for each greenhouse, we need the second behaviour.

Convert the collection and prepare it for display

Now we can apply the two conversion steps to the array. NumPy performs the arithmetic for each entry. NumPy's round function takes the result and a number of decimal places. We keep that rounded result separately, then turn it into a list for printing.

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]

We have one converted value per greenhouse. These arithmetic expressions produce new arrays, so the original Celsius readings are still available. Rounding is a display choice; it does not make floating-point arithmetic exact.

Use a dictionary when the name is how we find the reading

A dictionary associates a key with a value. Here each key is a greenhouse name, written as a quoted string of text. Its value is the temperature. Curly braces contain the entries, and a colon separates each key from its value.

A list lookup uses a position. This dictionary lookup uses a name. When we later need a numerical array, we can first request the readings in an explicit order.

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]

The dictionary is useful for looking up a named reading; the array is useful for numerical calculations across readings. Neither structure knows that these numbers are Celsius. That meaning still belongs in our variable names, labels, and explanation.