How do I preserve item-to-item pairings when combining two lists?

Use zip() to pair the items at corresponding positions. For example:

names = ["Ari", "Bea", "Cal"]
scores = [82, 91, 77]
pairs = list(zip(names, scores))
print(pairs)

The result is:

[('Ari', 82), ('Bea', 91), ('Cal', 77)]

Each tuple keeps a name beside the score from the same position. This assumes both lists are already in the intended order: zip() pairs by position, not by searching for matching values or labels. Python’s documentation describes zip() as iterating over inputs in parallel and producing tuples from corresponding positions. [S1]

If you want to process the pairs rather than save them as a list, you can also loop directly:

for name, score in zip(names, scores):
    print(name, score)

Use list(zip(...)) when you want to inspect or keep the resulting pairs as a list.

Ordinary zip() stops as soon as the shorter input is exhausted. Any remaining items in a longer list are left out of the result. [S1] For example:

names = ["Ari", "Bea", "Cal"]
scores = [82, 91]
print(list(zip(names, scores)))

The output is:

[('Ari', 82), ('Bea', 91)]

"Cal" has no paired score, so it does not appear in the output. The important distinction is that ordinary zip() does not check for this length mismatch by default; a short result can look valid even when an item was omitted. [S1]

Before relying on the pairs, decide what the lengths mean for your task. If extra items are expected and can be ignored, ordinary zip() may suit that purpose. If every item must have a partner, use the strict option or check your data before processing.

Pass strict=True when equal lengths are a requirement:

names = ["Ari", "Bea", "Cal"]
scores = [82, 91]
pairs = list(zip(names, scores, strict=True))

The strict option checks that the input iterables have equal lengths; ordinary zip() instead truncates at the shortest input without that check. [S1] This makes the equal-length requirement explicit in the code. Use it when every item must have a counterpart; use ordinary zip() when stopping at the shorter input is acceptable.

The documentation describes what zip() does, but it does not determine which policy is right for your lists. That depends on whether unmatched items are acceptable for your task.

Here is a pattern for lists that are intended to match item for item:

labels = ["Ari", "Bea", "Cal"]
values = [82, 91, 77]

pairs = list(zip(labels, values, strict=True))
for label, value in pairs:
    print(f"{label}: {value}")

Expected output:

Ari: 82
Bea: 91
Cal: 77

This assumes that labels and values are in the same intended order and should have equal lengths. If unequal lengths are acceptable, omit strict=True, but remember that ordinary zip() leaves unmatched trailing items out of the result. [S1] zip() is lazy, so wrapping it in list() makes the pairs visible as a list. [S1]