On 13/03/2016 09:39, Steven D'Aprano wrote:
On Sun, 13 Mar 2016 04:54 am, BartC wrote:
Common sense tells you it is unlikely.
Perhaps your common sense is different from other people's common sense. To
me, and many other Python programmers, it's common sense that being able to
replace functions or methods on the fly is a useful feature worth having.
More on this below.
Perhaps this is an example of the "Blub Paradox":
Perhaps it's time to talk about something which many languages have, but
Python hasn't. Not as far as I know anyway.
That's references to names (sometimes called pointers). So if I write:
a = 100
f(a)
then function f gets passed the value that a refers to, or 100 in this
case. But how do you pass 'a' itself?
Perhaps you can say:
f('a')
and f can do some sort of lookup, if it knows the caller's context, for
such a name and retrieve the value that way. But that's rather
heavy-handed, and f can't distinguish between a reference to a name, and
a string.
Unless maybe you wrap this up in a class and .... Well, you end up with
something that might emulate a name reference, but with so much
complexity and such overheads that it is not worthwhile.
Yet, this is a feature I use extensively, far more often than I would
use mutable functions. And in fact it was used in the code for my jpeg
example, where in the Python I has to use a workaround (see below).
I would argue that such references are more useful than mutable function
names, as the latter can be more easily emulated and with little or no
extra overheads.
-------------------------------------------------
Non-Python example of reference parameters:
fastidct8(
block[j], # each argument can be updated by the callee
block[j+8],
block[j+16],
block[j+24],
block[j+32],
block[j+40],
block[j+48],
block[j+56])
proc fastidct8(&a1,&a2,&a3,&a4,&a5,&a6,&a7,&a8) =
const w1 = 2841 # (Incidentally, here's a use-case for proper
const w2 = 2676 # consts. Evaluated at compile-time here ...
const w3 = 2408
const w5 = 1609
const w6 = 1108
const w7 = 565
....
a1 := (x8 + x2) >> 8
a2 := (x4 + x3) >> 8
a3 := (x1 + x5) >> 8
a4 := (x9 + x7) >> 8
a5 := (x9 - x7) >> 8
a6 := (x1 - x5) >> 8
a7 := (x4 - x3) >> 8
a8 := (x8 - x2) >> 8
end
Python version:
(block[j],
block[j+8],
block[j+16],
block[j+24],
block[j+32],
block[j+40],
block[j+48],
block[j+56]) = fastidct8(
block[j],
block[j+8],
block[j+16],
block[j+24],
block[j+32],
block[j+40],
block[j+48],
block[j+56])
def fastidct8(a1,a2,a3,a4,a5,a6,a7,a8):
w1 = 2841 # ... but at run-time in here)
w2 = 2676
w3 = 2408
w5 = 1609
w6 = 1108
w7 = 565
....
a1 = (x8 + x2) >> 8
a2 = (x4 + x3) >> 8
a3 = (x1 + x5) >> 8
a4 = (x9 + x7) >> 8
a5 = (x9 - x7) >> 8
a6 = (x1 - x5) >> 8
a7 = (x4 - x3) >> 8
a8 = (x8 - x2) >> 8
return [a1,a2,a3,a4,a5,a6,a7,a8]
--
Bartc
--
https://mail.python.org/mailman/listinfo/python-list
