Что выведет код: print([1, 2, 3] + [4, 5]) и print([1, 2, 3] * 2)?

Операции со списками: конкатенация и повторение

Это простой, но важный вопрос о перегрузке операторов в Python. Одни и те же операторы + и * работают по-разному для разных типов данных.

Вывод кода

print([1, 2, 3] + [4, 5])
# Выведет: [1, 2, 3, 4, 5]

print([1, 2, 3] * 2)
# Выведет: [1, 2, 3, 1, 2, 3]

Объяснение

Оператор + (конкатенация)

+ для списков выполняет конкатенацию (объединение):

list1 = [1, 2, 3]
list2 = [4, 5]
result = list1 + list2
print(result)  # [1, 2, 3, 4, 5]

# Это эквивалентно:
list1.extend(list2)  # Но + создаёт новый список

Важные особенности:

• Создаёт новый список (не изменяет исходные)
• Требует список с обеих сторон (нельзя [1, 2] + (3, 4))
• Временная сложность: O(n + m) где n, m — длины списков

a = [1, 2]
b = [3, 4]
c = a + b
print(c)  # [1, 2, 3, 4]
print(a)  # [1, 2] — не изменилось

# Но это может быть неэффективно
result = []
for item in large_list:
    result = result + [item]  # Плохо! O(n²)
# Лучше
result = []
for item in large_list:
    result.append(item)  # O(1) за добавление

Оператор * (повторение)

* для списков выполняет повторение:

list1 = [1, 2, 3]
result = list1 * 2
print(result)  # [1, 2, 3, 1, 2, 3]

# Это эквивалентно
result = list1 + list1
print(result)  # [1, 2, 3, 1, 2, 3]

# Или в другом порядке
result = 2 * [1, 2, 3]
print(result)  # [1, 2, 3, 1, 2, 3]

Важные особенности:

• Число может быть слева или справа: [1, 2] * 3 или 3 * [1, 2]
• Создаёт новый список
• Если число ≤ 0, результат — пустой список
• Число должно быть целое

print([1, 2] * 3)      # [1, 2, 1, 2, 1, 2]
print(3 * [1, 2])      # [1, 2, 1, 2, 1, 2]
print([1, 2] * 0)      # []
print([1, 2] * -1)     # []
print(["a"] * 5)       # ['a', 'a', 'a', 'a', 'a']

Опасность с изменяемыми объектами

ВАЖНО: При повторении мутабельных объектов копируются только ссылки!

# Опасный случай
matrix = [[0] * 3] * 3
print(matrix)  # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

matrix[0][0] = 1
print(matrix)  # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]
# Все строки указывают на ОДИН И ТОТ ЖЕ список!

# Правильно
matrix = [[0] * 3 for _ in range(3)]
matrix[0][0] = 1
print(matrix)  # [[1, 0, 0], [0, 0, 0], [0, 0, 0]]

# Ещё пример
data = [[]] * 3  # Три ссылки на ОДИН пустой список
data[0].append(1)
print(data)  # [[1], [1], [1]]

# Правильно
data = [[] for _ in range(3)]  # Три РАЗНЫХ пустых списка
data[0].append(1)
print(data)  # [[1], [], []]

Сравнение с другими типами

Строки:

print("ab" + "cd")     # abcd
print("ab" * 3)        # ababab

Кортежи:

print((1, 2) + (3, 4))  # (1, 2, 3, 4)
print((1, 2) * 2)       # (1, 2, 1, 2)

Словари (НЕ работают):

print({"a": 1} + {"b": 2})  # TypeError
print({"a": 1} * 2)         # TypeError
# Для словарей нужно
d1 = {"a": 1}
d2 = {"b": 2}
d1.update(d2)  # или {**d1, **d2}

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

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

# Медленно — O(n) за каждое слияние
result = [1]
for i in range(1000):
    result = result + [i]  # Создаёт новый список

# Быстро — O(1) за добавление
result = [1]
for i in range(1000):
    result.append(i)

# Или используй extend — O(n) но один раз
result = [1]
result.extend(range(2, 1001))

На собеседовании

Ожидаемый ответ:

• [1, 2, 3] + [4, 5] выведет [1, 2, 3, 4, 5] — конкатенация
• [1, 2, 3] * 2 выведет [1, 2, 3, 1, 2, 3] — повторение
• Понимание что это новые списки (не in-place операции)
• Знание про опасность с мутабельными объектами при повторении
• Отличие от методов extend() и append()

Это базовый вопрос, но хорошие кандидаты знают про ловушку с ссылками при повторении списков с изменяемыми элементами.