Q:

What is the scope of a defaulted parameter in Python? 

When you define a function in Python with an array parameter, what is the scope of that parameter? 
This example is taken from the Python tutorial:
def f(a, L=[]):
    L.append(a)
    return L

print f(1)
print f(2)
print f(3)

Prints:
[1]
[1, 2]
[1, 2, 3]

I'm not quite sure if I understand what's happening here.  Does this mean that the scope of the array is outside of the function?  Why does the array remember its values from call to call?  Coming from other languages, I would expect this behavior only if the variable was static.  Otherwise it seems it should be reset each time.  And actually, when I tried the following:
def f(a):
    L = []
    L.append(a)
    return L

I got the behavior I expected (the array was reset on each call). 
So it seems to me that I just need the line def f(a, L=[]): explained - what is the scope of the L variable? 

A:

The scope is as you would expect. 
The perhaps surprising thing is that the default value is only calculated once and reused, so each time you call the function you get the same list, not a new list initialized to []. 
The list is stored in f.func_defaults. 
def f(a, L=[]):
    L.append(a)
    return L

print f(1)
print f(2)
print f(3)
print f.func_defaults
f.func_defaults = (['foo'],) # Don't do this! 
print f(4)

Result:
[1]
[1, 2]
[1, 2, 3]
([1, 2, 3],)
['foo', 4]

A:

The scope of the L variable is behaving as you expect.   
The "problem" is with the list you're creating with [].   Python does not create a new list each time you call the function.   L gets assigned the same list each time you call which is why the function "remembers" previous calls.  
So in effect this is what you have:
mylist = []
def f(a, L=mylist):
    L.append(a)
    return L

The Python Tutorial puts it this way:

The default value is evaluated only once.  This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes.  

and suggests the following way to code the expected behaviour:
def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

A:

There's even less "magic" than you might suspect.  This is equivalent to 
m = []

def f(a, L=m):
    L.append(a)
    return L

print f(1)
print f(2)
print f(3)

m is only created once.