Concatenate An Arbitrary Number Of Lists In A Function In Python

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 w

Solution 1:

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:

defconcatenate(*lists):
    return itertools.chain(*lists)

or

defconcatenate(*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=0end=0for 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,[])

Solution 2:

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

importoperator
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
defconcatenate(*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).

Solution 3:

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

defjoin_lists(*lists):
    returnsum(lists, [])

For example:

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

Solution 4:

Another way:

>>>m = [1, 2, 3]>>>n = [4, 5, 6]>>>o = [7, 8, 9]>>>p = []>>>for (i, j, k) in (m, n, o):...    p.append(i)...    p.append(j)...    p.append(k)...>>>p
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

Solution 5:

This seems to work just fine:

def join_lists(*args):
    output = []
    for lst in args:
        output += lst
    returnoutput

It returns a new list with all the items of the previous lists. Is using + not appropriate for this kind of list processing?