Python：无global/return且未知变量名时修改外部元组类型变量

Alright, let's break down your problem and figure out how to approach it in Python. First off, using list as a parameter name is a bad idea—it overwrites Python's built-in list() function, so I'll use seq instead in the examples below.

The key problem here boils down to how Python handles variable bindings and parameter passing:

• Python uses pass-by-object-reference—when you pass secrettuple to your function, you're passing a reference to the tuple object, not the variable name itself.
• Tuples are immutable, so you can't modify the original tuple directly (which is why you're converting it to a list in the function).
• You can't directly reassign a variable in the caller's scope from inside a function unless you explicitly have access to that variable's name (which you don't here).

The line ??? = temporary can't work as-is because there's no way to reference the caller's variable name (like secrettuple in your example) dynamically inside the function without some workaround.

Python's design encourages functions to return modified values rather than mutating external variables. Even though you mentioned wanting the function to return None, this is the cleanest, most maintainable approach:

def next_seq(seq):
    temporary = list(seq)
    temporary.append(temporary[-1] + 1)
    return temporary

# Usage
secrettuple = (2, 3, 4, 5)
secrettuple = next_seq(secrettuple)
print(secrettuple)  # Output: [2, 3, 4, 5, 6]

This follows Python's conventions, is easy to read, and avoids any weird scope hacks. If you really need the function to return None for some reason, you could have the caller handle the assignment explicitly—there's no way around this without breaking standard practices.

If you absolutely must modify the caller's variable without returning a value (and you don't know the variable name in advance), you can use the inspect module to dig into the caller's scope. This is a hack and should never be used in production code—it breaks Python's scoping rules, is fragile, and makes your code hard to understand.

Here's how it would look:

import inspect

def next_seq(seq):
    temporary = list(seq)
    temporary.append(temporary[-1] + 1)
    
    # Get the caller's frame to access their local/global variables
    caller_frame = inspect.currentframe().f_back
    
    # First check local variables for a match to the input object
    updated = False
    for var_name, var_val in caller_frame.f_locals.items():
        if var_val is seq:
            caller_frame.f_locals[var_name] = temporary
            updated = True
            break
    
    # If not found in locals, check global variables
    if not updated:
        for var_name, var_val in caller_frame.f_globals.items():
            if var_val is seq:
                caller_frame.f_globals[var_name] = temporary
                break
    
    return None

# Usage
secrettuple = (2, 3, 4, 5)
next_seq(secrettuple)
print(secrettuple)  # Output: [2, 3, 4, 5, 6]

Why this is a bad idea: #

• If multiple variables reference the same input object, this will only update the first one it finds.
• It won't work in all environments (e.g., some optimized code, Jupyter notebooks with certain settings, or when called from a closure/class method).
• It makes your code non-intuitive—other developers reading this will be confused about how the variable is being modified.

Stick with the Pythonic solution of returning the modified list and having the caller reassign the variable. This aligns with Python's design principles and will save you from headaches down the line. The hacky workaround should only be used as a last resort if you have no other option.

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