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

Answer 1

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 2

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))

Answer 3

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 4

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 5

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 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)