Multi-item Variables

So far, each variable has stored exactly one value. In practice, we constantly work with groups of values that belong together, such as coordinate pairs, lists of cities, or sets of unique IDs.

In this chapter, you will learn how Python stores multiple values in one variable (often called collections or data structures) and how to choose the right one for your spatial workflows.

1. The Four Built-in Collections¶

Python provides four built-in collection types that we will use throughout the course. We will explore each in detail, but keeping this summary handy will help you navigate them:

Choosing the right collection type improves the clarity and correctness of your code.

2. Lists: Ordered and Changeable¶

Lists are the workhorse data structure in Python, written using square brackets []. They are designed to store ordered sequences of values, meaning Python will always preserve the exact order in which you added the items. Crucially, lists are mutable; you can seamlessly add, remove, or alter individual elements long after the list is created, making them ideal for datasets that grow or change over time.

For example, imagine we are recording a sequence of elevations (in meters) along a hiking transect:

Accessing and Slicing Lists¶

You can retrieve individual values using their numeric index position, always starting at 0. You can also extract a segment (or “slice”) of the list using a colon :. This is highly useful for isolating specific chunks of a spatial profile or time series without modifying the original data.

Building Lists Dynamically¶

In spatial data science, you rarely type out lists manually. Instead, you often start with an empty list and populate it dynamically as you process data (for example, reading coordinates from a file one by one).

Modifying and Expanding Lists¶

Because lists are mutable, you can change their contents in place. You can overwrite existing values using their index, or dynamically add new measurements to the transect using methods like .append(), .insert(), and .extend(). You can even combine two separate lists using the + operator.

Removing and Organizing Items¶

Python also provides built-in methods to clean and organize your lists. You can remove items by their specific value (.remove()), or by their index position (.pop() or del). Once your data is clean, you can reorganize it using .sort() or .reverse(). To check how many items remain in your list, use the len() function.

Lists can be sorted in place. You can sort them normally, in reverse, or just flip the current order entirely.

3. Tuples: Ordered and Fixed¶

Tuples look and behave very similarly to lists, but with one absolute difference: they are immutable. Once a tuple is created using parentheses (), its contents can never be changed, added to, or removed.

You use tuples when values represent a single logical entity that should be permanently protected. The most common geospatial example is a coordinate pair (latitude, longitude) or a bounding box. Modifying half of a coordinate pair accidentally would ruin your spatial analysis, so storing it as a tuple makes your intention strictly clear: this group of values is fixed.

Combining and Unpacking Tuples¶

While you cannot alter the contents of a tuple, you can combine two tuples together using the + operator to create a brand new tuple (for example, combining bbox_min and bbox_max into a single bounding box).

Tuples also offer a highly readable feature called “unpacking.” Unpacking allows you to extract the contents of a tuple into distinct variables in a single, elegant line of code.

The List Workaround¶

Sometimes you start with a tuple but later realize the data actually does need to change. Because you cannot change the tuple directly, the standard workaround is to convert it to a list using list(), modify the list, and then convert it back to a tuple using tuple().

If you find yourself converting tuples to lists often, you likely chose the wrong data structure to begin with. Use a list from the start!

4. Sets: Unique Values Only¶

Sets are designed for one main purpose: answering the question, “Is this value present or not?” Written with curly brackets {}, sets automatically discard duplicates and entirely ignore order. They are not sequences; they are purely collections of unique elements.

This makes sets the absolute best choice when you need to extract unique categories from messy data, such as identifying the distinct land cover classes in a regional survey.

Modifying Sets and Membership Testing¶

Because sets ignore order, you cannot access their items using an index (e.g., unique_classes[0] will fail). However, the trade-off is incredible speed. Checking if a specific value exists inside a set using the in keyword is significantly faster than checking a list. You can easily add items, update the set with multiple new items, or remove them.

When removing items, Python gives you two choices: .remove() will throw an error if the item doesn’t exist, while .discard() will silently ignore the request if the item is missing.

5. Dictionaries: Named Values¶

Dictionaries store data as key-value pairs. Instead of looking up a value by its numerical position (like in a list), you look it up using a meaningful name (the “key”).

Dictionaries are the backbone of attribute data in Python. Whenever you need to represent the properties of a real-world object—such as the metadata of a weather station, the configuration settings of an algorithm, or a GeoJSON feature—a dictionary is the correct choice.

Accessing, Modifying, and Safe Lookup¶

You retrieve values by passing the exact string name of the key inside square brackets []. If you need to update an attribute or add a completely new one, you simply assign a new value to that key.

If you try to access a key that does not exist using square brackets (e.g., station["precipitation"]), Python will raise a KeyError. When working with real-world datasets that might have missing attributes, it is much safer to use the .get() method. It allows you to request a key and provide a default fallback value just in case the key is missing.

Advanced Dictionary Methods¶

