Python指针歧义

Question

Say I have a function foo that takes a list baz, and in foo I wanted to clear baz like so:

baz = []
foo(baz)

foo(baz):
    baz = []

Now, this code does not do what I would want it to do, because it creates a new local list called baz. I know that there are other ways of doing this, but I would like to know Python resolves ambiguities like this where the statement

 baz = []

could be interpreted as telling Python to point the outer scope baz variable at a new empty chunk of memory or to create a new pointer pointing to an empty chunk of memory.

EDIT

Please be aware that I am not asking how to clear a list. I am asking about the behavior of the Python interpreter. Please read the question clearly before downvoting.

Answer 1

Python will only treat variable assignment as assigning to a variable from an outer scope if you explicitly tell it to with the global or nonlocal keywords. global is for global variables, and nonlocal is a Python 3-exclusive keyword for closure variables:

x = 1
def change_x():
    global x
    x = 2
def dont_change_x():
    # no global
    x = 3

change_x()
print(x)  # prints 2

dont_change_x()
print(x)  # still prints 2

Otherwise, it will always interpret assignment as assigning to a local variable.

Answer 2

If you intend to clear the items in your list, you would not need to reassign the current name to a new list, just clear the old one by slicing :

foo(baz):
    baz[:] = [] # clears out list baz

baz[:] is a way of indexing all the items in your list and assigning them a new value

Update :

If you use the same in an assignment to a new list, the interpreter simply reassigns that name to a new list object:

>>> baz = []
>>> id(baz)
14832064
>>> baz = []
>>> id(baz)
14834304

Except you use slicing to refactor the old list, the name baz will no longer be a reference to the old list.

Answer 3

Take a look at this post to understand python way of passing parameters by assignment .

What is happening is that you are redefining the variable baz to another list, so it doesn't have the reference to the outer baz anymore. You need to manipulate the elements in the list directly.

For example, if you're adding an element to baz, the outer list will get the changes:

def foo(baz):
    baz.append('baz')

But by doing this:

def foo(baz):
    baz = []

You assign a new list to baz and the reference to your outer baz is now broken.

In your case, you have 2 options to clear the list:

del baz[:]
baz[:] = []

Answer 4

Use slicing:

>>> def foo(baz):
...     baz[:] = []
...
>>> baz = [1, 2]
>>> foo(baz)
>>> baz
[]

The my_list[:] tells Python to replace all of the elements in my_list with the content on the right side of the assignment statement, referring to the same my_list object.

Answer 5

If you want to clear the list, use .clear() instead of creating a new list:

def foo(baz):
    baz.clear()

Side note: To access the outer baz in your foo() you can to use global keyword. However in that case there will be no ambiguity, as python will force you to rename the argument by throwing SyntaxError.

def foo(baz2):
    global baz
    baz = []

Plase note that usage of global is discouraged.