Multi-dimensional list initialization
andrew3 at r3dsolutions.com
Tue Nov 6 22:14:10 CET 2012
On 11/06/2012 06:35 AM, Oscar Benjamin wrote:
> > In general, people don't use element multiplication (that I have
> *ever* seen) to make lists where all elements of the outer most list
> point to the same sub-*list* by reference. The most common use of the
> multiplication is to fill an array with a constant, or short list of
> constants; Hence, almost everyone has to work around the issue as
> the initial poster did by using a much longer construction.
> That's what I have seen as well. I've never seen an example where
> someone wanted this behaviour.
> > The most compact notation in programming really ought to reflect the
> most *commonly* desired operation. Otherwise, we're really just
> making people do extra typing for no reason.
> It's not so much the typing as the fact that this a common gotcha.
> Apparently many people expect different behaviour here. I seem to
> remember finding this surprising at first.
:) That's true as well.
> > Further, list comprehensions take quite a bit longer to run than low
> level copies; by a factor of roughly 10. SO, it really would be worth
> implementing the underlying logic -- even if it wasn't super easy.
> > I really don't think doing a shallow copy of lists would break
> anyone's program.
> > The non-list elements, whatever they are, can be left as reference
> copies -- but any element which is a list ought to be shallow copied.
> The behavior observed in the opening post where modifying one element
> of a sub-list, modifies all elements of all sub-lists is never desired
> as far as I have ever witnessed.
> It is a semantic change that would, I imagine, break many things in
> subtle ways.
?? Do you have any guesses, how ?
> > The underlying implementation of Python can check an object type
> trivially, and the only routine needed is a shallow list copy. So, no
> it really isn't a complicated operation to do shallow copies of lists.
> Yes but if you're inspecting the object to find out whether to copy it
> what do you test for? If you check for a list type what about
> subclasses? What if someone else has a custom list type that is not a
> subclass? Should there be a dunder method for this?
No dunder methods. :)
Custom non-subclass list types aren't a common usage for list
multiplication in any event.
At present one has to do list comprehensions for that, and that would
simply remain so.
Subclasses, however, are something I hadn't considered...
> I don't think it's such a simple problem.
You made a good point, Oscar; I'll have to think about the subclassing a
More information about the Python-list