In Python one can do:
a, b = 1, 2
(a, b) = 1, 2
[a, b] = 1, 2
I checked the generated bytecode using dis and they are identical.
So why allow this at all? Would I ever need one of these instead of the others?
See also Multiple assignment and evaluation order in Python regarding the basic semantics of this kind of assignment.
See also Understand Python swapping: why is a, b = b, a not always equivalent to b, a = a, b? for more complex cases, where the order of assignment matters.
One case when you need to include more structure on the left hand side of the assignment is when you're asking Python unpack a slightly more complicated sequence. E.g.:
# Works
>>> a, (b, c) = [1, [2, 3]]
# Does not work
>>> a, b, c = [1, [2, 3]]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: need more than 2 values to unpack
This has proved useful for me in the past, for example, when using enumerate to iterate over a sequence of 2-tuples. Something like:
>>> d = { 'a': 'x', 'b': 'y', 'c': 'z' }
>>> for i, (key, value) in enumerate(d.iteritems()):
... print (i, key, value)
(0, 'a', 'x')
(1, 'c', 'z')
(2, 'b', 'y')
i will have even more meaning.
Python tuples can often be written with or without the parentheses:
a = 1, 2, 3
is equivalent to
a = (1, 2, 3)
In some cases, you need parentheses to resolve ambiguities, for examples if you want to pass the tuple (1, 2) to the function f, you will have to write f((1, 2)). Because the parentheses are sometimes needed, they are always allowed for consistency, just like you can always write (a + b) instead of a + b.
If you want to unpack a nested sequence, you also need parentheses:
a, (b, c) = 1, (2, 3)
There does not seem to be a reason to also allow square brackets, and people rarely do.
There should be one-- and preferably only one --obvious way to do it. and Special cases aren't special enough to break the rules. Thanks
just wondering about the rationale for this design decision makes me also curious and perplexed of what would be a (even single) justifiable use case for [...]= then?. Thanks
When unpacking a single-element iterable, the list syntax is prettier:
a, = f() # comma looks out of place
(a,) = f() # still odd
[a] = f() # looks like every other list
list is heavier to generate so a tuple is quicker. This may not be significant or even true but anyway I'm used to trailing commas now (and kind of like them in a wierd way). I've edited to black standards because we can't really assess appearance properly all crushed up like that (although black actually wraps the first form with parentheses to appear like the second, anyway).
list? It’s just syntax: the variables to which you are assigning aren’t actually in any list object (what would it contain?).list during assignment of a and then immediately throw it away again?They are also same because the assignment happens from Right to left and on the right, you have one type, which is a sequence of two elements. When the asignment call is made, the sequence is unpacked and looked for corresponding elements to match and given to those values. Yes, any one way should be fine in this case where the sequence is unpacked to respective elements.
An open parenthesis allows for a multi-line assignment. For example, when reading a row from csv.reader(), it makes code more readable (if less efficient) to load the list into named variables with a single assignment.
Starting with a parenthesis avoids long or \ escaped lines.
(a, b,
c) = [1, 2, 3]
(Imagine more and longer variable names)
