Как сделать конкатенацию двух листов?

Конкатенация списков в Python

Есть несколько способов объединить два или более списков. Выбор зависит от контекста и производительности.

1. Оператор + (самый простой)

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Оператор + создаёт новый список
result = list1 + list2
print(result)  # [1, 2, 3, 4, 5, 6]

# Исходные списки не изменяются
print(list1)  # [1, 2, 3] — без изменений

2. Метод extend() (изменяет оригинал)

list1 = [1, 2, 3]
list2 = [4, 5, 6]

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

# extend() изменяет оригинальный список (in-place)
# и не возвращает результат
result = list1.extend(list2)  # Это вернёт None!
print(result)  # None

3. Распаковка (Unpacking)

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

# Способ 1: используя *
result = [*list1, *list2, *list3]
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Способ 2: используя распаковку напрямую
result = [*list1, *list2]
print(result)  # [1, 2, 3, 4, 5, 6]

# Способ 3: можно добавить элементы
result = [0, *list1, *list2, 10]
print(result)  # [0, 1, 2, 3, 4, 5, 6, 10]

4. Список comprehension

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Способ 1: двойной цикл
result = [x for sublist in [list1, list2] for x in sublist]
print(result)  # [1, 2, 3, 4, 5, 6]

# Способ 2: с условиями (фильтрация при конкатенации)
result = [x for x in list1 + list2 if x > 2]
print(result)  # [3, 4, 5, 6]

5. Функция sum()

lists = [[1, 2], [3, 4], [5, 6]]

# sum() с пустым списком как start значение
result = sum(lists, [])
print(result)  # [1, 2, 3, 4, 5, 6]

# Внимание: это не очень эффективно для большого количества списков!

6. Метод itertools.chain()

from itertools import chain

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

# chain() эффективен для больших данных
result = list(chain(list1, list2, list3))
print(result)  # [1, 2, 3, 4, 5, 6, 7, 8]

# chain() вернёт итератор, нужно преобразовать в список
iterator = chain(list1, list2)
print(list(iterator))  # [1, 2, 3, 4, 5, 6]

7. Метод operator.add()

import operator

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Функциональный подход
result = operator.add(list1, list2)
print(result)  # [1, 2, 3, 4, 5, 6]

# Это эквивалентно list1 + list2
print(result == list1 + list2)  # True

Сравнение методов

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# 1. + оператор (создаёт новый список)
result1 = list1 + list2
print(f"+ operator: {result1}")  # [1, 2, 3, 4, 5, 6]

# 2. extend() (изменяет оригинал)
list1_copy = list1.copy()
list1_copy.extend(list2)
print(f"extend: {list1_copy}")  # [1, 2, 3, 4, 5, 6]

# 3. Распаковка (читаемо и модно)
result3 = [*list1, *list2]
print(f"Unpacking: {result3}")  # [1, 2, 3, 4, 5, 6]

# 4. chain (эффективно для больших данных)
from itertools import chain
result4 = list(chain(list1, list2))
print(f"chain: {result4}")  # [1, 2, 3, 4, 5, 6]

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

# Пример 1: Конкатенация результатов разных источников
def get_users_from_db():
    return [1, 2, 3]

def get_users_from_cache():
    return [4, 5]

def get_all_users():
    # Объединяем результаты
    return get_users_from_db() + get_users_from_cache()

print(get_all_users())  # [1, 2, 3, 4, 5]

# Пример 2: Объединение с фильтрацией
positive_numbers = [1, 2, 3]
negative_numbers = [-1, -2, -3]

# Конкатенация и фильтрация
result = [x for x in positive_numbers + negative_numbers if x > 0]
print(result)  # [1, 2, 3]

# Пример 3: Работа с множественными списками
data_sources = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Объединить всё в один список
total = []
for source in data_sources:
    total.extend(source)

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

# Или более коротко
total = sum(data_sources, [])
print(total)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Пример 4: API ответы
def get_page_1():
    return [{"id": 1, "name": "Item 1"}]

def get_page_2():
    return [{"id": 2, "name": "Item 2"}]

def get_all_items():
    # Конкатенация результатов с разных страниц
    return get_page_1() + get_page_2()

result = get_all_items()
print(result)
# [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]

Производительность

import time
from itertools import chain

# Создаём большие списки
large_list1 = list(range(100000))
large_list2 = list(range(100000))

# 1. + оператор
start = time.time()
result = large_list1 + large_list2
print(f"+ operator: {(time.time() - start) * 1000:.2f}ms")

# 2. extend
start = time.time()
copy = large_list1.copy()
copy.extend(large_list2)
print(f"extend: {(time.time() - start) * 1000:.2f}ms")

# 3. chain
start = time.time()
result = list(chain(large_list1, large_list2))
print(f"chain: {(time.time() - start) * 1000:.2f}ms")

# Результаты примерно одинаковые (~2-3ms)
# Выбирай по читаемости, не по производительности

Когда использовать какой метод

# ✅ + оператор
# - Простой и читаемый
# - Если нужен новый список (безопасно)
result = list1 + list2

# ✅ extend()
# - Если хочешь изменить оригинальный список
# - Экономит память (нет нового списка)
list1.extend(list2)

# ✅ Распаковка [*list1, *list2]
# - Современный подход
# - Легко добавить элементы
result = [*list1, 0, *list2, 999]

# ✅ chain() из itertools
# - Для работы с большим количеством списков
# - Ленивое вычисление (экономит память)
result = list(chain(list1, list2, list3, list4))

# ❌ sum(lists, [])
# - Медленно и неправильно
# - О(n²) сложность
# - Используй только для обучения

Особенности extend() vs +

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# + оператор: создаёт НОВЫЙ список
new_list = list1 + list2
print(new_list is list1)  # False

# extend(): изменяет оригинал
list1.extend(list2)
print(list1)  # [1, 2, 3, 4, 5, 6]
print(list1 is list1)  # True (работает на месте)

Вывод: используй + или распаковку для нового списка, extend() если нужно изменить оригинал.