How do I concatenate two lists in Python?

Asked 2023-09-20 20:18:55 View 843,561

How do I concatenate two lists in Python?

Example:

listone = [1, 2, 3]
listtwo = [4, 5, 6]

Expected outcome:

>>> joinedlist
[1, 2, 3, 4, 5, 6]
  • Do you want to simply append, or do you want to merge the two lists in sorted order? What output do you expect for [1,3,6] and [2,4,5]? Can we assume both sublists are already sorted (as in your example)? - anyone
  • ...also what if the lists have duplicates e.g. [1,2,5] and [2,4,5,6]? Do you want the duplicates included, excluded, or don't-care? - anyone
  • I made a youtube tutorial on 6 ways to concatenate lists if anyone finds it useful youtube.com/watch?v=O5kJ1v9XrDw - anyone

Answers

Use the + operator to combine the lists:

listone = [1, 2, 3]
listtwo = [4, 5, 6]

joinedlist = listone + listtwo

Output:

>>> joinedlist
[1, 2, 3, 4, 5, 6]

Answered   2023-09-20 20:18:55

  • does this create a deep copy of listone and appends listtwo? - anyone
  • @Daniel it will create a new list with a shallow copy of the items in the first list, followed by a shallow copy of the items in the second list. Use copy.deepcopy to get deep copies of lists. - anyone
  • another useful detail here: listone += listtwo results in listone == [1, 2, 3, 4, 5, 6] - anyone
  • @br1ckb0t will that change what listone is pointing at? So:list3 = listone listone+=listtwo Is list3 changed as well? - anyone
  • @Pygmalion That is not Python3 specific, but specific to how NumPy arrays handle operators. See the answer by J.F. Sebastian in the answer by Robert Rossney for concatenating NumPy arrays. - anyone

Python >= 3.5 alternative: [*l1, *l2]

Another alternative has been introduced via the acceptance of PEP 448 which deserves mentioning.

The PEP, titled Additional Unpacking Generalizations, generally reduced some syntactic restrictions when using the starred * expression in Python; with it, joining two lists (applies to any iterable) can now also be done with:

>>> l1 = [1, 2, 3]
>>> l2 = [4, 5, 6]
>>> joined_list = [*l1, *l2]  # unpack both iterables in a list literal
>>> print(joined_list)
[1, 2, 3, 4, 5, 6]

This functionality was defined for Python 3.5, but it hasn't been backported to previous versions in the 3.x family. In unsupported versions a SyntaxError is going to be raised.

As with the other approaches, this too creates as shallow copy of the elements in the corresponding lists.


The upside to this approach is that you really don't need lists in order to perform it; anything that is iterable will do. As stated in the PEP:

This is also useful as a more readable way of summing iterables into a list, such as my_list + list(my_tuple) + list(my_range) which is now equivalent to just [*my_list, *my_tuple, *my_range].

So while addition with + would raise a TypeError due to type mismatch:

l = [1, 2, 3]
r = range(4, 7)
res = l + r

The following won't:

res = [*l, *r]

because it will first unpack the contents of the iterables and then simply create a list from the contents.

Answered   2023-09-20 20:18:55

  • A nice example of the unpacking approach working on iterable types is functions that return an iterator over one of the lists you're concatenating. For example, you could reverse one of the lists you're concatenating: res = [*l1, *reversed(l2)]. Since reversed returns an iterator, res = l1 + reversed(l2) would throw an error. - anyone
  • It's worth noting that this is analogous to combining dictionary's in python. dict3 = {**dict1, **dict2}. Notice that we use ** to unpack the dictionary's whereas with lists we use * to unpack. - anyone
  • The grammar nazy in me has to point out: *dictionaries - anyone
  • @KevinS This only works with string keys, since the ** syntax only supports string keys. - anyone
  • Very interesting. Do you have I idea of what is the performance of this method compare to the addition? - anyone

It's also possible to create a generator that simply iterates over the items in both lists using itertools.chain(). This allows you to chain lists (or any iterable) together for processing without copying the items to a new list:

import itertools
for item in itertools.chain(listone, listtwo):
    # Do something with each list item

Answered   2023-09-20 20:18:55

  • chain is on the slower side (but not by much) for two lists, but is the fastest solution for chaining multiple lists (n >> 2). - anyone
  • @cs95 slow compared to what? - anyone
  • @Moberg Compared to other ways of concatenating lists, for reference please see my benchmarks here. - anyone
  • @cs95 Your benchmarks uses chain to make an iterator over all the elements but the converts the result to a list. Sometimes that's exactly what you want, but if you simply want to iterate over all the elements you can simply use the iterator from chain. That's probably a lot faster. - anyone

