Tuples: Creating, Unpacking, and Using Immutable Sequences

From Entries to Tuples

A dictionary stores information as key-value pairs. The items() method makes those relationships available as tuple-based entries. When you use list(d.items()), the result is a list in which every element is a tuple containing one key and its corresponding value.

Tracing the Conversion

prices = {
    "mango": 4,
    "apple": 2,
    "zebra": 7
}

pairs = list(prices.items())
print(pairs)

[("mango", 4), ("apple", 2), ("zebra", 7)]

The call to items() exposes the dictionary's key-value pairs, and list() creates an actual list that can be stored, printed, or passed to a function. Each list element is a tuple. The order follows the order in which the keys were added: mango first, apple second, and zebra third.

Inside Each Pair

Every tuple produced from a dictionary item contains exactly two elements. The key is at index 0, and the value is at index 1. This fixed structure lets you retrieve the two parts with ordinary tuple indexing.

pair = ("apple", 2)
key = pair[0]
value = pair[1]

In this example, pair[0] refers to the key and pair[1] refers to the value. The positions are not interchangeable: using index 1 when you need the key would retrieve the value instead.

Insertion Order Matters

The tuples appear in insertion order, meaning the order in which the dictionary's keys were added. This is different from alphabetical order. A key that comes later alphabetically can still appear earlier in the list if it was added earlier to the dictionary.

Unpacking During Iteration

Because every item is a two-element tuple, its key and value can be unpacked into two variables during iteration. The first variable receives the key at index 0, and the second variable receives the value at index 1.

prices = {
    "mango": 4,
    "apple": 2
}

for key, value in prices.items():
    print(key, value)

mango 4
apple 2

On the first iteration, the tuple for mango is unpacked so that key refers to mango and value refers to 4. On the next iteration, the variables receive the key and value from the next tuple. This is useful when processing both parts of every dictionary entry together.

Immutable Pair Records

Each item tuple is immutable. Once the tuple has been created, its two elements cannot be changed. This fixed structure makes a tuple suitable for representing a key-value relationship that should remain together as one pair.

The important idea is that immutability applies to the tuple's contents after creation. The tuple can be stored in a list, passed to a function, or unpacked for iteration, but its key and value positions are fixed.

Mistakes to Avoid

• Expecting items() to sort keys alphabetically

  The tuples follow dictionary insertion order, not alphabetical order.

  Fix: Treat the order as the order in which the keys were added. Sort the resulting data separately if alphabetical order is needed.

• Treating each returned item as a single value

  Each item is a tuple with exactly two elements: the key at index 0 and the value at index 1.

  Fix: Use two variables when unpacking, or use index 0 for the key and index 1 for the value.

• Assuming items() itself has already produced a stored list

  The source distinguishes the dict_items result from the actual list created by wrapping the call with list().

  Fix: Use list(d.items()) when you need a list of the key-value tuples.

Practical Uses

Use items() when a task needs keys and values together. Iteration is one common use: each tuple can be unpacked into a key variable and a value variable. Converting with list(d.items()) is useful when the tuple-based data must be stored, printed, or passed to a function that expects a sequence of tuples.

Practice Check