scope of function parameters

[Terry Reedy]

On 5/29/2011 7:59 AM, Mel wrote:
> Henry Olders wrote:
>
>> I just spent a considerable amount of time and effort debugging a program.
>> The made-up code snippet below illustrates the problem I encountered:
>>
>> def main():
>> a = ['a list','with','three elements']
>> print a
>> print fnc1(a)
>> print a
>>
>> def fnc1(b):
>> return fnc2(b)
>>
>> def fnc2(c):
>> c[1] = 'having'
>> return c
>>
>> This is the output:
>> ['a list', 'with', 'three elements']
>> ['a list', 'having', 'three elements']
>> ['a list', 'having', 'three elements']
>>
>> I had expected the third print statement to give the same output as the
>> first, but variable a had been changed by changing variable c in fnc2.
>>
>> It seems that in Python, a variable inside a function is global unless
>> it's assigned. This rule has apparently been adopted in order to reduce
>> clutter by not having to have global declarations all over the place.
>>
>> I would have thought that a function parameter would automatically be
>> considered local to the function.

Function *parameters* are names, the first *local names* of the function.

>> It doesn't make sense to me to pass a global to a function as a parameter.

You are right, in a way;-). Global *names* are just names. When you call 
a function, you pass *objects* as *arguments*. Of course, you may refer 
to the object by a global name to pass it, or you can pass a string 
object that contains a global name.
>
> It doesn't look like a question of local or global. fnc2 is passed a
> container object and replaces item 1 in that container.  You see the results
> when fnc2 prints the object it knows as `c`, and you see again when main
> prints the object it knows as `a`.  Python doesn't pass parameters by
> handing around copies that can be thought of as local or global.  Python
> passes parameters by binding objects to names in the callee's namespace.  In
> your program the list known as `a` in main is identically the same list as
> the one known as `c` in fnc2, and what happens happens.

Right. Python has one unnamed 'objectspace'. It has many, many 
namespaces: builtins, globals for each module, locals for each function 
and class, and attributes for some instances. Each name and each 
collection slot is associated with one object. Each object can have 
multiple associations, as in the example above.

-- 
Terry Jan Reedy