Extend: примеры (PYTHON)

Краткие примеры использования

# Пример 1: Добавление элементов списка
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)

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

# Пример 2: Добавление элементов кортежа
fruits = ['apple', 'banana']
fruits.extend(('orange', 'grape'))
print(fruits)

['apple', 'banana', 'orange', 'grape']

# Пример 3: Добавление элементов множества
numbers = [1, 2]
numbers.extend({3, 4, 5})
print(numbers)

[1, 2, 3, 4, 5]

# Пример 4: Добавление символов строки
chars = ['a', 'b']
chars.extend('cde')
print(chars)

['a', 'b', 'c', 'd', 'e']

# Пример 5: Добавление элементов из генератора
nums = [10, 20]
nums.extend(x * 2 for x in range(3))
print(nums)

[10, 20, 0, 2, 4]

Похожие функции в Python

В Python существуют другие методы, которые могут выполнять схожие операции с объединением или добавлением элементов.

• append() - добавляет один элемент в конец списка. В отличие от extend(), если передать итерируемый объект, он будет добавлен как единый элемент, создав вложенный список. Используется, когда требуется сохранить целостность добавляемого объекта.
• + (конкатенация списков) - создает новый список, объединяя два существующих. Не изменяет исходные списки, что может быть менее эффективно по памяти при работе с большими данными.
• += (оператор расширения) - работает аналогично extend(), изменяя исходный список. Фактически является его синтаксическим сахаром.
• list.insert() - вставляет элемент на определенную позицию. Позволяет добавлять элементы не только в конец списка.
• itertools.chain() - создает итератор, который последовательно возвращает элементы из нескольких контейнеров. Полезен для ленивого объединения без создания промежуточного списка.

Выбор метода зависит от задачи: extend() оптимален для добавления множества элементов из итерируемого объекта с модификацией исходного списка; append() - для добавления одного элемента; конкатенация - когда нужно сохранить оригинальные списки неизменными.

Аналоги функции в других языках

В разных языках программирования существуют аналогичные операции для расширения коллекций.

// JavaScript: метод concat или spread оператор
let arr1 = [1, 2];
let arr2 = [3, 4];
arr1 = arr1.concat(arr2); // Возвращает новый массив
// или
arr1.push(...arr2); // Изменяет исходный массив
console.log(arr1);

[1, 2, 3, 4]

// PHP: array_merge
$array1 = [1, 2];
$array2 = [3, 4];
$result = array_merge($array1, $array2);
print_r($result);

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
)

// Java: addAll для ArrayList
import java.util.ArrayList;
ArrayList list1 = new ArrayList<>();
list1.add(1); list1.add(2);
ArrayList list2 = new ArrayList<>();
list2.add(3); list2.add(4);
list1.addAll(list2);
System.out.println(list1);

[1, 2, 3, 4]

// C#: AddRange для List
List list1 = new List {1, 2};
List list2 = new List {3, 4};
list1.AddRange(list2);
Console.WriteLine(string.Join(", ", list1));

1, 2, 3, 4

// Golang: оператор ... для срезов
slice1 := []int{1, 2}
slice2 := []int{3, 4}
slice1 = append(slice1, slice2...)
fmt.Println(slice1)

[1 2 3 4]

Ключевое отличие Python - метод extend() является членом объекта списка и изменяет его напрямую, в то время как во многих других языках подобные операции часто возвращают новую коллекцию или требуют использования специального синтаксиса.

Типичные ошибки

# Ошибка 1: Попытка передать несколько аргументов
lst = [1, 2]
try:
    lst.extend(3, 4)
except TypeError as e:
    print(f"Ошибка: {e}")

Ошибка: list.extend() takes exactly one argument (2 given)

# Ошибка 2: Передача неитерируемого объекта
lst = [1, 2]
try:
    lst.extend(5)
except TypeError as e:
    print(f"Ошибка: {e}")

Ошибка: 'int' object is not iterable

# Ошибка 3: Ожидание возврата нового списка
lst = [1, 2]
new_lst = lst.extend([3, 4])
print("Новый список:", new_lst)
print("Исходный список:", lst)

Новый список: None
Исходный список: [1, 2, 3, 4]

# Ошибка 4: Путаница с методом append
lst = [1, 2]
lst.append([3, 4])
print("Использование append:", lst)

Использование append: [1, 2, [3, 4]]

История изменений

Метод extend() присутствует в языке Python с ранних версий и сохраняет стабильное поведение. Существенных изменений в его работе не было. Однако, начиная с Python 3.3, оптимизирована внутренняя реализация списков, что повысило производительность метода для больших последовательностей. В Python 3.9 были добавлены операторы объединения для словарей, но на списки это не повлияло.

Расширенные примеры

# Пример 1: Эффективное наращивание списка в цикле
result = []
for i in range(5):
    result.extend([i] * i)  # Добавляем i копий числа i
print(result)

[1, 2, 2, 3, 3, 3, 4, 4, 4, 4]

# Пример 2: Объединение нескольких списков
lists = [[1, 2], [3, 4], [5, 6]]
combined = []
for lst in lists:
    combined.extend(lst)
print(combined)

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

# Пример 3: Использование с map и filter
data = [1, 2, 3, 4, 5]
squares = []
squares.extend(map(lambda x: x**2, data))
print("Квадраты:", squares)

even = []
even.extend(filter(lambda x: x % 2 == 0, data))
print("Чётные:", even)

Квадраты: [1, 4, 9, 16, 25]
Чётные: [2, 4]

# Пример 4: Добавление элементов из range и enumerate
numbers = [100]
numbers.extend(range(5))
print("С range:", numbers)

letters = ['a']
letters.extend(val for _, val in enumerate(['b', 'c']))
print("С enumerate:", letters)

С range: [100, 0, 1, 2, 3, 4]
С enumerate: ['a', 'b', 'c']

# Пример 5: Работа с коллекциями deque
from collections import deque
d = deque([1, 2])
d.extend([3, 4])
d.extendleft([0, -1])  # Добавление в начало
print("deque:", list(d))

deque: [-1, 0, 1, 2, 3, 4]