Carl Banks wrote:
Say you want to calculate a list of points of an iterated fractal.
Here's the idea: you have a set of linear transformations. You take
the origin (0,0) as the first point, and then apply each transformation
in turn to get a new point. You recursively apply each transformation
at each additional point, up to a certain depth.
I like these kind of things. Ahhh, the best use out of one's computer.
What's the best way to write such a function? Using a nested function,
it's easy as pie. (Details may be a little wrong....)
. def ifs(transformations, maxdepth):
. def add_point(x,y,angle,depth):
. ifspoints.append((x,y,angle))
. if depth < maxdepth:
. for t in transformations:
. nx = x + t.x*cos(angle) - t.y*sin(angle)
. ny = y + t.x*sin(angle) * t.y*cos(angle)
. nangle = angle + t.angle
. add_point(nx,ny,nangle,depth+1)
. ifspoints = []
. add_point(0.0, 0.0, 0.0, 0)
. return ifspoints
If you didn't have the nested function, you'd have to pass not only
depth, but also maxdepth, transformations, and ifspoints around.
I see. Some people complained that you have to use "self." all the
time in methods:) If that was lifted the above would be done with
a class then?
The costly extra feature is this:
###############
def foo():
def f():
print x
x=1
f()
x=2
f()
return f
foo()()
#############
which prints '1 2 2'
The fractal code runs a little _slower_ because of this ability.
Although the specific program does not take advantage of it!
If you had something a little more complex than this, with more than
one nested function and more complex pieces of data you'd need to pass
around, the savings you get from not having to pass a data structure
around and referncing all that data though the structure can be quite a
lot.
Generally, I believe OOP is a superset of nested functions (as a
feature). Nested functions make sense to me as primary python
def statements which ``create new code objects with arbitary constants''
When I see :
###########
def foo(x):
def bar():
print x
return bar
###############
and the call:
xx = foo(1)
I imagine that python runs:
def bar():
print 1
xx=bar
But alas, it doesn't:(
Nooooooooo. It carries around a silly cell object for the
rest of its lifetime. see xx.func_closure.
At least, I think this is what happens...
jfj
--
http://mail.python.org/mailman/listinfo/python-list
