Python list scope outside a function

Question

I am having a problem which is hard to explain because there's a lot of code involve. So it boils down to the following problem.

I am trying to access the list xxx outside the function foo but I am getting unexpected results. Can someone please explain why?

Here's my function which I have created to show the problem:

def foo(xxx = []):
    if len(xxx) == 5:
        return xxx
    xxx += [1]
    foo()
    return xxx

If I run

print foo()

I get

[1, 1, 1, 1, 1]

which is what I expect.

But I want the list xxx to be accessible outside foo. So, I am doing

xxx = []
print foo(xxx)
print xxx

Now I expect to get the list xxx to be

[1, 1, 1, 1, 1]

but what I am getting xxx to be, is

[1]

which is not what I expect.

Can someone explain why? And is it possible to access the correct xxx outside foo without accessing it through the output of the function foo? The reason I want to do this is because in my actual code I am returning something other than in my function foo and making changes to xxx which I want to see after the foo has executed. I can make the function also return xxx every time but this will make my code unnecessarily bulky. But I am not sure if I am compromising the code quality. I don't know. Please suggest which ever way is the best.

Thanks

Passing in an argument replaces the default argument. So it will happily modify a different list when provided (and that list will be modified even if not returned), otherwise it's modifying the shared list used as a default (which cannot be accessed normally without returning it). — ShadowRanger
– ShadowRanger, Commented Oct 8, 2015 at 11:29
Just a side note (that has nothing to do with your question): try to avoid mutable default arguments. Their behavior is counter intuitive and people using your code may get unexpected results. — Andrea Corbellini
– Andrea Corbellini, Commented Oct 8, 2015 at 11:31
I am myself very confused with this code. What's the substitute for mutable default arguments? — Lokesh
– Lokesh, Commented Oct 8, 2015 at 11:33
I found my answer. By using the code by @Hammerite I am getting the desired functionality. Thanks — Lokesh
– Lokesh, Commented Oct 8, 2015 at 11:39

Hammerite · Accepted Answer · 2015-10-08 11:28:04Z

3

xxx = []
print foo(xxx)
print xxx

In this code you are calling foo() with the list you created outside the function, called xxx. But within the function, you are recursing to call foo() without parameters, so it modifies the list that was created at function definition time by the expression for the default argument value. (Importantly, this is the same list every time you call the function without supplying a value for that argument.)

Compare what happens when you define foo like this instead:

def foo(xxx = None):
    if xxx is None:
        xxx = []
    if len(xxx) == 5:
        return xxx
    xxx += [1]
    foo()
    return xxx

... and what happens when you define it like this:

def foo(xxx = None):
    if xxx is None:
        xxx = []
    if len(xxx) == 5:
        return xxx
    xxx += [1]
    foo(xxx)
    return xxx

answered Oct 8, 2015 at 11:28

Hammerite

22.5k6 gold badges76 silver badges103 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Lokesh Over a year ago

The second code which you mentioned solved my problem. But trying understand the difference between all the three is spinning my mind.

Alexander Trakhimenok Over a year ago

Roughly speaking when you write foo(xxx=[]) the xxx value is initialized on the module level and would be shared between all calls to the function - not created every time you make a call. There is a lot of information about this on web and StackOverflow.

Collectives™ on Stack Overflow

Python list scope outside a function

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related