Understanding Dictionary Structure and Operations

The items() method converts a dictionary into a list of tuples, where each tuple contains one key-value pair.

Programming

From Dictionary to Tuples

A dictionary keeps keys connected to their values. Sometimes you need to handle those connections as individual units rather than as dictionary entries. The items() method provides that view of the dictionary, and list(d.items()) turns it into a list whose elements are key-value tuples. The important transformation is this: one dictionary becomes a list, and each list element preserves one key together with its value.

How does dictionary data change when items() is converted into a list?

Tracing the Transformation

Worked example

Three Entries, Three Tuples

Convert a dictionary into a list of key-value tuples and identify the shape of the result.

1
Start with the dictionary
The generated example dictionary contains the key-value pairs apple with 3, mango with 7, and zebra with 2.
2
Call items()
The dictionary's key-value pairs are exposed as items. The result is a dict_items object before it is converted into a list.
3
Convert to a list
Using list(d.items()) creates a list. Each element in that list is one tuple containing exactly two elements.
4
Inspect one tuple
For the tuple ('mango', 7), index 0 contains the key mango and index 1 contains the value 7.

Result

The result is a list of three two-element tuples: [('apple', 3), ('mango', 7), ('zebra', 2)].

What does each tuple contain, and how are its key and value connected?

Reading Insertion Order

What do you think happens?

Suppose a dictionary receives the keys b, a, and c in that order. When its items are converted to a list, will the tuples appear alphabetically or in the order the keys were added?

Alphabetically: a, b, c
Insertion order: b, a, c

Reveal answer

Answer:

Insertion order: b, a, c

The tuples returned from the dictionary appear in insertion order, meaning the order in which the keys were added. items() does not alphabetize the keys.

In what order do the key-value tuples appear, and how does that differ from alphabetical order?

This distinction matters whenever the order of the output is inspected. If apple was added after zebra, then the tuple for apple appears after the tuple for zebra, even though apple comes first alphabetically. If alphabetical order is required, the resulting list must be sorted separately; items() itself preserves insertion order rather than applying alphabetical sorting.

Using Tuples Together

The tuple format is useful because each key and its value arrive together. You can access the two parts by index, or receive the two parts as separate variables while processing one tuple at a time. This makes items() useful for iteration, for passing dictionary data to a function that expects a sequence of tuples, and for storing or transmitting the dictionary data in tuple-based form.

How does a loop receive each key-value tuple and process it one item at a time?

python

prices = {"apple": 3, "mango": 7, "zebra": 2}
pairs = list(prices.items())

for key, value in pairs:
    print(key, value)

prices = {"apple": 3, "mango": 7, "zebra": 2}
pairs = list(prices.items())

for key, value in pairs:
    print(key, value)

Output

apple 3
mango 7
zebra 2

In this example, list(prices.items()) creates the tuple-based list. The loop receives one two-element tuple at a time and assigns its index-0 key to key and its index-1 value to value. The displayed order follows the order in which the entries were added to the dictionary.

Mistakes with items()

Common mistake
Assuming items() sorts keys alphabetically
What it looks like
Expecting apple, mango, zebra to be ordered alphabetically merely because items() was called
Why it fails
The tuples follow insertion order, not alphabetical order.
Do this instead
Check the order in which keys were added. Sort the resulting list separately if alphabetical order is required.
Common mistake
Treating one item tuple as a one-element structure
What it looks like
Reading ('mango', 7) as though it contains only the key
Why it fails
Each item tuple contains exactly two elements: the key at index 0 and the value at index 1.
Do this instead
Use both positions when interpreting the tuple: index 0 is the key, and index 1 is the value.
Common mistake
Calling the result of items() an actual list without conversion
What it looks like
Assuming d.items() and list(d.items()) have the same list type
Why it fails
items() produces a dict_items object. list(d.items()) converts that result into an actual list.
Do this instead
Use list(d.items()) when you need a list that can be stored, printed, or passed to a function.

Practice and Summary

EASY

A dictionary receives the entries zebra with 1, apple with 4, and mango with 9 in that order. Describe the result of list(d.items()). Then identify the key and value at index 0 and index 1 of the tuple for apple.

Hints

Use insertion order, not alphabetical order.
Each tuple has exactly two elements.
The key is at index 0 and the value is at index 1.

Your attempt (not saved)

1
items() exposes a dictionary's key-value pairs, and list(d.items()) converts them into an actual list. Each list element is an immutable tuple with exactly two elements: the key at index 0 and the value at index 1. The tuples appear in dictionary insertion order, not alphabetical order. This format keeps each key connected to its value and supports iteration, storage, and passing dictionary data to functions that expect a sequence of tuples.

At a glance

Use items() to work with a dictionary's key-value pairs.
Use list(d.items()) to create an actual list of two-element tuples.
In each tuple, index 0 is the key and index 1 is the value.
The tuples follow insertion order rather than alphabetical order.
Tuple-based pairs are useful for iteration, storage, and passing dictionary data to functions.

Related concepts

Iteration in Python

More concepts starting with U