Row-Wise Intersection of 2D Lists in Python Using zip: Align Rows and Avoid Nested-Loop Bugs

Learn how to intersect 2D lists row-wise in Python: align B and C with zip, require matches in both, use set intersections, and avoid naive nested loops.

When matching values across multiple lists, row alignment matters. A classic mistake is to iterate over every possible pair of rows, which silently breaks the constraint “same row in B and C.” Below is a compact guide showing how to intersect three 2D lists row-wise and collect only those values that meet the constraint for B and C at the same index.

The setup

We start with three 2D lists. The goal is to look at each row of the first list and find values that also appear in the corresponding rows of the second and third lists, with B and C matched by index. Only rows where both intersections are non-empty should contribute to the result.

data_a = [
    [11, 27, 41, 42],
    [7, 26, 34, 36],
    [8, 22, 24, 38, 42]
]
data_b = [
    [11, 42],
    [11, 32],
    [7, 14],
    [11, 17, 21],
    [21, 38],
    [11, 42, 45]
]
data_c = [
    [15, 16, 21, 27, 38, 44],
    [34, 39, 42],
    [20, 21, 35, 36, 49],
    [2, 12, 22, 24, 30],
    [21, 22, 27, 31, 42],
    [1, 5, 8, 27, 32, 38]
]

The naive attempt and what goes wrong

A straightforward but incorrect approach is to triple-nest the loops, intersect each row of A with each row of B and each row of C, then union the results whenever something matches. That breaks the “same row” constraint because every row of B is combined with every row of C.

hits = []
for row_x in data_a:
    for row_y in data_b:
        for row_z in data_c:
            s_x = set(row_x)
            s_y = set(row_y)
            s_z = set(row_z)
            combo = (s_x & s_y) | (s_x & s_z)
            if len(combo) > 0:
                hits.append(list(combo))
# This collects matches where A intersects with B or C across all row pairs,
# not just aligned rows, which is not what we want.

Why this fails

The requirement reads: if A finds a match in B in row k, it must be row k in C as well. That means B and C must be traversed in lockstep by index. The nested loops above pair every row in B with every row in C, throwing away row alignment. There is another subtlety: a valid result requires a match in both B and C, not in only one of them, so a simple union of intersections and a non-empty check are not sufficient. Finally, checking len on a set is unnecessary when a truthiness check is enough.

The fix: iterate B and C together and require both intersections

The clean way to preserve row alignment is to iterate B and C simultaneously, using zip. For each row of A, compute its intersections with the aligned rows of B and C, ensure both are non-empty, and then merge them.

results = []
for row_a in data_a:
    for row_b, row_c in zip(data_b, data_c):
        s_a = set(row_a)
        inter_b = s_a.intersection(row_b)
        inter_c = s_a.intersection(row_c)
        if inter_b and inter_c:
            results.append(list(inter_b | inter_c))
print(results)

This produces the following output:

[[27, 42, 11], [42, 11], [27, 42, 11], [36, 7], [42, 38], [42, 38, 22], [8, 42, 38]]

As noted elsewhere, there was an extra bracket and a missed [36, 7] in the initially stated expected output. The corrected result is shown above.

A note on dimensions

Despite being introduced as “3d list,” A, B and C are each 2D lists. The matching logic here proceeds row-wise within each, aligning rows of B and C by index.

Additional implementation details

When checking whether an intersection is empty, using the set directly in a condition is idiomatic and efficient. There’s no need to call len on it. Also, computing intersections can be done with either the & operator or the intersection method; both are equivalent in this context. If needed, intersection between two lists without sets can be written as a comprehension like [x for x in [11, 27, 41, 42] if x in [11, 42]], which yields [11, 42].

Why this matters

Row alignment bugs are subtle in data-processing pipelines. Nested loops that ignore index constraints often appear to work but leak invalid combinations into the result. Using zip enforces the intended pairing semantics and makes the requirement explicit in code, which reduces ambiguity and errors.

Conclusion

To correctly match values across multiple 2D lists under a row-equality constraint, iterate the aligned structures together, intersect with A row-wise, require both intersections to be non-empty, and then merge them. Prefer direct truth checks on sets, and choose either set operations or comprehensions for clarity. Keeping the iteration aligned is the key that turns an almost-right solution into a correct and maintainable one.