Adding lists together in Python means combining multiple sequences into one ordered collection. You can merge lists with different techniques that affect performance, clarity, and memory usage.
This guide walks through practical patterns for joining lists, with a summary table, focused sections, and common questions to help you choose the right approach.
| Method | Syntax | Mutates Original | Best For |
|---|---|---|---|
| plus operator | list_a + list_b | No | Simple, readable concatenation |
| extend method | list_a.extend(list_b) | Yes | In-place updates without creating a new list |
| list unpacking | [*list_a, *list_b] | No | Readable merging in function calls or assignments |
| itertools.chain | list(chain(list_a, list_b)) | No | Memory efficient iteration over many lists |
| sum with empty start | sum([list_a, list_b], []) | No | Quick one-liner for small lists only |
Use the plus operator for simple list concatenation
The plus operator creates a new list by joining the items from both sides. This keeps the original lists unchanged and reads clearly for straightforward cases.
When you write combined = list_one + list_two, Python allocates a new list with all elements in order. Use this style when you need an explicit combined result and prefer a functional pattern without side effects.
Extend lists in place for memory efficiency
The extend method appends elements from another iterable to the end of the list in place. It modifies the left-hand list and returns None, which saves memory when you do not need the original sequence intact.
Call target_list.extend(source_list) when you want to grow a working list inside loops or long pipelines. This is efficient because it avoids creating many intermediate list objects during repeated merges.
Leverage unpacking for inline merging
List unpacking with the star operator lets you merge lists inside literals and function arguments. The syntax [*a, *b] produces a new list with elements in the specified order while keeping code compact.
This approach is handy when constructing new structures from multiple sources in a single line. It remains readable and avoids explicit method calls, which is valuable in comprehensions or complex expressions.
Use itertools.chain for many sequences or lazy evaluation
itertools.chain iterates over multiple inputs without building intermediate lists, which reduces memory pressure for large datasets. Converting the chain to a list with list(chain(sequence_a, sequence_b)) materializes the combined result when needed.
Prefer this pattern when working with many lists or streaming data, because chain processes elements lazily. It keeps performance predictable and supports any iterable, not only concrete lists.
Best practices for combining lists in Python
- Choose plus operator for small, explicit concatenations where immutability is preferred.
- Use extend when updating a working list inside loops to save memory and avoid temporary objects.
- Apply unpacking for clean, single-expression merges in assignments and function calls.
- Leverage itertools.chain for many sequences or when memory efficiency and lazy evaluation matter.
- Avoid sum for list concatenation in performance sensitive code due to higher overhead.
FAQ
Reader questions
What happens when I concatenate very large lists with the plus operator?
Python allocates a new list and copies all elements from both sides, which increases memory usage and can be slow for very large sequences. For big data, prefer extend or itertools.chain to avoid high overhead.
Does extend modify the original list in place, and is it safe in concurrent code?
Yes, extend mutates the list it is called on by appending new items at the end. It is not thread safe by default, so you should use locks or queues when extending shared structures across threads.
Can I merge more than two lists with a single unpacking expression?
Yes, you can include as many starred sequences as you need inside a literal, like result = [*list_a, *list_b, *list_c]. This keeps the code concise and preserves the order of elements from each source list.
Is sum([list1, list2, list3], []) a good way to join lists in production code?
Using sum with lists is inefficient for more than a couple of inputs because it repeatedly creates intermediate results and has quadratic complexity. Use extend, unpacking, or itertools.chain instead for reliable performance.