Hello. Currently during star assignement the new list is created.
What was the idea to produce new list instead of returning an iterator?
It seems to me that returning an iterator more suited to the spirit of Python 3.
There are three cases:

1. a,b,c,*d = something_iterable
2. *a,b,c,d = something_iterable
3. a,*b,c,d = something_iterable

The first one is obvious. For the rest two we always need to iterate through
entire iterable to achieve values for b,c,d (or c,d) binding. But this can be done
more memory effiecient than currently (may be I'm wrong). And we can iterate in
space of last three (or two) variables. Some rough (simplified) Python code:

from itertools import islice, chain
from collections import deque

def good_star_exp(signature, seq):
    if signature.count('*') > 1:
        raise SyntaxError('two starred expressions in assignment')
    vrs = signature.split(',')
    idx_max = len(vrs) - 1
    star_pos, = (i for i,v in enumerate(vrs) if '*' in v)
    #First case
    if star_pos == idx_max:
        head = islice(seq, idx_max)
        tail = islice(seq, idx_max, None)
        return chain(head, (tail,))
    #Second case
    elif star_pos == 0:
        tail = deque(maxlen=idx_max)      
        for seq_idx_max, v in enumerate(seq):
        head = islice(seq, 0, seq_idx_max-(idx_max-1))      
        return chain([head], tail)
    #Third case
        head = islice(seq, star_pos)
        tail = deque(maxlen=(idx_max-star_pos)) 
        for seq_idx_max, v in enumerate(seq):
        mid = islice(seq, star_pos, seq_idx_max-(idx_max-2))
        return chain(head, [mid], tail)
ls = range(100000)
a,b,c,d = good_star_exp('a,b,c,*d', ls)
a,b,c,d = good_star_exp('*a,b,c,d', ls)
a,b,c,d = good_star_exp('a,*b,c,d', ls)

Of course this version has drawbacks (the first that come to mind):
1. Will *b see change if rhs is some muttable sequence?
2. Will *b one way iterator or somethong like range?

But still it seems to me that the "iterator way" has more useful applications.

With best regards, -gdg