concatenate an arbitrary number of lists in a function in Python

Question

I hope to write the join_lists function to take an arbitrary number of lists and concatenate them. For example, if the inputs are

m = [1, 2, 3]
n = [4, 5, 6]
o = [7, 8, 9]

then we I call print join_lists(m, n, o), it will return [1, 2, 3, 4, 5, 6, 7, 8, 9]. I realize I should use *args as the argument in join_lists, but not sure how to concatenate an arbitrary number of lists. Thanks.

Answer 1

One way would be this (using reduce) because I currently feel functional:

import operator
from functools import reduce
def concatenate(*lists):
    return reduce(operator.add, lists)

However, a better functional method is given in Marcin's answer:

from itertools import chain
def concatenate(*lists):
    return chain(*lists)

although you might as well use itertools.chain(*iterable_of_lists) directly.

A procedural way:

def concatenate(*lists):
    new_list = []
    for i in lists:
        new_list.extend(i)
    return new_list

A golfed version: j=lambda*x:sum(x,[]) (do not actually use this).

Answer 2

Although you can use something which invokes __add__ sequentially, that is very much the wrong thing (for starters you end up creating as many new lists as there are lists in your input, which ends up having quadratic complexity).

The standard tool is itertools.chain:

def concatenate(*lists):
    return itertools.chain(*lists)

or

def concatenate(*lists):
    return itertools.chain.from_iterable(lists)

This will return a generator which yields each element of the lists in sequence. If you need it as a list, use list: list(itertools.chain.from_iterable(lists))

If you insist on doing this "by hand", then use extend:

def concatenate(*lists):
    newlist = []
    for l in lists: newlist.extend(l)
    return newlist

Actually, don't use extend like that - it's still inefficient, because it has to keep extending the original list. The "right" way (it's still really the wrong way):

def concatenate(*lists):
    lengths = map(len,lists)
    newlen = sum(lengths)
    newlist = [None]*newlen
    start = 0
    end = 0
    for l,n in zip(lists,lengths):
        end+=n
        newlist[start:end] = list
        start+=n
    return newlist

http://ideone.com/Mi3UyL

You'll note that this still ends up doing as many copy operations as there are total slots in the lists. So, this isn't any better than using list(chain.from_iterable(lists)), and is probably worse, because list can make use of optimisations at the C level.

---

Finally, here's a version using extend (suboptimal) in one line, using reduce:

concatenate = lambda *lists: reduce((lambda a,b: a.extend(b) or a),lists,[])

Answer 3

You can use sum() with an empty list as the start argument:

def join_lists(*lists):
    return sum(lists, [])

For example:

>>> join_lists([1, 2, 3], [4, 5, 6])
[1, 2, 3, 4, 5, 6]