Hey Andy, let's break down what's happening with these two lambda approaches in your PyQt loop—this is such a common gotcha with Python closures, so you’re definitely not alone in scratching your head over it!

First, the Root of the Closure Problem #

To start, let’s clarify why plain lambda: func(i) fails in loops: the loop variable i is a single variable that gets updated with each iteration. All your lambdas will reference this same variable, not a copy of its value at the time the lambda was created. By the time your PyQt signals trigger, the loop has finished, and i will be stuck at its final value (e.g., len(items)-1).

How Your First Working Approach Works #

Let’s unpack this line step by step:

items[i].connect( ( lambda i: lambda: func(i) )(i) )

Think of this as a two-step process:

1. The outer lambda: lambda i: lambda: func(i) is a function that accepts one parameter i. Inside it, it defines and returns an inner lambda: lambda: func(i).
2. Immediate execution: The (i) at the end calls this outer lambda right away, passing in the current value of the loop’s i.

When you call the outer lambda immediately, the parameter i inside it gets bound to the loop’s current i value (a snapshot of that iteration). The inner lambda that gets returned captures this bound i—not the loop’s variable. So each signal connects to a lambda that holds its own unique copy of i from the iteration it was created in.

If you rewrite this without anonymous functions, it’s easier to see:

def make_callback(current_i):
    # This inner function captures the 'current_i' parameter from make_callback
    def callback():
        func(current_i)
    return callback

for i in range(len(items)):
    items[i].connect(make_callback(i))

Your first lambda-based code is just a condensed, anonymous version of this pattern.

Why Your Second Approach Should Work (And Why It Might Seem Broken) #

Your second approach uses lambda default arguments, which is actually another standard fix for this closure issue:

items[i].connect( lambda i=i: func(i) )

Here’s how it works:

• When you define a lambda with i=i, you’re setting a default parameter value. Default arguments are evaluated at the time the lambda is created (not when it’s called). That means each lambda gets its own copy of the loop’s current i value stored as the default.
• When your PyQt signal triggers the lambda (which happens without passing any arguments), the lambda uses its default i value—exactly the snapshot from the loop iteration it was made in.

If you’re seeing it "only return the first value of i," that’s almost certainly not a problem with the lambda itself. Common culprits could be:

• All your items are actually references to the same PyQt widget (so connecting multiple times overwrites the callback)
• A bug in your func function that’s reusing or overwriting the i value
• Accidentally resetting the i variable somewhere outside the loop

To test this, try running a simplified version without PyQt:

def func(i):
    print(f'i value {i}')

# Mock "items" as a list of empty functions
items = [lambda: None for _ in range(3)]

# Apply your second approach
for i in range(len(items)):
    items[i] = lambda i=i: func(i)

# Call each callback
for cb in items:
    cb()

This should print:

i value 0
i value 1
i value 2

Which proves the lambda default argument approach works as intended.

Quick Recap #

• Closure gotcha: Lambdas in loops reference the loop variable itself, not its value at creation time.
• Fix 1 (your first code): Use an immediately-invoked outer lambda to capture a snapshot of i for each inner lambda.
• Fix 2 (your second code): Use lambda default arguments to bind the current i value at lambda creation time—this is more concise and avoids extra nested lambdas.

内容的提问来源于stack exchange，提问作者Andy B