递归调用中修改变量是否属于mutation？递归指针变化是否算作mutation？

Great questions—mutation can feel confusing when moving between recursive and iterative paradigms, so let’s break this down with clear examples and definitions.

问题1：递归调用过程中修改变量是否被视为mutation？ #

Short answer: Yes, if you’re modifying the state of an existing variable/object—mutation has nothing to do with whether you’re using recursion or iteration.

Mutation is defined as changing the internal state of an already-existing entity (like a variable, list, or object) instead of creating a new one. So if your recursive function does any of these, it’s using mutation:

• Modifying a global variable across recursive calls
• Altering a mutable parameter (like a list or dictionary) that’s passed into the function
• Updating a variable in an outer scope (like a closure variable)

For example, this recursive sum uses mutation (modifying a global total variable):

total = 0
def recursive_sum_with_mutation(lst):
    global total
    if not lst:
        return total
    total += lst[0]  # This mutates the existing `total` variable
    return recursive_sum_with_mutation(lst[1:])

On the flip side, a pure recursive approach that creates new values instead of modifying existing ones doesn’t use mutation:

def pure_recursive_sum(lst):
    if not lst:
        return 0
    # Here we return a new value (lst[0] + recursive result) instead of modifying anything
    return lst[0] + pure_recursive_sum(lst[1:])

问题2：递归求和时指针的变化是否会被认定为mutation？Mutation仅指代迭代循环中变量的修改吗？ #

First, let’s clarify what “pointer changes” usually mean here: if you’re passing a sub-slice of the list (like lst[1:] in Python) or a new index value (like current_index + 1) to each recursive call, that’s not mutation. Why? Because you’re creating a new reference or value, not modifying the original list or index variable.

For example, using an index parameter recursively without mutation:

def recursive_sum_with_index(lst, index=0):
    if index >= len(lst):
        return 0
    # We pass a new index value (index + 1) instead of modifying the original `index`
    return lst[index] + recursive_sum_with_index(lst, index + 1)

Here, each recursive call gets a fresh index value—we never change the state of the original index variable passed in.

Now, to the second part of your question: Mutation is absolutely not limited to iterative loops. The core idea is still modifying existing state, regardless of the control flow. Iteration often uses mutation (like i += 1 in a for/while loop), but recursion can too (as shown in the first example).

The key distinction isn’t recursion vs iteration—it’s whether you’re modifying existing entities or creating new ones.

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