[Python-ideas] How assignment should work with generators?

Paul Moore p.f.moore at gmail.com
Fri Dec 1 05:17:28 EST 2017

On 1 December 2017 at 09:48, Kirill Balunov <kirillbalunov at gmail.com> wrote:
> Probably, some time ago it was necessary to split this thread into two
> questions:
> 1. Philosophical question regarding sequences and iterators. In particular,
> should they behave differently depending on the context,
> or, in other words, whether to emphasize their different nature as
> fixed-size containers and those that are lazily produce values on demand.
> 2. Additional syntax in the assignment statement for partial extraction of
> values from the iterable.

That's a good summary of the two elements of the discussion here.

On (1), I'd say that Python should *not* have context-dependent
semantics like this. It's something Perl was famous for (list and
scalar contexts) and IMO makes for pretty unreadable code. Python's
Zen here is "Explicit is better than implicit". Specifically, having
the semantics of the assignment statement vary depending on the type
of the value being assigned seems like a very subtle distinction, and
not in line with any other statement in the language.

On (2), that's something that is relatively simple to debate - all of
the normal rules for new syntax proposals apply - what problem does it
solve, how much of an improvement over existing ways of solving the
problem does the proposal give, how easy is it for beginners to
understand and for people encountering it to locate the documentation,
does it break backward compatibility, etc... Personally I don't think
it's a significant enough benefit but I'm willing to be swayed if good
enough arguments are presented (currently the "a, b, ... = value"
syntax is my preferred proposal, but I don't think there's enough
benefit to justify implementing it).

> 2017-11-30 22:19 GMT+03:00 Paul Moore <p.f.moore at gmail.com>:
>> Mostly corner cases, and I don't believe there have been any
>> non-artificial examples posted in this thread.
>> Certainly no-one has offered a real-life code example that is made
>> significantly worse by
>> the current semantics, and/or which couldn't be easily worked around
>> without needing a language change.
> Yes, in fact, this is a good question, is whether that is sufficiently
> useful to justify extending the syntax. But it is not about corner cases, it
> is rather usual situation.
> Nevertheless, this is the most difficult moment for Rationale. By now, this
> feature does not give you new opportunities for solving problems. It's more
> about expressiveness and convenience. You can write:
> x, y, ... = iterable
> or,
> it = iter(iterable)
> x, y = next(it), next(it)
> or,
> from itertools import isclice
> x, y = islice(iterable, 2)
> or,
> x, y = iterable[:2]
> and others, also in some cases when you have infinite generator or iterator,
> you should use 2nd or 3rd.

It's significant to me that you're still only able to offer artificial
code as examples. In real code, I've certainly needed this type of
behaviour, but it's never been particularly problematic to just use

    first_result = next(it)
    second_result - next(it)

Or if I have an actual sequence, x, y = seq[:2]

The next() approach actually has some issues if the iterator
terminates early - StopIteration is typically not the exception I
want, here. But all that means is that I should use islice more. The
reason i don't think to is because I need to import it from itertools.
But that's *not* a good argument - we could use the same argument to
make everything a builtin. Importing functionality from modules is
fundamental to Python, and "this is a common requirement, so it should
be a builtin" is an argument that should be treated with extreme
suspicion. What I *don't* have a problem with is the need to specify
the number of items - that seems completely natural to me, I'm
confirming that I require an iterable that has at least 2 elements at
this point in my code.

The above is an anecdotal explanation of my experience with real code
- still not compelling, but hopefully better than an artificial
example with no real-world context :-)

> In fact, this has already been said and probably
> I will not explain it better:
> 2017-11-28 1:40 GMT+03:00 Greg Ewing <greg.ewing at canterbury.ac.nz>:
>> Guido van Rossum wrote:
>>> Is this problem really important enough that it requires dedicated
>>> syntax? Isn't the itertools-based solution good enough?
>> Well, it works, but it feels very clumsy. It's annoying to
>> have to specify the number of items in two places.
>> Also, it seems perverse to have to tell Python to do *more*
>> stuff to mitigate the effects of stuff it does that you
>> didn't want it to do in the first place.
>> Like I said, I'm actually surprised that this doesn't already
>> work. To me it feels more like filling in a piece of
>> functionality that was overlooked, rather than adding a
>> new feature. Filling in a pothole in the road rather than
>> bulding a new piece of road.
>> (Pushing the road analogy maybe a bit too far, the current
>> itertools solution is like digging *more* potholes to make
>> the road bumpy enough that you don't notice the first
>> pothole.)
>>> (Or failing that, couldn't we add something to itertools to make it more
>>> readable rather than going straight to new syntax?)
>> I'm not sure how we would do that. Even if we could, it
>> would still feel clumsy having to use anything from itertools
>> at all.

I'm typically suspicious of arguments based on "filling in the gaps"
of existing functionality (largely because it's a fault I'm prone to
myself). It's very easy to argue that way for features you'll never
actually need in practice - so a "completeness" argument that's not
backed up with real-world examples of use cases is weak, at least to

And I've already commented above on my views of the "it would still
feel clumsy having to use anything from itertools" argument.


More information about the Python-ideas mailing list