Multi-dimensional list initialization

MRAB python at
Wed Nov 7 01:23:44 CET 2012

On 2012-11-06 23:52, Ian Kelly wrote:
> On Tue, Nov 6, 2012 at 3:41 PM, Andrew Robinson
> <andrew3 at> wrote:
>>>      Q: What about other mutable objects like sets or dicts?
>>>      A: No, the elements are never copied.
>> They aren't list multiplication compatible in any event! It's a total
>> nonsense objection.
>> If these are inconsistent in my idea -- OBVIOUSLY -- they are inconsistent
>> in Python's present implementation.  You can't even reference duplicate them
>> NOW.
>>>>> { 1:'a', 2:'b', 3:'c' } * 2
>> Traceback (most recent call last):
>>   File "<stdin>", line 1, in <module>
>> TypeError: unsupported operand type(s) for *: 'dict' and 'int'
> 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
>>>      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:
>>> Losing consistency in favour of saving a few characters for something as
>>> uncommon as list multiplication is a poor tradeoff. That's why this
>>> proposal has been rejected again and again and again every time it has
>>> been suggested.
>> Please link to the objection being proposed to the developers, and their
>> reasoning for rejecting it.
>> I think you are exaggerating.
>>From Google:
> Note that in two out of these four cases, the reporter was trying to
> multiply lists of dicts, not just lists of lists.
>> 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.
>> 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.  This is not
> what Python does; the list inside the function and the list passed in
> are the same list.  At the same time, the function does not have
> access to the original reference to the list and cannot reassign it by
> reassigning its own reference, so it is not call-by-reference
> semantics either.
I prefer the term "reference semantics".

More information about the Python-list mailing list