Python嵌套while循环异常排查：双列表重复项提取与移除代码故障分析

Let's break down exactly why your first nested while loop didn't run as expected—it's not a quirk of Python's while loops, just a mistake in how you managed the k variable.

The Root Cause #

You initialized k=0 outside the outer while loop, which means it only gets set to 0 once. Here's what happens step-by-step:

1. When i=0, the inner while loop runs, incrementing k until it reaches m (1000). By the end of this inner loop, k equals 1000.
2. The outer loop increments i to 1, but k is still 1000. The inner loop's condition k < m (1000 < 1000) is false, so the inner loop skips entirely.
3. This repeats for every subsequent i value—k never gets reset to 0, so the inner loop never runs again. That's why your COMPARED list only has 1000 entries (from i=0 alone) and the outer loop never progresses past the first iteration.

Even if you found a duplicate (and reset k=0 inside the if block), once that inner loop finishes, k would again hit m, and the next outer loop iteration would still skip the inner loop.

Fixing the While Loop #

To fix this, move the k=0 initialization inside the outer while loop. This ensures every time you start checking a new name from names_1, you start comparing from the first element of names_2 again:

dup_names = [] 
m = len(names_1) 
i = 0 
COMPARED = [] 
while i < m: 
    k = 0  # Reset k to 0 for each new element in names_1
    while k < m: 
        COMPARED.append((i, k)) 
        if names_1[i] == names_2[k]: 
            dup_names.append(names_1[i]) 
            names_1[i:i+1] = [] 
            names_2[k:k+1] = [] 
            m -= 1 
            k = 0  # Reset k since lists have shrunk
        else: 
            k += 1 
    i += 1 

⚠️ Note: There's another subtle issue here—when you delete names_1[i], the list shifts left, so the next element you need to check is now at index i (not i+1). If you increment i anyway, you'll skip that element. To fix this, only increment i when you don't delete an element. But honestly...

A Far More Efficient Approach #

Nested loops work for small lists, but with 1000 elements, you're looking at 1,000,000 comparisons—Python's sets can do this in O(n) time instead. Sets are designed for fast membership checks and intersection operations:

# Convert lists to sets for fast operations
set_names1 = set(names_1)
set_names2 = set(names_2)

# Get duplicate names (intersection of the two sets)
dup_names = list(set_names1 & set_names2)

# Filter out duplicates from original lists
names_1 = [name for name in names_1 if name not in dup_names]
names_2 = [name for name in names_2 if name not in dup_names]

This is cleaner, faster, and avoids all the manual loop variable management headaches.

内容的提问来源于stack exchange，提问作者Fandi Bataineh