(define (f) 42)
(define (g) (f))
(g) ;; 42
(define (f) 50)
(g) ;; 50

The neat thing about Python’s lexical scope is that you can actually fake private variables: declare a local dictionary inside your constructor __init__, put all the private variables there (key = the name, value = initial value), and define all the accessor methods in the constructor as well.

Because of lexical scoping, they have access to this dictionary. Now attach them to the class:

class bean(object):
def __init__(self):
privates = {"val" : 0}
def get():
return privates["val"]
def set(x):
privates["val"] = x
return
self.get = get
self.set = set
return

dir(bean()) will show you that the privates are, well, privates. Note the neat trick that if you use self.method_name = internal_name, you don’t need to take self as an argument (but you don’t have access to the object’s namespace, apart from privates). If you use classname.method_name = internal_name (i.e. bean.get = get), now get must take self as a parameter, but gets to use it as needed.

I lifted this from a fascinating discussion, that unfortunately I can’t find at the moment. Will update when I manage to locate it.

>>> def a1():
… def q(x):
… print ’stat’, x
… def p(x):
… return q(x)
… def a2():
… def q(x):
… print ‘dyn’, x
… p(‘hello’)
… a2()
…
>>> a1()
stat hello

the example i was working from the book was in a language (“Oz”) was a dynamic language that still had variable declaration:

local P Q in
proc {Q X} {Browse stat(X)} end
proc {P X} {Q X} end
local Q in
proc {Q X} {Browse dyn(X)} end
{P hello}
end
end

so it is easier to create inner scopes. with python, i needed a separate inner function for each layer of scope for a comparable example.

**** naive example
>>> def q(x):
… print ’stat’, x
…
>>> def p(x):
… q_holder = q
… return q_holder(x)
…
>>> p(‘dude’)
stat dude
>>> def q(x):
… print ‘dyn’, x
…
>>> p(‘dude’)
dyn dude
>>>

***** should show static scoping
>>> def q(x):
… print ’stat’, x
…
>>> def p(x):
… q_holder = q
… return q_holder(x)
…
>>> def blah(x):
… print ‘dyn’, x
…
>>> p(‘dude’)
stat dude
>>> q = blah
>>> p(‘dude’)
dyn dude

I guess you can’t copy a function definition and save it from being rebound later….

I’m reading “Concepts, Techniques and Models of Computer Programming” and came across the section on static vs. dynamic scoping. I whipped open my laptop to check whether python was statically scoped, and was fooled into thinking it was dynamically scoped using something very similar to your “bad” example.

A couple google searches later and I find this post, the perfect clarification. Thanks!