Изменение списков с помощью 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()

каждый раз:

  1. ищет первое совпадение;
  2. удаляет его;
  3. сдвигает оставшиеся элементы.

Кроме того, перед каждым удалением условие:

'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), обычно быстро,
  но требует дополнительной памяти

Если исходный список необязательно изменять именно на месте, часто проще и эффективнее создать новый список только из нужных элементов.