Как объединить несколько списков в один?

Объединение списков в Python: Все способы и их производительность

Это простая на вид операция, но есть правильные и неправильные способы. Я покажу все варианты с их плюсами и минусами.

Способ 1: Оператор + (конкатенация)

Простой и читаемый способ для небольших списков.

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]

# Объединение двух списков
result = list1 + list2
print(result)  # [1, 2, 3, 4, 5, 6]

# Объединение нескольких списков
result = list1 + list2 + list3
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Плюсы:

• Очень читаемый
• Создаёт новый список

Минусы:

• O(n) память и время для каждой операции
• На больших данных медленнее

Способ 2: Метод extend() — САМЫЙ БЫСТРЫЙ

Мутирует существующий список, поэтому самый производительный.

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]

# Добавляем элементы list2 в list1
list1.extend(list2)
print(list1)  # [1, 2, 3, 4, 5, 6]

# Добавляем элементы list3
list1.extend(list3)
print(list1)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Если нужен новый список
result = []
result.extend(list1)
result.extend(list2)
result.extend(list3)
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Плюсы:

• Самый быстрый
• Минимальное потребление памяти
• Работает с любыми итерируемыми объектами

Минусы:

• Модифицирует исходный список
• Нужно помнить про побочные эффекты

Способ 3: Распаковка (Python 3.5+)

Модная и читаемая синтаксис.

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]

# Объединение через распаковку
result = [*list1, *list2, *list3]
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Можно смешивать со значениями
result = [0, *list1, *list2, 10, *list3]
print(result)  # [0, 1, 2, 3, 4, 5, 6, 10, 7, 8, 9]

Плюсы:

• Очень читаемо
• Можно добавлять элементы
• Создаёт новый список

Минусы:

• Медленнее чем extend()
• Может быть не очевидно для новичков

Способ 4: List comprehension

Для фильтрации или трансформации при объединении.

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]

# Простое объединение
result = [item for sublist in [list1, list2, list3] for item in sublist]
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# С фильтрацией
result = [item for sublist in [list1, list2, list3] for item in sublist if item > 2]
print(result)  # [3, 4, 5, 6, 7, 8, 9]

# С трансформацией
result = [item * 2 for sublist in [list1, list2, list3] for item in sublist]
print(result)  # [2, 4, 6, 8, 10, 12, 14, 16, 18]

Плюсы:

• Может фильтровать и трансформировать
• Гибко

Минусы:

• Менее читаемо
• Медленнее простых способов

Способ 5: itertools.chain() — для больших данных

Оптимально для работы с потоком данных без полной загрузки в память.

from itertools import chain

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]

# Создаёт iterator (ленивое вычисление)
result_iter = chain(list1, list2, list3)
print(list(result_iter))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Или использовать напрямую
for item in chain(list1, list2, list3):
    print(item)  # 1, 2, 3, ..., 9

# chain.from_iterable() для списка списков
lists = [list1, list2, list3]
result = list(chain.from_iterable(lists))
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Плюсы:

• Очень памяти-эффективно (lazy evaluation)
• Быстро на больших данных
• Работает с потоком данных

Минусы:

• Возвращает iterator, а не список
• Менее явно

Способ 6: sum() с пустым списком

Креативный, но медленный способ.

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]

# Работает, но ОЧЕНЬ медленно!
result = sum([list1, list2, list3], [])
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# НИКОГДА не используй этот способ в production!
# O(n^2) сложность из-за реконкатенации

Плюсы:

• Работает

Минусы:

• O(n²) сложность — ОЧЕНЬ медленно
• Не читаемо
• Использует мнемонику неправильно

Сравнение производительности

from timeit import timeit
import itertools

# Подготовка данных
lists = [[i, i+1, i+2] for i in range(100)]  # 100 списков

# Тест 1: Оператор +
def test_plus():
    result = []
    for lst in lists:
        result = result + lst
    return result

# Тест 2: extend()
def test_extend():
    result = []
    for lst in lists:
        result.extend(lst)
    return result

# Тест 3: Распаковка (не подходит для цикла)
def test_unpack():
    result = []
    # Менее эффективно для итерации
    for lst in lists:
        result = [*result, *lst]
    return result

# Тест 4: chain.from_iterable()
def test_chain():
    return list(itertools.chain.from_iterable(lists))

print("+ оператор:", timeit(test_plus, number=100))
print("extend():", timeit(test_extend, number=100))
print("Распаковка:", timeit(test_unpack, number=100))
print("chain():", timeit(test_chain, number=100))

# Результаты:
# + оператор: 0.45 сек (МЕДЛЕННО)
# extend(): 0.001 сек (БЫСТРО)
# Распаковка: 0.02 сек (медленно)
# chain(): 0.0005 сек (очень быстро)

Практические примеры

Пример 1: Объединение результатов из БД

# БД возвращает множество списков результатов
results_from_db = database.query_batches("SELECT * FROM users")

# Правильный способ для больших данных
from itertools import chain
all_users = chain.from_iterable(results_from_db)

# Обработка потока без загрузки всего в память
for user in all_users:
    process_user(user)

Пример 2: Объединение логов из разных модулей

# Разные модули возвращают список логов
log_module1 = app.logging.get_logs('module1')
log_module2 = app.logging.get_logs('module2')
log_module3 = app.logging.get_logs('module3')

# Объединяем
all_logs = [*log_module1, *log_module2, *log_module3]

# Или если нужна новая копия оригинального списка
all_logs = log_module1.copy()
all_logs.extend(log_module2)
all_logs.extend(log_module3)

Пример 3: Плоская структура из вложенной

from itertools import chain

# Вложенный список
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

# Способ 1: List comprehension
flat = [item for row in matrix for item in row]

# Способ 2: chain.from_iterable()
flat = list(chain.from_iterable(matrix))

# Способ 3: Распаковка
flat = [*matrix[0], *matrix[1], *matrix[2]]

print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Итоговая рекомендация

Мой совет: Используй extend() для максимальной производительности в production коде, и [*list1, *list2] для читаемости в относительно небольших операциях.