Path: csiph.com!usenet.pasdenom.info!gegeweb.org!de-l.enfer-du-nord.net!feeder1.enfer-du-nord.net!feeds.phibee-telecom.net!newsfeed.xs4all.nl!newsfeed5.news.xs4all.nl!xs4all!post.news.xs4all.nl!not-for-mail
Date: Tue, 06 Nov 2012 13:14:10 -0800
From: Andrew Robinson <andrew3@r3dsolutions.com>
User-Agent: Mozilla/5.0 (X11; Linux i686; rv:8.0) Gecko/20111126 Thunderbird/8.0
MIME-Version: 1.0
To: Oscar Benjamin <oscar.j.benjamin@gmail.com>
Subject: Re: Multi-dimensional list initialization
References: <mailman.3267.1352096879.27098.python-list@python.org> <50978323$0$6908$e4fe514c@news2.news.xs4all.nl> <CAHVvXxQR2J2tyFcQZd7bNYTAeetwM+LfoV4UcYrkRfeNVOj+pg@mail.gmail.com> <CAPTjJmqzQi2TEjme_we-KfmG7vxOfRWoKG=zL=SGHYGqiFf9_Q@mail.gmail.com> <CAHVvXxQNCxpACM=tkKir0f3iVqui4oVGnyS-GywO+dtGacKAdQ@mail.gmail.com> <5098A55C.3090201@r3dsolutions.com> <CAHVvXxSyVvZi-qcuZC3-gnmpQNdrp7jMT2rXp5T1f719_1BN-Q@mail.gmail.com>
In-Reply-To: <CAHVvXxSyVvZi-qcuZC3-gnmpQNdrp7jMT2rXp5T1f719_1BN-Q@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit
Cc: python-list@python.org
Precedence: list
Reply-To: andrew3@r3dsolutions.com
Newsgroups: comp.lang.python
Message-ID: <mailman.3339.1352236812.27098.python-list@python.org>
Lines: 68
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:32842

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.
>
> Oscar
>
You made a good point, Oscar; I'll have to think about the subclassing a 
bit.
:)