On 20/11/2015 01:05, Steven D'Aprano wrote:
On Fri, 20 Nov 2015 04:30 am, BartC wrote:
On 19/11/2015 16:01, Steven D'Aprano wrote:
[...]
The whole concept of 'mutable' default is alien to me. A default is just
a convenient device to avoid having to write:
fn(0) or fn("") or fn([])
Says who?
People who want to avoid having to write:
fn(0) or fn("") or fn([])
Here's another use for function defaults, as static storage:
# Ackermann's function
def ack(m, n, _memo={}):
key = m, n
if key not in _memo:
if m==0: v = n + 1
elif n==0: v = ack(m-1, 1)
else: v = ack(m-1, ack(m, n-1))
_memo[key] = v
return _memo[key]
This is a quick and easy way to memoise a function which would otherwise be
horribly slow. And it only works because _memo is bound to a mutable object
once, and once only.
We're arguing at cross-purposes then since you are obviously interested
in these esoteric aspects, but all I want to do is avoid remembering a
long list of defaults. Here's an example from another language, a
function I'm working on at the minute:
function asklist(caption,&data,n=1, rows=10, width=50, flags="",
buttons=(), tablist=(), heading="")=
9 parameters, 7 of them optional. This is designed to be used with
keyword arguments which is where the default values come into their own,
as you don't need to remember positional order either.
Very basic stuff and very obvious what it's for. Notice some defaults
are () (empty lists here), which are the ones that cause bother in Python.
(Here, however, the language doesn't like you doing in-place
modification of a parameter unless the '&' is used, in which case you
wouldn't be able to assign a default value such as () as you can only
pass l-values.)
def test(arg=[]):
arg.append(1)
return len(arg)
The binding arg=[] is NOT inside the body of the function. Therefore, it is
NOT executed repeatedly, but only once.
OK, so the "=" is misleading if not a lie.
So you didn't bother reading the LRM either!
LRM? Left Right Manual?
Language Reference Manual.
That [] doesn't look like an object that could change.
Of course it does.
You've lost me know.
a = []
a.append(1)
Are you shocked to learn that a is no longer an empty list?
No. But I would be surprised if, after this point, [] is no longer an
empty list either!
No, forget that; by now, I wouldn't be surprised at all!
(That [] isn't changed is probably thanks to [] being implemented with
the BUILD_LIST byte-code, which constructs a brand-new empty list each
time. So the next time [] is used, it will be a different one from the
one that has just been appended to.
In my language, a construct such as [10,20,30] is evaluated just once at
start-up. If Python did the same, then I suspect such a literal could
conceivably be changed if just "=" was used to ______[1] it to 'a'.)
([1] To avoid further argument, insert your own choice of jargon here.)
--
Bartc
--
https://mail.python.org/mailman/listinfo/python-list
