Improving multiple assignment using an iterator function
I'll look at each of your three examples individually.


Ignoring remaining values

In Python 2:

&gt;&gt;&gt; a, b = 'foo bar is here'.split()[:2]
&gt;&gt;&gt; a, b
('foo', 'bar')


In Python 3 (_ used by convention, double underscore, __, is
also appropriate):

&gt;&gt;&gt; a, b, *_ = 'foo bar is here'.split()
&gt;&gt;&gt; a, b
('foo', 'bar')


When ignoring remaining values, using the built-in language features would be the most Pythonic approach.  I think they're clear enough that they do not need to be re-invented.
Capture remaining values

In Python 2:

&gt;&gt;&gt; split_string = 'foo bar is here'.split()
&gt;&gt;&gt; a, b, c = split_string[2:] + [split_string[2:]]
&gt;&gt;&gt; a, b, c
('is', 'here', ['is', 'here'])


In Python 3:

&gt;&gt;&gt; a, b, *c = 'foo bar is here'.split()
&gt;&gt;&gt; a, b, c
('is', 'here', ['is', 'here'])


In Python 3, the * feature is again more Pythonic than your approach.  In Python 2, that approach won't work if you're dealing with a non-indexable type.
Fill remaining values with None.  Here is a somewhat similar question.  That question and the Python 2 solution only work for lists.

Python 2:

&gt;&gt;&gt; split_string = 'foo bar is here'.split()
&gt;&gt;&gt; a, b, c, d, e = split_string + [None] * (5-len(split_string))
&gt;&gt;&gt; a, b, c, d, e
('foo', 'bar', 'is', 'here', None)


Python 3.5 (this is not very clear in my opinion):

&gt;&gt;&gt; a, b, c, d, e, *_ = *'foo bar is here'.split(), *[None]*5
&gt;&gt;&gt; a, b, c, d, e
('foo', 'bar', 'is', 'here', None)


There isn't really a built-in language construct for this so this case might warrant re-inventing.  However, this kind of None-filling seems rare and may not necessarily be clear to other Python programmers.




A review of your actual implementation

Don't use import * in Python.  In Python we value our namespaces highly because namespaces allow us to see what variables came from what modules.

from itertools import *


Do this instead:

from itertools import chain, islice, repeat


You didn't use use_default in your code at all.  It seems like you could use another islice instead of an enumerate to restructure your code like this:

def iterassign(iterable, *, count, default=None, tail=False):
    it = iter(iterable)
    for x in islice(chain(islice(it, 0, count), repeat(default)), 0, count):
        yield x
    if tail:
        yield list(it)


Iterators are the right solution to this problem (assuming we've decided it's one that needs solving).

If we want to rewrite this to only handle case 3 (because we've already decided we can just use Python's built-in language features for case 1 and 2, we could rewrite like this:

def fill_remaining(iterable, *, length, default=None):
    """Return iterable padded to at least ``length`` long."""
    return islice(chain(iterable, repeat(default)), 0, length)


Which would work like this:

&gt;&gt;&gt; a, b, c, d, e = fill_remaining(ret, length=5)
&gt;&gt;&gt; a, b, c, d, e
('foo', 'bar', 'is', 'here', None)