# How can I get the concatenation of two lists in Python without modifying either one? [duplicate]

Posted on

### Question :

How can I get the concatenation of two lists in Python without modifying either one? [duplicate]

In Python, the only way I can find to concatenate two lists is `list.extend`, which modifies the first list. Is there any concatenation function that returns its result without modifying its arguments?

Yes: `list1 + list2`. This gives a new list that is the concatenation of `list1` and `list2`.

The simplest method is just to use the `+` operator, which returns the concatenation of the lists:

`concat = first_list + second_list`

One disadvantage of this method is that twice the memory is now being used . For very large lists, depending on how you’re going to use it once it’s created, `itertools.chain` might be your best bet:

``````>>> import itertools
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = itertools.chain(a, b)
``````

This creates a generator for the items in the combined list, which has the advantage that no new list needs to be created, but you can still use `c` as though it were the concatenation of the two lists:

``````>>> for i in c:
...     print i
1
2
3
4
5
6
``````

If your lists are large and efficiency is a concern then this and other methods from the `itertools` module are very handy to know.

Note that this example uses up the items in `c`, so you’d need to reinitialise it before you can reuse it. Of course you can just use `list(c)` to create the full list, but that will create a new list in memory.

`concatenated_list = list_1 + list_2`

You can also use `sum`, if you give it a `start` argument:

``````>>> list1, list2, list3 = [1,2,3], ['a','b','c'], [7,8,9]
>>> all_lists = sum([list1, list2, list3], [])
>>> all_lists
[1, 2, 3, 'a', 'b', 'c', 7, 8, 9]
``````

This works in general for anything that has the `+` operator:

``````>>> sum([(1,2), (1,), ()], ())
(1, 2, 1)

>>> sum([Counter('123'), Counter('234'), Counter('345')], Counter())
Counter({'1':1, '2':2, '3':3, '4':2, '5':1})

>>> sum([True, True, False], False)
2
``````

With the notable exception of strings:

``````>>> sum(['123', '345', '567'], '')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: sum() can't sum strings [use ''.join(seq) instead]
``````

you could always create a new list which is a result of adding two lists.

``````>>> k = [1,2,3] + [4,7,9]
>>> k
[1, 2, 3, 4, 7, 9]
``````

Lists are mutable sequences so I guess it makes sense to modify the original lists by extend or append.

And if you have more than two lists to concatenate:

``````import operator
from functools import reduce  # For Python 3
list1, list2, list3 = [1,2,3], ['a','b','c'], [7,8,9]
reduce(operator.add, [list1, list2, list3])

# or with an existing list
all_lists = [list1, list2, list3]
It doesn’t actually save you any time (intermediate lists are still created) but nice if you have a variable number of lists to flatten, e.g., `*args`.
When you write `list1 + list2`, you are calling the `__add__` method of `list1`, which returns a new list. in this way you can also deal with `myobject + list1` by adding the `__add__` method to your personal class.