How do I concatenate two lists in Python?

As of 3.9, these are the most popular stdlib methods for concatenating two (or more) lists in Python.

Version Restrictions In-Place? Generalize?*
a + b - No sum(list_of_lists, [])1
list(chain(a, b))2 >=2.3 No list(chain(*list_of_lists))
[*a, *b]3 >=3.5 No No
a += b - Yes No
a.extend(b) - Yes No

* A solution will qualify as a generalized solution if it works for an unknown number of lists (say, inside a loop or list comprehension)

Footnotes

  1. This is a slick solution because of its succinctness. But sum performs concatenation in a pairwise fashion, which means this is a quadratic operation as memory has to be allocated for each step. DO NOT USE if your lists are large.

  2. See chain and chain.from_iterable from the docs. You will need to from itertools import chain first. Concatenation is linear in memory, so this is the best in terms of performance and version compatibility. chain.from_iterable was introduced in 2.6.

  3. This method uses Additional Unpacking Generalizations (PEP 448), but cannot generalize to N lists unless you manually unpack each one yourself.

  4. a += b and a.extend(b) are more or less equivalent for all practical purposes. += when called on a list will internally call list.__iadd__, which extends the first list by the second.


Performance

2-List Concatenation1

enter image description here

There's not much difference between these methods but that makes sense given they all have the same order of complexity (linear). There's no particular reason to prefer one over the other except as a matter of style.

N-List Concatenation

enter image description here

Plots have been generated using the perfplot module. Code, for your reference.

1. The iadd (+=) and extend methods operate in-place, so a copy has to be generated each time before testing. To keep things fair, all methods have a pre-copy step for the left-hand list which can be ignored.


Comments on Other Solutions

  • DO NOT USE THE DUNDER METHOD list.__add__ directly in any way, shape or form. In fact, stay clear of dunder methods, and use the operators and operator functions like they were designed for. Python has careful semantics baked into these which are more complicated than just calling the dunder directly. Here is an example. So, to summarise, a.__add__(b) => BAD; a + b => GOOD.

  • Some answers here offer reduce(operator.add, [a, b]) for pairwise concatenation -- this is the same as sum([a, b], []) only more wordy.

  • Any method that uses set will drop duplicates and lose ordering. Use with caution.

  • for i in b: a.append(i) is more wordy, and slower than a.extend(b), which is single function call and more idiomatic. append is slower because of the semantics with which memory is allocated and grown for lists. See here for a similar discussion.

  • heapq.merge will work, but its use case is for merging sorted lists in linear time. Using it in any other situation is an anti-pattern.

  • yielding list elements from a function is an acceptable method, but chain does this faster and better (it has a code path in C, so it is fast).

  • operator.add(a, b) is an acceptable functional equivalent to a + b. It's use cases are mainly for dynamic method dispatch. Otherwise, prefer a + b which is shorter and more readable, in my opinion. YMMV.

Answered   2023-09-20 20:18:55

  • the answers to stackoverflow.com/q/36863404/125507 could use a perfplot plot (including the numba solution) - anyone
  • @endolith bit swamped with work but I'll take a look and see if I can chip in. Ty. - anyone
  • which is the best method then performance wise, faster one? please tell. - anyone
  • @ganeshdeshmukh The TL;DR is they're all good and which one you pick is mostly a matter of style. "There's not much difference between these methods but that makes sense given they all have the same order of complexity (linear). There's no particular reason to prefer one over the other except as a matter of style." Solutions not listed in my answer, or critized in "Comments" I recommend to not use. - anyone
  • @cs95 I make some significant corrections to the table. You can revert if you don't agree - anyone

You could also use the list.extend() method in order to add a list to the end of another one:

listone = [1,2,3]
listtwo = [4,5,6]

listone.extend(listtwo)

If you want to keep the original list intact, you can create a new list object, and extend both lists to it:

mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

Answered   2023-09-20 20:18:55

  • Why does this method returns None in my case? - anyone
  • listone = [1,2,3]; listtwo = [4,5,6]; listone.extend(listtwo) this returns me None - anyone
  • It does an in place update to listone. So check that is in the list listone - anyone
  • actually I'm returning a expression where I'm extending a list using the method you've mentioned. I'm not re-assigning the list as said in this post. My expression is something like return list1.extend(list2) and the this expression returns None to me. - anyone
  • @Ayush the extend method updates listone with the values from listtwo and returns None. You want to do: listone.extend(listtwo) followed by return listone - anyone

You can use sets to obtain merged list of unique values

