Introduction

Python gives you several ways to combine two lists, and the best one depends on whether you want a new list or want to modify an existing list in place. The difference is small in syntax but important for correctness, memory use, and readability.

Using + Creates a New List

The most direct way to concatenate two lists is the + operator.

1left = [1, 2, 3]
2right = [4, 5, 6]
3
4combined = left + right
5
6print(combined)
7print(left)
8print(right)

This creates a new list and leaves the original inputs unchanged. That makes it a good default when you want clear, predictable behavior.

Using extend() Modifies in Place

If you want to append all elements of one list into another existing list, use extend().

1left = [1, 2, 3]
2right = [4, 5, 6]
3
4left.extend(right)
5
6print(left)
7print(right)

This changes left directly. It can be more memory-efficient than + because it avoids allocating a separate combined list, but that benefit only matters if mutating the original list is acceptable.

Unpacking Is Clean and Flexible

Python also supports iterable unpacking inside list literals. This is especially readable when you are combining more than two sources.

1left = [1, 2, 3]
2right = [4, 5, 6]
3extra = [7, 8]
4
5combined = [*left, *right, *extra]
6print(combined)

This still creates a new list, but it scales nicely when you want to combine several iterables in one expression.

itertools.chain() Is Useful for Lazy Iteration

Sometimes you do not actually need a materialized combined list yet. If you only need to iterate through the values, itertools.chain() avoids building a new list immediately.

1from itertools import chain
2
3left = [1, 2, 3]
4right = [4, 5, 6]
5
6for value in chain(left, right):
7    print(value)

If you later need a real list, you can still convert it:

1from itertools import chain
2
3combined = list(chain([1, 2], [3, 4]))
4print(combined)

append() Is Not Concatenation

One beginner mistake is using append() when the goal is concatenation.

1left = [1, 2, 3]
2right = [4, 5, 6]
3
4left.append(right)
5print(left)

This produces a nested list, not a flat combined list. The result is [1, 2, 3, [4, 5, 6]], which is usually not what you want.

Which Method Should You Choose

Use the method that matches the real requirement:

• Use + when you want a new combined list.
• Use extend() when you want to modify one list in place.
• Use unpacking when readability matters across multiple inputs.
• Use chain() when lazy iteration is enough.

In most everyday code, + and extend() are the two answers you will reach for most often.

Performance and Intent

Micro-optimizing list concatenation is rarely the bottleneck in normal Python programs. Clarity usually matters more than chasing tiny differences. A readable left + right is often better than a more clever-looking construct unless you are in a genuinely performance-sensitive loop.

That said, repeatedly doing result = result + another_list inside a loop can be wasteful because each step creates a new list. If you are accumulating many lists over time, extend() or a different data-flow pattern may be more appropriate.

Combining Other Iterables

Remember that not every iterable is a list. If one side is a tuple, generator, or set, methods like extend() still work because they accept any iterable.

1left = [1, 2, 3]
2right = (4, 5, 6)
3
4left.extend(right)
5print(left)

The result is still a list. That can be convenient, but it also means you should be aware of the target type you want to preserve.

Common Pitfalls

The biggest pitfall is using append() and accidentally creating a nested list. If the goal is a flat sequence, use extend() or +.

Another issue is forgetting that extend() mutates the original list. If other parts of your program still rely on the old value, in-place modification can introduce surprising bugs.

Developers also assume chain() returns a list. It does not. It returns an iterator, which is excellent for iteration but not for code that expects list methods or indexing.

Finally, do not ignore readability. Python gives you several valid ways to combine lists, but the simplest correct one is usually the best.

Summary

• 'left + right creates a new combined list.'
• 'left.extend(right) modifies left in place.'
• Unpacking with [*left, *right] is a clean way to combine multiple iterables.
• 'itertools.chain() is best when you want lazy iteration instead of an immediate list.'
• 'append() adds one object and therefore does not perform list concatenation.'