Automatically extend a Python list to N elements if it's too short?

Question

What is the best way in Python to automatically extend a list to N elements, if the list has fewer than N elements?

That is, let's have I have this string: s = "hello there". If I do this:

x, y, z = s.split()

I will get an error, because s.split() returns a list of two elements, but I'm assigning it to 3 variables. What I want is for z to be assigned None.

I know I can do this the hard way:

l = s.split()
while len(l) < 3:
    l.append(None)
x, y, z = l

But there has to be something more elegant than this.

Answer 1

If you want a one-liner, do:

s = "hello there"
x, y, z, *_ = s.split() + [None, None, None]

print(x, y, z)

Output

hello there None

Note that a one-liner is not necessarily more readable nor more elegant. A variation, thanks to @Grismar is:

x, y, z, *_ = s.split() + [None] * 3

Answer 2

extend adds an iterable to the end of a list, so you can do:

l.extend(None for _ in range(3 - len(l))

or

l.extend([None]*(3-len(l)))

which is a bit more elegant but slightly slower because it needs to construct the list of Nones first.

Answer 3

This sort of application is exactly what the padnone recipe in itertools is for (https://docs.python.org/3/library/itertools.html#itertools-recipes):

x, y, z = itertools.islice(itertools.chain(s.split(), itertools.repeat(None)), 3)

The above also incorporates take to get just 3 elements.

Answer 4

Here's a mildly amusing solution using itertools.zip_longest: the behaviour is to use None to fill in the missing elements in the shorter sequence.

from itertools import zip_longest

(x, _), (y, _), (z, _) = zip_longest(s.split(), range(3))

Like your original code, this will throw an error if s.split() has more than three parts. If you prefer to silently discard the extra parts, destructure to (x, _), (y, _), (z, _), *_ instead.

Answer 5

An alternative approach would be to assign z to a blank string using partition.

s = "hello there" 
x, z, y = s.partition(' ')

This approach cuts to the chase. In doing so, it leaves z assigned to a blank instead of None.

Answer 6

A flexible decorator-based solution inspired by this and this answer:

from itertools import islice, chain, repeat

def variable_return(max_values, default=None):
    def decorator(f):
        def wrapper(*args, **kwargs):
            return islice(chain(f(*args, **kwargs), repeat(default)), max_values)
        return wrapper
    return decorator

Or a pointlessly condensed version:

variable_return = lambda m, d=None: lambda f: lambda *a, **k: islice(chain(f(*a, **k), repeat(d)), m)

It can be used like this:

@variable_return(3)
def split(s):
    return s.split()

x, y, z = split(s) # ('hello', 'there', None)

or like this:

x, y, z = variable_return(3)(s.split)() # ('hello', 'there', None)

Answer 7

You could add the single-item list [None] the required number of times (edit: similar to this but without using extend):

l += [None]*(3-len(l))