mergedlist = list(set(listone + listtwo))

Answered   2023-09-20 20:18:55

  • True, however, it will also remove duplicates, if that's what you are interested in. List addition along would not do that. - anyone
  • What is the way to do that and keep the ordering information? - anyone
  • Better than listone + [x for x in listtwo if x not in listone] - anyone
  • +1 IMHO this is the correct way to "merge" (union) lists while the "approved" answer describes how to combine/add lists (multiset) - anyone
  • If you care about maintaining input order, then import collections; mergedlist = list(collections.OrderedDict.fromkeys(listone + listtwo)) will do the trick. - anyone

This is quite simple, and I think it was even shown in the tutorial:

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]

Answered   2023-09-20 20:18:55

This question directly asks about joining two lists. However it's pretty high in search even when you are looking for a way of joining many lists (including the case when you joining zero lists).

I think the best option is to use list comprehensions:

>>> a = [[1,2,3], [4,5,6], [7,8,9]]
>>> [x for xs in a for x in xs]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

You can create generators as well:

>>> map(str, (x for xs in a for x in xs))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

Old Answer

Consider this more generic approach:

a = [[1,2,3], [4,5,6], [7,8,9]]
reduce(lambda c, x: c + x, a, [])

Will output:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Note, this also works correctly when a is [] or [[1,2,3]].

However, this can be done more efficiently with itertools:

a = [[1,2,3], [4,5,6], [7,8,9]]
list(itertools.chain(*a))

If you don't need a list, but just an iterable, omit list().

Update

Alternative suggested by Patrick Collins in the comments could also work for you:

sum(a, [])

Answered   2023-09-20 20:18:55

  • Python 3 note: reduce is now in functools so you'll need to import it first. - anyone

You could simply use the + or += operator as follows:

a = [1, 2, 3]
b = [4, 5, 6]

c = a + b

Or:

c = []
a = [1, 2, 3]
b = [4, 5, 6]

c += (a + b)

Also, if you want the values in the merged list to be unique you can do:

c = list(set(a + b))

Answered   2023-09-20 20:18:55

  • The last part can arbitrarily re-order the items. If you want to preserve order, on CPython 3.6+ you can do list(dict.fromkeys(a + b)) - anyone

It's worth noting that the itertools.chain function accepts variable number of arguments:

>>> l1 = ['a']; l2 = ['b', 'c']; l3 = ['d', 'e', 'f']
>>> [i for i in itertools.chain(l1, l2)]
['a', 'b', 'c']
>>> [i for i in itertools.chain(l1, l2, l3)]
['a', 'b', 'c', 'd', 'e', 'f']

If an iterable (tuple, list, generator, etc.) is the input, the from_iterable class method may be used:

>>> il = [['a'], ['b', 'c'], ['d', 'e', 'f']]
>>> [i for i in itertools.chain.from_iterable(il)]
['a', 'b', 'c', 'd', 'e', 'f']

Answered   2023-09-20 20:18:55

For cases with a low number of lists you can simply add the lists together or use in-place unpacking (available in Python-3.5+):

In [1]: listone = [1, 2, 3] 
   ...: listtwo = [4, 5, 6]                                                                                                                                                                                 

In [2]: listone + listtwo                                                                                                                                                                                   
Out[2]: [1, 2, 3, 4, 5, 6]
                                                                                                                                                                                     
In [3]: [*listone, *listtwo]                                                                                                                                                                                
Out[3]: [1, 2, 3, 4, 5, 6]

As a more general way for cases with more number of lists you can use chain.from_iterable()1 function from itertools module. Also, based on this answer this function is the best; or at least a very good way for flatting a nested list as well.

