I ran into a code that calls a function f():
def f():
return 1, []
a, [] = f()
I was wondering why didn't the author use a, _ = f().
Why is this syntax even allowed?
[] = []
a, [] = 444, []
Where can I read more about [] = [] philosophy?
Consider a less strange-looking example:
def f():
return 1, [2, 3]
a, [b, c] = f()
This is an ordinary destructuring assignment; we simple assign a = 1, b = 2 and c = 3 simultaneously. The structure on the left-hand side matches that on the right-hand side (on the left-hand side, we can use [] and () interchangeably, and the corresponding list and tuple objects don't exist after the fact - or at any point; they're purely syntactical here).
The code you have shown is simply the degenerate case of this, where there are zero elements in the sub-sequence. The 1 is assigned to a, and all zero of the elements [] are assigned to zero target names.
I was wondering why not the author used
a, _ = f()
I cannot read the author's mind, but one possible reason:
def f():
return 1, g()
# later:
# precondition: the result from g() must be empty for code correctness
a, [] = f() # implicitly raises ValueError if the condition is not met
This is easy to write, but requires some explanation and is perhaps not the greatest approach. Explicit is better than implicit.
Why is this syntax even allowed
Because special cases aren't special enough to break the rules.
The syntax [] = [] is an edge case of assignment to a target list: it unpacks values from an empty iterable into zero target names.
Python's assignment statement allows multiple assignment by using list or tuple syntax for the targets. The source can be any iterable with the correct number of items.
>>> a, b = range(2)
>>> a
0
>>> (a, b) = {1: "one", 2: "two"}
>>> a
1
>>> [a, b] = {3, 5}
>>> a
3
Notably, the left hand side does not denote an actual tuple/list in this case. It merely defines the structure in which the actual assignment targets a and b are, akin to pattern matching.
As an edge case, the syntax also allows specifying one or zero length assignment lists.
>>> # assign single-element iterable into single name
>>> [a] = {15}
>>> a
15
>>> # assign no-element iterable into no name
>>> [] = []
It is worth pointing out that the left and right hand side [] are fundamentally different things. The right hand side ... = [] denotes an actual list object with no elements. The left hand side [] = ... merely denotes "zero names".
Multiple assignment often serves the two-fold purpose of performing an actual assignment while checking the number of items.
>>> # accept any number of secondary items
>>> a, b = 42, [16, 72]
>>> # accept only one secondary item
>>> a, [b] = 42, [16, 72]
...
ValueError: too many values to unpack (expected 1)
By using an empty target list, one enforces that there is an iterable but that it is empty.
>>> # empty iterable: fine
>>> a, [] = 444, []
>>> # non-empty iterable: error
>>> a, [] = 444, ["oops"]
...
ValueError: too many values to unpack (expected 0)
As already mentioned, this syntax is allowed due to the so-called "pattern-matching" in Python. In this particular case, the list is empty, so Python matches nothing with nothing. If you had more elements in the list, this would actually be helpful, as Karl Knechtel has shown in his answer.
Your example is just a special (and useless) case of pattern matching (for matching 0 elements).
