Why Do Functions Defined in Loops Often Return the Same Value, and How Can This Be Fixed?

Creating Functions Within Loops: Addressing Late Binding Issues

When attempting to define individual functions within a loop, it's common to encounter the issue where all functions return the same value despite being intended to represent unique outcomes. This phenomenon, known as late binding, occurs because functions do not receive their arguments until they are called.

Consider the following example using a for loop:

functions = []
for i in range(3):
    def f():
        return i
    functions.append(f)

As written, each function looks up its corresponding value of i at the time it is called. However, after the loop has executed, all functions will reference the final value of i (2), resulting in the following output:

print([f() for f in functions])
# Expected: [0, 1, 2]
# Actual: [2, 2, 2]

Solution: Enforcing Early Binding

To address this issue, it's necessary to force early binding by assigning arguments to functions at definition time rather than call time. This can be achieved by adding a default argument to the function definition:

functions = []
for i in range(3):
    def f(i=i):
        return i
    functions.append(f)

The default argument (in this case, i=i) is evaluated when the function is defined, not when it is called. This ensures that each function retains its unique argument value, producing the desired output:

print([f() for f in functions])
# Output: [0, 1, 2]

Alternative Approach Using Closure

If concern arises over the potential for additional arguments to be passed to the function, a more elaborate approach can be implemented using closures:

def make_f(i):
    def f():
        return i
    return f

In this scenario, a function factory (make_f) is created. Within the loop, the returned function from make_f is assigned to the f variable instead of calling def f(): directly. This approach guarantees that each function retains its exclusive argument value, like in the early binding solution.

The above is the detailed content of Why Do Functions Defined in Loops Often Return the Same Value, and How Can This Be Fixed?. For more information, please follow other related articles on the PHP Chinese website!