Работа с элементами списка языка Python: операции и примеры

Расширенные примеры работы с элементами списка

1. Срезы для вставки и удаления подсписков

Срезы можно использовать для замены целого фрагмента списка другим списком, а также для удаления диапазона.

nums = [1, 2, 3, 4, 5, 6]
# замена элементов с индексами 1..3 на новые значения
nums[1:4] = [10, 20, 30]
print(nums)  # [1, 10, 20, 30, 5, 6]
# удаление элементов с 1 по 2 (не включая 3)
nums[1:3] = []
print(nums)  # [1, 30, 5, 6]

[1, 10, 20, 30, 5, 6]
[1, 30, 5, 6]

Таким способом можно эффективно менять несколько элементов за одну операцию.

2. Сортировка с пользовательским ключом (lambda)

Метод sort() и функция sorted() принимают параметр key – функцию, вычисляющую значение для сравнения.

students = [('Alice', 22), ('Bob', 19), ('Charlie', 21)]
# сортировка по возрасту
students.sort(key=lambda s: s[1])
print(students)
# сортировка по имени (лексикографически)
sorted_by_name = sorted(students, key=lambda s: s[0])
print(sorted_by_name)

[('Bob', 19), ('Charlie', 21), ('Alice', 22)]
[('Alice', 22), ('Bob', 19), ('Charlie', 21)]

Для обратного порядка используйте reverse=True.

3. Группировка элементов по условию (использование defaultdict)

Разделить список на группы по некоторому признаку.

from collections import defaultdict

items = ['apple', 'banana', 'avocado', 'apricot', 'blueberry', 'cherry']
groups = defaultdict(list)
for fruit in items:
    first_letter = fruit[0]
    groups[first_letter].append(fruit)
print(dict(groups))

{'a': ['apple', 'avocado', 'apricot'], 'b': ['banana', 'blueberry'], 'c': ['cherry']}

Такой подход работает за линейное время.

4. Работа с вложенными списками: выравнивание (flatten)

Многомерный список можно превратить в одномерный с помощью рекурсии или вложенных list comprehensions.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# простой способ для двух уровней
flat = [num for row in matrix for num in row]
print(flat)
# для произвольной вложенности – рекурсия
def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

nested = [1, [2, 3], [4, [5, 6]]]
print(flatten(nested))

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6]

5. Использование deque для эффективной работы с концами списка (стек/очередь)

Стандартный список неэффективен для добавления/удаления слева. collections.deque оптимизирован для операций с обоих концов.

from collections import deque

dq = deque(['a', 'b', 'c'])
dq.appendleft('x')   # O(1) – в начало
dq.append('z')       # O(1) – в конец
print(dq)
left = dq.popleft()  # удаление слева
right = dq.pop()     # удаление справа
print(left, right, dq)

deque(['x', 'a', 'b', 'c', 'z'])
x z deque(['a', 'b', 'c'])

Этот тип коллекции идеален для реализации FCFS очереди или стека.

6. Применение operator.itemgetter для сортировки вложенных списков

Вместо lambda можно использовать itemgetter из модуля operator, что может быть быстрее и читаемее.

from operator import itemgetter

data = [{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}, {'name': 'Charlie', 'age': 35}]
# сортировка по age
data.sort(key=itemgetter('age'))
print(data)
# сортировка по name, затем по age (множественные ключи)
data.sort(key=itemgetter('name', 'age'))
print(data)

[{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]
[{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}, {'name': 'Charlie', 'age': 35}]

7. Использование functools.reduce для агрегации

Функция reduce последовательно применяет бинарную операцию к элементам, сводя список к одному значению.

from functools import reduce

numbers = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 24
# Можно также задать начальное значение
sum_with_start = reduce(lambda x, y: x + y, numbers, 10)
print(sum_with_start)  # 20

24
20

Подходит для вычислений, не имеющих встроенной функции (например, произведение до Python 3.8, когда появился math.prod).

8. Срезы с шагом для извлечения каждого n-го элемента

lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# каждый второй элемент, начиная с индекса 1
print(lst[1::2])  # [1, 3, 5, 7, 9]
# каждый третий элемент
print(lst[::3])   # [0, 3, 6, 9]
# обратный порядок с шагом 2
print(lst[::-2])  # [9, 7, 5, 3, 1]

[1, 3, 5, 7, 9]
[0, 3, 6, 9]
[9, 7, 5, 3, 1]

9. Удаление дубликатов с сохранением порядка (OrderedDict или set + list)

from collections import OrderedDict

items = ['a', 'b', 'a', 'c', 'b', 'd']
# способ с OrderedDict (сохраняет порядок)
unique_ordered = list(OrderedDict.fromkeys(items))
print(unique_ordered)  # ['a', 'b', 'c', 'd']
# современный способ (Python 3.7+ dict сохраняет порядок)
unique_ordered2 = list(dict.fromkeys(items))
print(unique_ordered2)
# без сохранения порядка (только уникальные значения)
unique_set = list(set(items))
print(unique_set)  # порядок может быть любым

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

10. Генераторы списков с условием else (list comprehension с if-else)

В list comprehension можно использовать тернарный оператор.

numbers = [1, 2, 3, 4, 5, 6]
# заменить чётные на строку 'even', нечётные на 'odd'
result = ['even' if x % 2 == 0 else 'odd' for x in numbers]
print(result)  # ['odd', 'even', 'odd', 'even', 'odd', 'even']

['odd', 'even', 'odd', 'even', 'odd', 'even']

Фильтрация (только условие if) записывается без else: [x for x in lst if condition].