How to Concatenate Multiple Lists in Python

Joining three or more lists takes one expression. To concatenate multiple lists in Python, chain them with + or unpack them into a new list; for a list of lists, use itertools.chain.from_iterable():

merged = [*a, *b, *c]                       # or a + b + c
merged = list(chain.from_iterable(nested))

Every output below is a real run on Python 3.12.5 in Command Prompt, with US order totals in dollars and 2026 dates.

Concatenate multiple lists with the + operator

The + operator builds a new list and leaves the inputs untouched:

east = [129.99, 45.55, 310.75]
central = [89.95, 220.45]
west = [15.25, 74.85, 199.99, 52.15]

all_orders = east + central + west
print(all_orders)
print(len(all_orders), "orders, total", f"${sum(all_orders):,.2f}")
print(east)                 # unchanged

Output:

[129.99, 45.55, 310.75, 89.95, 220.45, 15.25, 74.85, 199.99, 52.15]
9 orders, total $1,138.93
[129.99, 45.55, 310.75]

It’s clearest when you know the lists by name. For just two, see my guide to appending one list to another in Python.

Join lists in place with extend() and +=

extend() grows an existing list in place instead of building a copy, and a loop handles any number of lists:

q1 = ["2026-01-15", "2026-02-03"]
q2 = ["2026-04-22"]
q3 = ["2026-07-04", "2026-08-19", "2026-09-30"]

shipments = []
for quarter in (q1, q2, q3):
    shipments.extend(quarter)
print(shipments)

shipments += ["2026-10-19"]          # += also extends in place
print(len(shipments))

result = [].extend(q1)               # common mistake
print("extend() returns:", result)

Output:

['2026-01-15', '2026-02-03', '2026-04-22', '2026-07-04', '2026-08-19', '2026-09-30']
7
extend() returns: None

Watch the last line: extend() returns None, so never write x = x.extend(y). The difference between the two list methods is spelled out in extend vs append in Python.

Concatenate lists and tuples with * unpacking

[*a, *b, *c] accepts any iterable and lets you add extra items in between:

texas = ["Austin", "Dallas"]
ohio = ("Columbus", "Cleveland")     # a tuple

stops = [*texas, *ohio, "Denver"]
print(stops)

try:
    texas + ohio
except TypeError as err:
    print("TypeError:", err)

Output:

['Austin', 'Dallas', 'Columbus', 'Cleveland', 'Denver']
TypeError: can only concatenate list (not "tuple") to list

That TypeError is why I use unpacking when the inputs aren’t all lists. More tricks with the star operator are in unpacking a list in Python.

Merge a list of lists with itertools.chain()

When the lists arrive inside another list, like weekly batches, chain.from_iterable() walks them lazily without copying:

from itertools import chain

weekly = [
    [120.35, 75.55],           # week 1
    [310.25],                  # week 2
    [42.99, 18.25, 260.45],    # week 3
]
merged = chain.from_iterable(weekly)
print(type(merged).__name__)   # lazy: nothing copied yet
print(list(merged))
print(list(merged))            # the iterator is used up after one pass

print(list(chain([1, 2], [3], [4, 5])))   # separate lists as arguments
print(f"Month total: ${sum(chain.from_iterable(weekly)):,.2f}")

Output:

chain
[120.35, 75.55, 310.25, 42.99, 18.25, 260.45]
[]
[1, 2, 3, 4, 5]
Month total: $827.84

Use plain chain(a, b, c) for separate lists and from_iterable() for nested ones. New to nesting? Start with a list of lists in Python.

Concatenate and filter lists with a list comprehension

A nested comprehension joins and filters in one pass; read the for clauses outer loop first:

weekly = [[120.35, 75.55], [310.25], [42.99, 18.25, 260.45]]

big = [amount for week in weekly for amount in week if amount >= 100]
print(big)

Output:

[120.35, 310.25, 260.45]

If the syntax is new to you, see Python list comprehension, and deeper nesting is handled in flattening a list of lists in Python.

Why is sum() a bad way to concatenate lists?

sum(lists, []) works only with the empty-list start value, and it builds a new list at every step:

weekly = [[120.35, 75.55], [310.25], [42.99, 18.25, 260.45]]

print(sum(weekly, []))     # works, but copies the list every step
try:
    sum(weekly)            # start value defaults to 0
except TypeError as err:
    print("TypeError:", err)

Output:

[120.35, 75.55, 310.25, 42.99, 18.25, 260.45]
TypeError: unsupported operand type(s) for +: 'int' and 'list'

Without [], Python tries 0 + list and fails. Keep the Python sum() function for numbers.

Which way to concatenate multiple lists is fastest?

I timed each method joining 1,000 lists of 100 prices:

import timeit
from itertools import chain

batches = [[19.99] * 100 for _ in range(1_000)]

def extend_loop():
    out = []
    for b in batches:
        out.extend(b)
    return out

tests = {
    "extend() loop": extend_loop,
    "chain.from_iterable": lambda: list(chain.from_iterable(batches)),
    "list comprehension": lambda: [x for b in batches for x in b],
    "sum(batches, [])": lambda: sum(batches, []),
}
for name, fn in tests.items():
    assert len(fn()) == 100_000
    best = min(timeit.repeat(fn, number=10, repeat=5)) / 10
    print(f"{name:<22} {best * 1000:9.2f} ms")

Output:

extend() loop               0.87 ms
chain.from_iterable         0.47 ms
list comprehension          1.16 ms
sum(batches, [])           97.26 ms

The extend() loop and chain.from_iterable() won, the comprehension came next, and sum() was over 100 times slower. Milliseconds vary by machine; the order doesn’t.

Related list jobs you’ll probably run into next:

• Merge two lists without duplicates
• Concatenate NumPy arrays in Python
• Pair items from several lists with zip()
• Split a list into evenly sized chunks

Frequently asked questions