Изменение списков с помощью for и range в Python
Обновлено:
Мы уже умеем:
- обходить элементы списка с помощью
for; - получать элементы по индексам;
- изменять элементы списка по индексам;
- создавать диапазоны с помощью
range().
Теперь объединим эти знания и научимся изменять элементы списка во время его обхода.
1. Обычный for не позволяет переприсвоить элемент списка
Возьмём список строк:
words = [
'python',
'sql',
'django',
]
Попробуем изменить регистр:
for word in words:
word = word.upper()
print(words)
Результат:
['python', 'sql', 'django']
Исходный список не изменился.
2. Почему список не изменился
На первой итерации:
word
получает ссылку на объект:
'python'
После:
word = word.upper()
метод upper() возвращает новую строку:
'PYTHON'
и имя:
word
переназначается на новый объект.
Но ссылка, которая находится в самом списке, не изменяется.
Упрощённо:
список:
['python', 'sql', 'django']
↑
word
После:
word = word.upper()
получаем:
список:
['python', 'sql', 'django']
word → 'PYTHON'
Мы изменили значение переменной word, а не элемент списка.
На следующей итерации в word будет записан следующий элемент списка.
Изменение списка по индексу
3. Через индекс можно заменить ссылку внутри списка
Мы уже умеем:
words[0] = 'PYTHON'
После этого список действительно изменится:
['PYTHON', 'sql', 'django']
При присваивании:
words[index] = new_value
мы заменяем ссылку, хранящуюся в соответствующей позиции списка.
Именно это можно совместить с:
for
и:
range()
for + range
4. Изменяем все строки списка
words = [
'python',
'sql',
'django',
]
for index in range(
len(words)
):
words[index] = (
words[index].upper()
)
print(words)
Результат:
['PYTHON', 'SQL', 'DJANGO']
Здесь:
range(len(words))
даёт индексы:
0
1
2
На каждой итерации мы получаем доступ именно к соответствующей позиции списка:
words[index]
и заменяем хранящийся там объект.
5. Как работает алгоритм
Изначально:
['python', 'sql', 'django']
Первая итерация:
index == 0
Выполняется:
words[0] = words[0].upper()
Получаем:
['PYTHON', 'sql', 'django']
Следующая:
words[1] = words[1].upper()
Получаем:
['PYTHON', 'SQL', 'django']
И затем:
words[2] = words[2].upper()
Результат:
['PYTHON', 'SQL', 'DJANGO']
Другие примеры изменения списка
6. Умножаем каждое число
numbers = [
2,
4,
6,
8,
]
for index in range(
len(numbers)
):
numbers[index] *= 10
print(numbers)
Результат:
[20, 40, 60, 80]
Здесь:
numbers[index] *= 10
по сути заменяет соответствующий элемент результатом вычисления.
7. Возводим числа в квадрат
numbers = [
2,
3,
4,
5,
]
for index in range(
len(numbers)
):
numbers[index] **= 2
print(numbers)
Результат:
[4, 9, 16, 25]
8. Очищаем и нормализуем строки
names = [
' alex ',
'EMMA ',
' daniel',
]
for index in range(
len(names)
):
names[index] = (
names[index]
.strip()
.capitalize()
)
print(names)
Результат:
['Alex', 'Emma', 'Daniel']
Важное уточнение
9. Переприсваивание и изменение объекта — разные действия
Мы увидели, что:
for word in words:
word = word.upper()
не изменяет список.
Но если элемент сам является изменяемым объектом, можно изменить этот объект через переменную цикла.
Например:
numbers = [
[1, 2],
[3, 4],
]
for row in numbers:
row.append(0)
print(numbers)
Результат:
[[1, 2, 0], [3, 4, 0]]
Здесь мы не выполняли:
row = ...
Мы изменяли сам вложенный список:
row.append(0)
На этот же объект ссылается внешний список.
То же самое через while
10. Изменение списка по индексам
Любой подобный обход можно написать и с помощью while:
words = [
'python',
'sql',
'django',
]
index = 0
while index < len(words):
words[index] = (
words[index].upper()
)
index += 1
print(words)
Результат:
['PYTHON', 'SQL', 'DJANGO']
В случае for:
for index in range(
len(words)
):
индексами управляет range.
В случае while:
index = 0
и:
index += 1
мы управляем самостоятельно.
Изменение длины списка во время обхода
11. Опасный пример с for
Возьмём:
numbers = [
10,
20,
30,
40,
50,
]
Попробуем удалять элементы:
for index in range(
len(numbers)
):
if numbers[index] == 20:
numbers.pop(index)
Когда создаётся:
range(len(numbers))
длина списка равна:
5
поэтому range заранее представляет индексы:
0
1
2
3
4
Но после:
numbers.pop(1)
список становится короче:
[10, 30, 40, 50]
Теперь существующие индексы:
0
1
2
3
А цикл всё равно позже попытается обратиться:
numbers[4]
Возникнет:
IndexError
Почему это произошло
12. range(len(...)) вычисляется один раз
В выражении:
for index in range(
len(numbers)
):
сначала выполняется:
len(numbers)
Например, получаем:
5
Затем создаётся:
range(5)
И этот объект уже не изменяется вслед за изменением длины списка.
То есть:
список уменьшился
но:
range(5)
остался прежним.
Изменение длины через while
13. while может проверять текущую длину
С while можно каждый раз получать актуальное:
len(numbers)
Например, удалим все числа 20:
numbers = [
10,
20,
20,
30,
20,
40,
]
index = 0
while index < len(numbers):
if numbers[index] == 20:
numbers.pop(index)
else:
index += 1
print(numbers)
Результат:
[10, 30, 40]
14. Почему после удаления не увеличиваем индекс
Было:
[10, 20, 20, 30]
↑
index 1
Удаляем элемент:
[10, 20, 30]
↑
index 1
Следующий элемент сам сдвинулся на тот же индекс.
Поэтому после удаления делать:
index += 1
нельзя.
Нужно снова проверить:
numbers[index]
Индекс увеличиваем только тогда, когда элемент не был удалён:
else:
index += 1
Удаление всех одинаковых значений
Рассмотрим несколько способов удалить из списка все:
'apple'
Возьмём:
fruits = [
'apple',
'orange',
'banana',
'apple',
'grape',
'kiwi',
'apple',
'melon',
]
Способ №1. remove() + while
15. Удаляем первое совпадение снова и снова
while 'apple' in fruits:
fruits.remove('apple')
print(fruits)
Результат:
[
'orange',
'banana',
'grape',
'kiwi',
'melon',
]
Метод:
remove()
каждый раз:
- ищет первое совпадение;
- удаляет его;
- сдвигает оставшиеся элементы.
Кроме того, перед каждым удалением условие:
'apple' in fruits
снова выполняет поиск.
Поэтому на больших списках такой алгоритм может оказаться очень медленным.
В худшем случае его сложность растёт примерно квадратично:
O(n²)
Способ №2. Идём справа налево и используем pop()
16. Удаление с конца к началу
index = len(fruits) - 1
while index >= 0:
if fruits[index] == 'apple':
fruits.pop(index)
index -= 1
print(fruits)
Мы начинаем с последнего индекса:
len(fruits) - 1
и двигаемся:
справа → налево
17. Почему удобно идти с конца
Если удалить элемент с индексом:
7
изменятся позиции элементов справа от него.
Но мы их уже обработали.
Например:
[A][B][C][D][E]
↑
удалили
Элементы слева:
A B C D
сохраняют свои индексы.
А именно к ним мы и будем переходить дальше.
Поэтому обратный обход удобен для удаления элементов из списка.
18. Но pop(index) не всегда O(1)
Мы знаем:
fruits.pop()
с последнего места выполняется за:
O(1)
Но:
fruits.pop(index)
из середины списка требует сдвига элементов справа.
Поэтому алгоритм с обратным обходом может быть значительно быстрее первого варианта, но в худшем случае он всё равно способен иметь:
O(n²)
при большом количестве удалений.
Способ №3. Создаём новый список
19. List comprehension
Вместо удаления элементов из старого списка можно обойти его один раз и создать новый только из нужных значений:
fruits = [
'apple',
'orange',
'banana',
'apple',
'grape',
'kiwi',
'apple',
'melon',
]
result = [
fruit
for fruit in fruits
if fruit != 'apple'
]
print(result)
Результат:
[
'orange',
'banana',
'grape',
'kiwi',
'melon',
]
Такая конструкция называется:
list comprehension — списковое включение.
Подробно её синтаксис разберём отдельно.
20. Почему этот вариант быстрый
Здесь мы не удаляем элементы из существующего динамического массива.
Поэтому не требуется постоянно:
- искать элемент;
- удалять его;
- сдвигать оставшиеся ссылки.
Мы просто один раз обходим исходный список:
apple → не добавляем
orange → добавляем
banana → добавляем
apple → не добавляем
...
Поэтому время работы относительно количества элементов:
O(n)
Цена высокой скорости
21. Создаётся новый список
У этого подхода есть другая стоимость.
Исходный список остаётся в памяти:
fruits
и одновременно создаётся:
result
То есть требуется дополнительная память.
В худшем случае, если почти все элементы попадают в результат, дополнительная память также растёт как:
O(n)
Поэтому существует обычный компромисс:
больше скорость
↕
больше дополнительной памяти
Сравнение трёх алгоритмов
22. Подготовим большой список
from timeit import timeit
fruits = [
'apple',
'orange',
'banana',
'apple',
'grape',
'kiwi',
'orange',
'melon',
'pear',
'banana',
'cherry',
'kiwi',
'apple',
'banana',
'orange',
'grape',
'pear',
'kiwi',
'apple',
'melon',
'orange',
'banana',
'kiwi',
'grape',
'pear',
'apple',
'banana',
'kiwi',
'orange',
'melon',
'grape',
'apple',
'banana',
'kiwi',
'orange',
'pear',
'grape',
'kiwi',
'apple',
'banana',
] * 1500
23. Новый список
def remove_with_comprehension(
values,
):
return [
value
for value in values
if value != 'apple'
]
24. pop() справа налево
def remove_with_pop(values):
index = len(values) - 1
while index >= 0:
if values[index] == 'apple':
values.pop(index)
index -= 1
return values
25. remove()
def remove_with_remove(values):
while 'apple' in values:
values.remove('apple')
return values
26. Измерение
Каждому алгоритму передаём собственную копию одинаковых исходных данных:
print(
timeit(
lambda: remove_with_comprehension(
fruits.copy()
),
number=1,
)
)
print(
timeit(
lambda: remove_with_pop(
fruits.copy()
),
number=1,
)
)
print(
timeit(
lambda: remove_with_remove(
fruits.copy()
),
number=1,
)
)
Конкретные результаты зависят от:
- компьютера;
- версии Python;
- длины списка;
- количества удаляемых элементов;
- расположения этих элементов.
Но общая тенденция обычно хорошо заметна.
Почему результаты отличаются
27. remove() + while
while target in values:
values.remove(target)
выполняет большое количество повторных поисков и сдвигов.
При большом количестве совпадений становится очень дорогим.
28. pop() справа налево
while index >= 0:
...
делает только один последовательный проход по индексам.
Мы не ищем каждый следующий элемент с начала списка.
Поэтому такой алгоритм часто значительно быстрее первого.
Но удаления из середины динамического массива всё равно требуют сдвигов.
29. List comprehension
[
value
for value in values
if value != target
]
просто проходит исходные данные и создаёт новый список.
Не происходит многократного удаления и перемещения элементов старого списка.
Поэтому с точки зрения времени это обычно наиболее эффективный из этих трёх вариантов:
O(n)
Цена — дополнительная оперативная память.
Изменение значения и изменение длины — разные задачи
30. Значения списка менять можно
Например:
for index in range(
len(numbers)
):
numbers[index] *= 2
Количество элементов остаётся прежним.
Было:
[10, 20, 30]
Стало:
[20, 40, 60]
Длина всё время:
3
Такой обход через:
range(len(numbers))
нормален.
31. С длиной списка нужно быть осторожнее
Если внутри цикла выполнять:
append()
extend()
insert()
pop()
remove()
clear()
количество элементов меняется.
Тогда заранее созданный:
range(len(values))
может перестать соответствовать текущему состоянию списка.
Кроме IndexError, изменение длины во время обхода может приводить и к более опасным логическим ошибкам — пропуску элементов или повторной обработке.
Главное по теме
Обычное:
for element in values:
element = ...
перепривязывает только переменную:
element
и само по себе не заменяет элемент внутри списка.
Для замены элементов удобно использовать индексы:
for index in range(
len(values)
):
values[index] = ...
Например:
for index in range(
len(words)
):
words[index] = (
words[index].upper()
)
То же самое можно сделать с помощью while:
index = 0
while index < len(values):
values[index] = ...
index += 1
Если:
range(len(values))
создан при одной длине списка, а внутри цикла длина меняется, индексы range автоматически не перестраиваются.
Поэтому:
for index in range(
len(values)
):
values.pop(...)
обычно является плохой идеей.
При необходимости удалить множество элементов существуют разные подходы:
remove() в цикле
→ просто, но может быть очень медленно
обход справа налево + pop()
→ обычно значительно лучше,
но удаления всё равно могут требовать сдвигов
создание нового списка
→ O(n), обычно быстро,
но требует дополнительной памяти
Если исходный список необязательно изменять именно на месте, часто проще и эффективнее создать новый список только из нужных элементов.