What are the differences in variable scoping between Python and Scheme?

Question

Refering to Variable Scoping.

I'm trying to figure out what are the differences between those 2.

For example, Anonymous functions in a scheme function has access to the variables local to that function. Does python have this?

Thanks!

Answer 1

Yes, Python has the ability to access variables that are local to an anonymous function (in Python, this is called a lambda function) within that function.

I'm not entirely sure if that answered you question, so if it didn't, please post some more detail

Answer 2

In Python variable scope can be either global or function. In Scheme, the scope can be any block.

For example, in Scheme you could define a variable inside a loop, and it wouldn't be accessible from outside the loop. In Python, the scope being the whole function, this variable would 'leak' out of the loop into the rest of the function.

About your specific question: note that anonymous (lambda) functions in Python are horribly limited (just a single expression, no if/then statements, loops, etc.), so you usually define complete (named) inner functions. In this case the scope rules are similar to Scheme: the inner function can access the outer function's variables (creating a closure), and the outer function can't access variables defined inside the inner function.

In short: lexical scoping and closures work as expected; just remember that the scoping granularity is per function, not per block.

Answer 3

Scheme and Python are both lexically scoped, in the way that you seem to be asking.

def make_adder(n):
    when = datetime.now()
    def adder(k):
        print "The adder you created at %s has been called!" % when
        return k + n
    return adder

Answer 4

Subtle question. Yes, Python lambdas close on variables in the enclosing function. Both languages have lexical scoping. But the details are quite different.

In Scheme, you usually introduce a variable with (let) or (letrec) or (lambda) and it's pretty explicit what the scope of the variable is. Also, whenever a variable is in scope, you can assign to it using (set!).

In Python, assigning to a name implicitly makes a local variable whose scope is the entire function. So even though you can access outer variables by name, if you want to assign to a variable in an outer scope, you must use a global declaration (or in Python 3.0 nonlocal).

Python also has classes. Class members aren't really lexical variables; methods do not close over them.

>>> def top(x):
...   class C:
...     x = 1  # foo does not close on this 'x'.
...     def foo(self):
...       return x  # this refers to the argument of top
...   return C().foo()
... 
>>> top(2)
2

See the Python language reference for more: http://docs.python.org/reference/executionmodel.html#naming