On Apr 14 2003, 10:30 pm, Alex Martelli <[EMAIL PROTECTED]> wrote:
> Sebastian Wilhelmi wrote:
> > Hi,
>
> > I would like to do the following:
>
> > -------8<-------8<-------8<-------8<-------
> > def test ():
> > count = 0
> > def inc_count ():
> > count += 1
> > inc_count ()
> > inc_count ()
> > print count
>
> > test ()
> > -------8<-------8<-------8<-------8<-------
>
> > This doesn't work (and I even understand, why ;-)
>
> Specifically: a nested function cannot *RE-BIND* a variable of
> an outer function.
>
Sorry to dig up this old thread, but I would like to know what's the
rationale is. Why can't a nested function rebind a variable of an
outer function?
>
>
> > One solution is the following, which I however do not see as very
> > clean or nice.
>
> > -------8<-------8<-------8<-------8<-------
> > def test ():
> > count = [0]
> > def inc_count ():
> > count[0] += 1
> > inc_count ()
> > inc_count ()
> > print count[0]
>
> > test ()
> > -------8<-------8<-------8<-------8<-------
>
> > Now my question: Is there some way to achieve this with a nicer
> > syntax?
>
> Depends on your tastes in syntax, e.g.:
>
> def test():
> class Bunch: pass
> loc = Bunch()
> loc.count = 0
> def inc_count():
> loc.count += 1
> inc_count()
> inc_count()
> print loc.count
>
> or:
>
> def test():
> test.count = 0
> def inc_count():
> test.count += 1
> inc_count()
> inc_count()
> print test.count
>
> and no doubt quite a few others.
I was trying to write a function that creates another function and
returns it when I came across this problem. These two solutions have a
difference:
def M():
M.c = 0
class Bunch:
pass
Bunch.c = 0
def f():
M.c += 1
Bunch.c += 1
print M.c, Bunch.c
return f
>>>f = M()
>>>f2 = M()
>>> f()
1 1
>>> f()
2 2
>>> f()
3 3
>>> f2()
4 1
>>> f2()
5 2
>>> f2()
6 3
The created functions share their variables binded to the outer
function, but have their separate copies of variables bundled in a
class.
Is binding name to the function object a python way to use 'static'
variables? But how to initialize them?
>
> > Using 'global' would not count, as that would make a variable
> > unnecessarily known to the outside.
>
> The two solutions above outlined differ in this respect -- variable
> 'loc' in the former is local to function test, while function attribute
> test.count in the latter is "known to the outside" (it survives each
> execution of test and can be examined "from the outside").
>
> Class Bunch (or some highly refined version thereof) IS typically
> around whenever I program, see for example:
>
> http://mail.python.org/pipermail/python-list/2002-July/112007.html
>
> for a typical presentation. Having available the MetaBunch there
> described, I'd start the function as follows:
>
> def test():
> class Bunch(MetaBunch): count=0
> loc = MetaBunch()
> def inc_count():
> loc.count += 1
>
> etc. I do find such constructs often handy...
>
> Alex
--
http://mail.python.org/mailman/listinfo/python-list