>>> l=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> import itertools
>>> list(itertools.chain.from_iterable(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

1. Note that `chain.from_iterable()` is available in Python 2.6 and later. In other versions, use `chain(*l)`.

Answered   2023-09-20 20:18:55

With Python 3.3+ you can use yield from:

listone = [1,2,3]
listtwo = [4,5,6]

def merge(l1, l2):
    yield from l1
    yield from l2

>>> list(merge(listone, listtwo))
[1, 2, 3, 4, 5, 6]

Or, if you want to support an arbitrary number of iterators:

def merge(*iters):
    for it in iters:
        yield from it

>>> list(merge(listone, listtwo, 'abcd', [20, 21, 22]))
[1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 20, 21, 22]

Answered   2023-09-20 20:18:55

If you want to merge the two lists in sorted form, you can use the merge function from the heapq library.

from heapq import merge

a = [1, 2, 4]
b = [2, 4, 6, 7]

print list(merge(a, b))

Answered   2023-09-20 20:18:55

If you can't use the plus operator (+), you can use the operator import:

import operator

listone = [1,2,3]
listtwo = [4,5,6]

result = operator.add(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

Alternatively, you could also use the __add__ dunder function:

listone = [1,2,3]
listtwo = [4,5,6]

result = list.__add__(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

Answered   2023-09-20 20:18:55

  • grabbing dunders is generally not the best approach. If + is off the table, use operator.add. - anyone
  • Why would the plus operator be unavailable? - anyone
  • Normally it wouldn't :) but if you are doing list concatenation with the map function or want to store the add function in a variable, you can't use +. - anyone

If you need to merge two ordered lists with complicated sorting rules, you might have to roll it yourself like in the following code (using a simple sorting rule for readability :-) ).

list1 = [1,2,5]
list2 = [2,3,4]
newlist = []

while list1 and list2:
    if list1[0] == list2[0]:
        newlist.append(list1.pop(0))
        list2.pop(0)
    elif list1[0] < list2[0]:
        newlist.append(list1.pop(0))
    else:
        newlist.append(list2.pop(0))

if list1:
    newlist.extend(list1)
if list2:
    newlist.extend(list2)

assert(newlist == [1, 2, 3, 4, 5])

Answered   2023-09-20 20:18:55

Use a simple list comprehension:

joined_list = [item for list_ in [list_one, list_two] for item in list_]

It has all the advantages of the newest approach of using Additional Unpacking Generalizations - i.e. you can concatenate an arbitrary number of different iterables (for example, lists, tuples, ranges, and generators) that way - and it's not limited to Python 3.5 or later.

Answered   2023-09-20 20:18:55

If you are using NumPy, you can concatenate two arrays of compatible dimensions with this command:

numpy.concatenate([a,b])

Answered   2023-09-20 20:18:55

  • @cs95 it doesn't 'not ask' for numpy as well. I should say this actually helped me since the plus operator wasn't working for my application - anyone

All the possible ways to join lists that I could find

import itertools

A = [1,3,5,7,9] + [2,4,6,8,10]

B = [1,3,5,7,9]
B.append([2,4,6,8,10])

C = [1,3,5,7,9]
C.extend([2,4,6,8,10])

D = list(zip([1,3,5,7,9],[2,4,6,8,10]))
E = [1,3,5,7,9]+[2,4,6,8,10]
F = list(set([1,3,5,7,9] + [2,4,6,8,10]))

G = []
for a in itertools.chain([1,3,5,7,9], [2,4,6,8,10]):
    G.append(a)


print("A: " + str(A))
print("B: " + str(B))
print("C: " + str(C))
print("D: " + str(D))
print("E: " + str(E))
print("F: " + str(F))
print("G: " + str(G))

Output

A: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
B: [1, 3, 5, 7, 9, [2, 4, 6, 8, 10]]
C: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
D: [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
E: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
F: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
G: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

Answered   2023-09-20 20:18:55

Another way:

>>> listone = [1, 2, 3]
>>> listtwo = [4, 5, 6]
>>> joinedlist = [*listone, *listtwo]
>>> joinedlist
[1, 2, 3, 4, 5, 6]
>>> 

Answered   2023-09-20 20:18:55

  • How does [*a, *b] improve on a + b? - anyone
list(set(listone) | set(listtwo))

The above code does not preserve order and removes duplicates from each list (but not from the concatenated list).

Answered   2023-09-20 20:18:55

As already pointed out by many, itertools.chain() is the way to go if one needs to apply exactly the same treatment to both lists. In my case, I had a label and a flag which were different from one list to the other, so I needed something slightly more complex. As it turns out, behind the scenes itertools.chain() simply does the following:

for it in iterables:
    for element in it:
        yield element

(see https://docs.python.org/2/library/itertools.html), so I took inspiration from here and wrote something along these lines:

for iterable, header, flag in ( (newList, 'New', ''), (modList, 'Modified', '-f')):
    print header + ':'
    for path in iterable:
        [...]
        command = 'cp -r' if os.path.isdir(srcPath) else 'cp'
        print >> SCRIPT , command, flag, srcPath, mergedDirPath
        [...]

The main points to understand here are that lists are just a special case of iterable, which are objects like any other; and that for ... in loops in python can work with tuple variables, so it is simple to loop on multiple variables at the same time.

Answered   2023-09-20 20:18:55

You could use the append() method defined on list objects:

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)

Answered   2023-09-20 20:18:55

 a = [1, 2, 3]
 b = [4, 5, 6]
     
 c = a + b
 print(c)

Output

>>> [1, 2, 3, 4, 5, 6]

In the above code, the "+" operator is used to concatenate the two lists into a single list.

Another solution

 a = [1, 2, 3]
 b = [4, 5, 6]
 c = [] # Empty list in which we are going to append the values of list (a) and (b)

 for i in a:
     c.append(i)
 for j in b:
     c.append(j)

 print(c)

Output

>>> [1, 2, 3, 4, 5, 6]

Answered   2023-09-20 20:18:55

I recommend three methods to concatenate the list, but the first method is most recommended,

# Easiest and least complexity method <= recommended

listone = [1, 2, 3]
listtwo = [4, 5, 6]

newlist = listone + listtwo
print(newlist)

# Second-easiest method
newlist = listone.copy()
newlist.extend(listtwo)
print(newlist)

In the second method, I assign newlist to a copy of the listone, because I don't want to change listone.

# Third method
newlist = listone.copy()
for j in listtwo:
    newlist.append(j)

print(newlist)

This is not a good way to concatenate lists because we are using a for loop to concatenate the lists. So time complexity is much higher than with the other two methods.

Answered   2023-09-20 20:18:55

The most common method used to concatenate lists are the plus operator and the built-in method append, for example:

list = [1,2]

list = list + [3]
# list = [1,2,3]

list.append(3)
# list = [1,2,3]

list.append([3,4])
# list = [1,2,[3,4]]

For most of the cases, this will work, but the append function will not extend a list if one was added. Because that is not expected, you can use another method called extend. It should work with structures:

list = [1,2]
list.extend([3,4])
# list = [1,2,3,4]

Answered   2023-09-20 20:18:55

A really concise way to combine a list of lists is

list_of_lists = [[1,2,3], [4,5,6], [7,8,9]]
reduce(list.__add__, list_of_lists)

which gives us

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Answered   2023-09-20 20:18:55

  • Please do not use list.__add__, use operator.add instead. This is the more wordy equivalent of sum(list_of_lists, []) which is just as bad. DO NOT USE! - anyone
  • @cs95 can you explain what’s the issue by using list.__add__ - anyone
  • dunder methods are "private methods" and should typically not be used directly (they are called by other functions). Exceptions are obj.__class__ and obj.__dict__. - anyone
  • And if __add__ seems too low-level and unstable (prone to change), you can use np.union1d instead. - anyone

So there are two easy ways.

  1. Using +: It creates a new list from provided lists

Example:

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: a + b
Out[3]: [1, 2, 3, 4, 5, 6]

In [4]: %timeit a + b
10000000 loops, best of 3: 126 ns per loop
  1. Using extend: It appends new list to existing list. That means it does not create a separate list.

Example:

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: %timeit a.extend(b)
10000000 loops, best of 3: 91.1 ns per loop

Thus we see that out of two of most popular methods, extend is efficient.

Answered   2023-09-20 20:18:55

  • What if i need to add multiple lists, like a+b+c+d+e? - anyone
  • @Tweakimp See this answer which has a couple of options (I recommend chain.from_iterable). - anyone

You could also just use sum.

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> sum([a, b], [])
[1, 2, 3, 4, 5, 6]
>>>

This works for any length and any element type of list:

>>> a = ['a', 'b', 'c', 'd']
>>> b = [1, 2, 3, 4]
>>> c = [1, 2]
>>> sum([a, b, c], [])
['a', 'b', 'c', 'd', 1, 2, 3, 4, 1, 2]
>>>

The reason I add [], is because the start argument is set to 0 by default, so it loops through the list and adds to start, but 0 + [1, 2, 3] would give an error, so if we set the start to []. It would add to [], and [] + [1, 2, 3] would work as expected.

Answered   2023-09-20 20:18:55

I assume you want one of the two methods:

Keep duplicate elements

It is very easy. Just concatenate like a string:

def concat_list(l1,l2):
    l3 = l1+l2
    return l3

Next, if you want to eliminate duplicate elements

def concat_list(l1,l2):
   l3 = []
   for i in [l1,l2]:
     for j in i:
       if j not in l3:
         # Check if element exists in final list, if no then add element to list
         l3.append(j)
   return l3

Answered   2023-09-20 20:18:55

The solutions provided are for a single list. In case there are lists within a list and the merging of corresponding lists is required, the "+" operation through a for loop does the work.

a = [[1,2,3], [4,5,6]]

b = [[0,1,2], [7,8,9]]

for i in range(len(a)):
    cc.append(a[i] + b[i])

Output: [[1, 2, 3, 0, 1, 2], [4, 5, 6, 7, 8, 9]]

Answered   2023-09-20 20:18:55