Hi IAN!
On 11/06/2012 03:52 PM, Ian Kelly wrote:
On Tue, Nov 6, 2012 at 3:41 PM, Andrew Robinson
The objection is not nonsense; you've merely misconstrued it. If
[[1,2,3]] * 4 is expected to create a mutable matrix of 1s, 2s, and
3s, then one would expect [[{}]] * 4 to create a mutable matrix of
dicts. If the dicts are not copied, then this fails for the same
reason
:) The idea does create a multable list of dicts; just not a mutable
list of different dicts.
Q: How about if I use delegation to proxy a list?
A: Oh no, they definitely won't be copied.
Give an example usage of why someone would want to do this. Then we can
discuss it.
Seriously? Read a book on design patterns. You might start at SO:
http://stackoverflow.com/questions/832536/when-to-use-delegation-instead-of-inheritance
:) I wasn't discarding the argument, I was asking for a use case to
examine.
I know what a delegation *is*; but I'm not spending lots of times
thinking about this issue.
(Besides this thread just went more or less viral, and I can't keep up)
I have a book on design patterns -- in fact, the one called "Design
Patterns" by Gamma, Helm, Johnson, Vlissides. (Is it out of date
already or something?)
Please link to the objection being proposed to the developers, and
their reasoning for rejecting it. I think you are exaggerating.
> From Google:
http://bugs.python.org/issue1408
http://bugs.python.org/issue12597
http://bugs.python.org/issue9108
http://bugs.python.org/issue7823
Note that in two out of these four cases, the reporter was trying to
multiply lists of dicts, not just lists of lists.
That's helpful. Thanks. I'll look into these.
Besides, 2D arrays are *not* rare and people *have* to copy internals of
them very often.
The copy speed will be the same or *faster*, and the typing less -- and the
psychological mistakes *less*, the elegance more.
List multiplication is not potentially useful for copying 2D lists,
only for initializing them. For copying an existing nested list,
you're still stuck with either copy.deepcopy() or a list
comprehension.
Yes, I totally agree.
But, as far as I know -- the primary use of list multiplication is
initialization.
That was my point about the most compact notation ought to be for the
most common case.
Initialization is a very common use case.
List comprehensions are appropriate for the other's.
Even D'Aprano thought the * operator was not a common operation; and I
suppose that when compared to other operations done in a program
(relative counting) he's correct; most programs are not primarily matrix
or initialization oriented.
It's hardly going to confuse anyone to say that lists are copied with list
multiplication, but the elements are not.
Every time someone passes a list to a function, they *know* that the list is
passed by value -- and the elements are passed by reference. People in
Python are USED to lists being "the" way to weird behavior that other
languages don't do.
Incorrect. Python uses what is commonly known as call-by-object, not
call-by-value or call-by-reference. Passing the list by value would
imply that the list is copied, and that appends or removes to the list
inside the function would not affect the original list.
Interesting, you avoided the main point "lists are copied with list
multiplication".
But, in any event:
_Pass_ by value (not call by value) is a term stretching back 30 years;
eg: when I learned the meaning of the words. Rewording it as "Call by
value" is something that happened later, and the nuance is lost on those
without a very wide programming knowledge *and* age.
In any event:
All objects in Python are based on pointers; all parameters passed to
functions, etc, are *copies* of those pointers; (by pointer value).
I made the distinction between contents of the list and the list object
itself for that reason; I gave an explicit correction to the _pass_ by
"value" generalization by saying: ("the elements are passed by reference").
The concept I gave, although archaically stated -- still correctly
represents what actually happens in Python and can be seen from it's
source code(s).
The point I am making is not generally true of everyone learning
Python; For some people obviously learn it from scratch. But, for
people who learn the language after a transition, this is a common FAQ;
how do I modify the variables by reference and not by value; -- the
answer is, you can't -- you must embed the return value in another
object; parameters are always passed the *same* way.
Every function written, then, has to decide when objects are passed to
it -- whether to modify or copy the object (internals) when modifying
it. That's all I meant.
--
http://mail.python.org/mailman/listinfo/python-list