Dictionaries come with powerful methods to manage their contents and explore their structure. You can update multiple key-value pairs at once using .update(). When you want to explore the dictionary without knowing the keys in advance, you can use views: .keys() shows all the labels, .values() shows the raw data, and .items() shows both together as tuples.

If you need to remove data, you have multiple options depending on your needs.

Concept Check: The Nested Weather Record¶

You are tracking daily temperature readings for a specific weather station and have organized the data into the following nested structure:

weather_record = {
    "station_name": "Zurich",
    "temperatures_C": [12.5, 14.1, 13.8, 15.2]
}

You want to extract the last temperature reading recorded (15.2). Which code snippet successfully achieves this?

A) weather_record[-1]["temperatures_C"]

B) weather_record["temperatures_C"][-1]

C) weather_record["temperatures_C"]

6. Indexing and Referencing¶

To work with values stored inside collections, Python relies heavily on indexing and referencing. While all collections use square brackets [] to retrieve data, what goes inside the brackets depends on the collection:

• Lists and Tuples: Use numeric positions (elevations_m[0]).

• Dictionaries: Use named keys (station["name"]).

• Sets: Do not support brackets at all!

Multi-dimensional Collections (Nesting)¶

Collections can easily contain other collections. This is called nesting, and it is how we build multidimensional matrices (like grids of pixels or lists of coordinates). To access data buried inside nested collections, you simply chain the brackets together. Python evaluates indexing one level at a time, from the outside in.

You do not need special syntax for higher dimensions; you just keep applying brackets for each level you want to drill into.

7. Copying vs Referencing Collections¶

How Python handles assignment (=) depends entirely on the type of data you are working with. This subtle difference is one of the most common sources of bugs in data science.

When you assign a single value (like an integer or string) to a new variable, Python creates an independent copy. However, when you assign a mutable collection (like a list, dictionary, or set) to a new variable, Python does not create a copy. Instead, it creates a shared reference: both variables now point to the exact same object in computer memory.

Because Python wants to save memory and processing time, it assumes you just want two name tags (list_a and list_b) pointing at the same underlying box of data.

Equality (==) vs Identity (is)¶

This distinction is why Python has two different comparison operators. == checks if two variables have the same value inside them. is checks if they are literally the same object in memory. list_a is list_b will return True, because they are the same underlying object!

Making an Independent Copy¶

If you actually want a separate, safe backup of a collection before you manipulate it, you must explicitly tell Python to clone the memory block using .copy() or by wrapping it in the collection constructor (e.g. list()).

Concept Check: The Shared Memory Trap¶

You are organizing a list of sample coordinates and want to create a backup before making changes. You write the following code:

original_samples = [12, 15, 18]
backup_samples = original_samples

original_samples.append(21)

If you print backup_samples right now, what will Python output?

A) [12, 15, 18]

B) [12, 15, 18, 21]

C) [12, 15, 18], [21]

8. Short Exercise¶

You have received raw field information and need to organise it into the appropriate data structures so it can be used reliably later.

Given Data¶

Task¶

1. Create a set called unique_cities from raw_cities to remove duplicates.

2. Convert that set back into a sorted list called cities_sorted (Hint: use sorted(unique_cities)).

3. Build a final dictionary called station_record with the following keys:

• "name" → extract this from raw_attributes

• "coordinates" → the coordinate tuple

• "cities" → the sorted list you just made

• "discharge_m3s" → extract this from raw_attributes using .get(), defaulting to "not available"

1. Use an f-string to print the station name and its latitude (index 0 of the coordinate tuple) from your new dictionary.

# 1 & 2) Remove duplicates and sort
unique_cities = set(raw_cities)
cities_sorted = sorted(unique_cities)

# 3) Build a structured station record
station_record = {
    "name": raw_attributes["station"],
    "coordinates": coords,
    "cities": cities_sorted,
    "discharge_m3s": raw_attributes.get("discharge_m3s", "not available")
}

# 4) Extract and print from the structured dictionary
lat = station_record["coordinates"][0]
name = station_record["name"]

print(f"Station {name} is located at latitude {lat}.")

9. Summary¶

After completing this chapter, you should understand that:

• Lists ([]) are ordered and changeable, serving as the workhorse for sequential data.

• Tuples (()) are ordered and permanently fixed, ideal for protecting coordinate pairs.

• Sets ({}) store unique values and ignore duplicates, making them perfect for extracting distinct categories.

• Dictionaries ({key: value}) store data using named labels instead of numeric index positions, forming the backbone of attribute records.

• Collections are referenced, not copied. Assigning a list to a new variable just creates a second name tag for the same data in memory. To create a true independent clone, you must explicitly call .copy().

This summary table features the most relevant functions and methods introduced in the chapter.

What Comes Next¶

So far, you have learned how to store and access single and multiple values. However, doing calculations manually on every item in a list of 10,000 coordinates is impossible.

In the next lesson (after the practical), we will introduce Loops and Conditional Logic, which will allow your code to automate tasks, make decisions, and process massive lists of data in milliseconds.