Michael Tobis <[EMAIL PROTECTED]> wrote: ...I don't know that it's ever necessary to rebind, but it is, in fact, common, and perhaps too easy. In numeric Python, avoiding rebinding turns out to be a nontrivial skill.
Well, a for-statement is BASED on rebinding, for example. Maybe you don't mean to address rebinding per se, but rebinding in ``separate statements''? The ``separation'' needs to be defined carefully to make while-loops work, too. Normally, a while-statement's header clause would be something like: while <expression>: where the expression depends on the values bound to some local variables. For the first evaluation, the variables need to be bound by earlier statements; for the expression to eventually become false, it's likely (unless we're talking about mutable objects) that the variables need to be re-bound in the loop body.
For example, consider:
def f(a, b): x = 0 while x < 100000: print x, x = a*x + b print
I think you guys are talking about rebinding of quite different objects. Rebinding x in the above example is not what Michael Tobis is talking about, I presume, though x is prone to the 'epselon' error. But, C'est la vie.
If x was some sort of counter (time step, iteration) and there was a Numeric array y to be processed in that loop,
def f(a, b):
y = Numeric.zeros((100, 100), 'd')
x = 0
while x < 100000:
x = a*x + b
y = a*y + bit is actually important (e.g. in terms of performance) not to rebind y. Okay, in this case it is straightforward to change function f to function g, so that y does not get recreated (rebound).
def g(a, b):
y = Numeric.zeros((100, 100), 'd')
x = 0
while x < 100000:
x = a*x + b
y *= a
y += bI don't know if y gets 'rebound' in a strict sense of the word. But y does not call it's constructor (which is expensive). And in terms of performance
y = Numeric.zeros((100, 100), 'd')
1 0.010 0.010 574.050 574.050 profile:0(f(1,1))
1 -0.000 -0.000 416.640 416.640 profile:0(g(1,1))
y = numarray.zeros((100, 100), 'd')
1 0.020 0.020 231.359 231.359 profile:0(f(1,1))
1 0.010 0.010 27.899 27.899 profile:0(g(1,1))
it's quite a difference.
would you require the programmer to find out a closed-form expression for this recurrence relation, in order to avoid having to rebind the name 'x'? OK, in this particular case it may be OK, if you are willing
Using Numeric arrays or Numarrays, it might help to have some closed-form expression for the above (I'm quite sure there is, see daxpy in BLAS). But then, I'd say it's in the responsability of the programmer who did class Y to create y to prevent the user from using y = a*y + b. Either in the documentation or really strictly by not implementing + and * (only =+ and =*). This kind of restriction/declaration should not be in Python, but in the module that provides Y.
to put competence in college-level algebra as a prerequisite for using
Python. But what if the rebinding in the body of the loop was to a more
I believe those using Numeric/Numarray might have heard of algebra and in-place operations. So, one could even argue that it's up to the user to find an efficient way to avoid rebinding of y.
Christian
-- http://mail.python.org/mailman/listinfo/python-list
