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.

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

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

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