Как заменить значения в списке в Python
Часто вас может заинтересовать замена одного или нескольких значений в списке в Python.
К счастью, это легко сделать в Python, и в этом руководстве дается несколько различных примеров того, как это сделать.
Пример 1. Замена одного значения в списке
Следующий синтаксис показывает, как заменить одно значение в списке в Python:
#create list of 4 items **x = ['a', 'b', 'c', 'd'] #replace first item in list **x[ 0 ] = 'z' #view updated list **x ['z', 'b', 'c', 'd'] Пример 2. Замена нескольких значений в списке
Следующий синтаксис показывает, как заменить несколько значений в списке в Python:
#create list of 4 items **x = ['a', 'b', 'c', 'd'] #replace first three items in list **x[ 0:3 ] = ['x', 'y', 'z'] #view updated list **x ['x', 'y', 'z', 'd'] Пример 3. Замена определенных значений в списке
Следующий синтаксис показывает, как заменить определенные значения в списке в Python:
#create list of 6 items y = [1, 1, 1, 2, 3, 7] #replace 1's with 0's y = [0 if x==1 else x for x in y] #view updated list y [0, 0, 0, 2, 3, 7] Вы также можете использовать следующий синтаксис для замены значений, превышающих определенный порог:
#create list of 6 items y = [1, 1, 1, 2, 3, 7] #replace all values above 1 with a '0' y = [0 if x>1 else x for x in y] #view updated list y [1, 1, 1, 0, 0, 0] Точно так же вы можете заменить значения, которые меньше или равны некоторому порогу:
#create list of 6 items y = [1, 1, 1, 2, 3, 7] #replace all values less than or equal to 2 a '0' y = [0 if x Найдите больше руководств по Python здесь .
Модификация списков поэлементно — Python: Списки
Как вы помните, элементы списков индексированы, то есть каждый элемент имеет порядковый номер. Первый элемент имеет индекс 0 , последний — len(list) - 1 .
Функция len возвращает длину списка, но работает она с различными типами, например — со строками и кортежами.
Элементы списка можно получать и заменять через присваивание по их индексу. Если указать отрицательный индекс, то элементы будут браться с конца.
Последний элемент списка будет иметь отрицательный индекс -1 . Увы, -0 использовать не получится. Вот пара примеров использования индексов со списком:
l = [0] * 3 l[0], l[1] = 10, 32 l[-1] = l[0] + l[1] print(l) # => [10, 32, 42] Обратите внимание, что мы создали список клонированием нулей. Так делать безопасно, потому что числа в Python — неизменяемые. Впрочем, все модификации списка сделаны через присваивание, поэтому ничего неожиданного мы бы не получили, даже если бы использовали изменяемые объекты.
pop и insert
Итак, получать и заменять элементы по одному мы умеем. Неплохо бы еще уметь удалять старые элементы и вставлять в середину списка новые. За это отвечают методы pop и insert соответственно. pop удаляет элемент по индексу.
Если не указать индекс, то удаляется последний элемент. При этом pop возвращает значение элемента, который удаляет:
l = [1, 2, 3] l.pop() # 3 print(l) # => [1, 2] l.pop(0) # 1 print(l) # => [2] А вот пример использования insert :
l = [1, 2, 3] l.insert(1, 100) print(l) # => [1, 100, 2, 3] l.insert(-1, 200) print(l) # => [1, 100, 2, 200, 3] insert всегда вставляет новый элемент перед элементом с указанным индексом относительно начала списка. При этом не важно, откуда мы индекс отсчитывали — от начала или от конца. И insert(-1, ..) вставляет элемент именно перед последним элементом.
Интересно, что l.insert(len(l), x) добавит элемент x в конец списка l , то есть сработает как l.append(x) .
Фактически здесь не будет элемента, перед которым будет вставлен новый, вот новый элемент и попадет в конец списка.
Имейте в виду эту особенность, но используйте append , хотя бы потому, что его вызов проще читается.
Ошибки индексации
Если попытаться вызвать pop() у пустого списка или указать индекс за пределами индексов существующих элементов, вы получите ошибку IndexError :
l = [] l.pop() # Traceback (most recent call last): # File "", line 1, in # IndexError: pop from empty list А вот insert более терпим к некорректным индексам и просто добавляет элементы с соответствующего края:
l = [0] l.insert(-500, 1) l.insert(1000, 2) print(l) # => [1, 0, 2] Однако полагаться на это не стоит — индексы все же лучше держать под контролем.
Сортировка и разворачивание
Списки чего-либо периодически приходится сортировать, а иногда и разворачивать. Желательно уметь это делать эффективно. Поэтому список уже имеет встроенные средства для выполнения обеих задач — методы sort и reverse . Оба метода изменяют список по месту. Посмотрим на несколько примеров:
l = [1, 3, 7, 2, 10, 8] l.sort() print(l) # => [1, 2, 3, 7, 8, 10] l.reverse() print(l) # => [10, 8, 7, 3, 2, 1] Эти методы могут работать без параметров. В случае reverse нечего и параметризовывать: разворачивание — это всегда разворачивание.
А вот сортировка может производиться по разным критериям. Если вызывать sort без параметров, то элементы сортируются в порядке возрастания. Однако методу можно передать параметр-функцию, которая будет возвращать критерий сортировки, то есть ключ.
Функция будет вызвана по одному разу для каждого элемента списка, после чего элементы будут отсортированы по возрастанию значения ключа. Давайте объявим функцию, которая будет возвращать остаток от деления аргумента на два, и используем ее в роли ключа:
def mod2(x): return x % 2 l = [1, 2, 3, 6, 5, 4] l.sort(key=mod2) print(l) # => [2, 6, 4, 1, 3, 5] Обратите внимание, что функцию в метод sort мы передали по имени параметра. Такой синтаксис мы рассмотрим позже, но поэкспериментировать с методом sort и разными функциями-ключами вы уже сможете, указывая их по аналогии.
Функция mod2 вернула для четных и нечетных чисел 0 и 1 соответственно. Поэтому в начале списка оказались сначала четные числа.
Интересно, что в пределах своей группы числа сохранили порядок: 6 шла в списке перед 4 , и это взаимное расположение сохранилось.
Умение сохранить относительный порядок элементов, которые уже отсортированы относительно друг друга — важная характеристика алгоритма сортировки. Называется она стабильностью.
Сортировка в этом случае называется стабильной — и в Python сортировка именно такая.
Функция-ключ не обязана возвращать числа — она может возвращать любые значения, которые Python умеет сравнивать. Давайте в предыдущем примере усложним функцию-ключ:
def key(x): return (x % 2, x) l = [1, 2, 3, 6, 5, 4] l.sort(key=key) print(l) # => [2, 4, 6, 1, 3, 5] Теперь числа разбиты на группы и при этом еще и отсортированы внутри групп. Когда Python сравнивает кортежи, он сравнивает сначала первые элементы, а если те равны — вторые и так далее.
Значения сравниваются, пока не найдется первое неравенство. Либо пока не кончится один из кортежей — в этом случае более короткий будет меньше. Вот несколько примеров:
print((1, 2, 3) (1, 2, 4)) # => True print((1, 1) (1, 1, 1)) # => True print((1, 2) > (1, 1, 1)) # => True print((3, 4, 5) == (3, 4, 5)) # => True Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях:
замена элементов в списке по индексу. Python
Есть задание, в существующий список внести значения пользователя. Никак не получается это сделать. Должно быть циклом до тех пор пока пользователь не введет в поле индекс : "-1" Cпасибо Вот пример: list=[1, 2, 3, 4, 5] Введите индекс: 0 Введите значение: 10 [10, 2, 3, 4, 5] Введите индекс: 2 Введите значение: 250 [10, 2, 250, 4, 5] Введите индекс: -1 Моя попытка:
list=[1,2,3,4,5] for i in list: index=int(input("Введите индекс: ")) arv=int(input("Введите значение: ")) if index >= 0: list.insert(index, arv) print(list) if index Отслеживать
10.1k 5 5 золотых знаков 24 24 серебряных знака 68 68 бронзовых знаков
Как удалить элемент из списка в Python
Рассказываем, как работают методы remove(), pop(), clear() и ключевое слово del.
Иллюстрация: Оля Ежак для Skillbox Media
Иван Стуков
Журналист, изучает Python. Любит разбираться в мелочах, общаться с людьми и понимать их.
В Python есть много удобных механизмов для работы со списками. И удалять элементы из них можно по-разному.
4 главных способа удалить элемент из списка
В этой статье мы рассмотрим четыре основных метода. Их функциональность в некоторых случаях пересекается, поэтому иногда они вполне взаимозаменяемы.
Метод remove(): удаление по значению
remove() можно использовать, когда мы точно знаем значение, от которого хотим избавиться. В качестве аргумента remove() получает объект, находит совпадение и удаляет его, ничего не возвращая:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] new_list.remove(1) print(new_list ) >>> ['ноль', [2.1, 'два и два'], 3, 'IV']
Можно удалять и более сложные объекты: например, внутренние списки. Главное — в точности передать этот объект методу:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] new_list.remove([2.1, 'два и два']) print(new_list) >>> ['ноль', 1, 3, 'IV']
remove() удаляет только первое совпадение с искомым элементом. Например, так он себя поведёт, если в списке будет несколько строк 'ноль':
change_list = ['ноль', 1, [2.1, 'два и два'], 'ноль', 3, 'IV'] change_list.remove('ноль') print(change_list) >>> [1, [2.1, 'два и два'], 'ноль', 3, 'IV']
При попытке удалить значение, которого нет в списке, Python выдаст ошибку ValueError.
Метод pop(): удаление по индексу
pop() подойдёт, когда известно точное местоположение удаляемого элемента. В качестве аргумента pop() получает индекс, а возвращает удалённое значение:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] new_list.pop(2) >>> [2.1, 'два и два'] print(new_list) >>> ['ноль', 1, 3, 'IV']
Если передать отрицательное значение, то pop() будет считать индексы не с нуля, а с -1:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] new_list.pop(-2) print(new_list) #Удалили предпоследний элемент. >>> ['ноль', 1, [2.1, 'два и два'], 'IV']
А вот если оставить pop() без аргумента, то удалится последний элемент — потому что -1 является аргументом по умолчанию:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] new_list.pop() print(new_list) >>> ['ноль', 1, [2.1, 'два и два'], 3]
При попытке обратиться в методе pop() к несуществующему индексу, интерпретатор выбросит исключение IndexError.
Метод clear(): очищение списка
clear() удаляет из списка всё, то есть буквально очищает его. Он не принимает аргументов и не возвращает никаких значений:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] new_list.clear() print(new_list) >>> []
Ключевое слово del: удаление срезов
del, как и метод pop(), удаляет элементы списка по индексу. При этом с его помощью можно избавиться как от единичного объекта, так и от целого среза:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] del new_list[2] print(new_list) >>> ['ноль', 1, 3, 'IV']
Если передать срез, то элемент с правым индексом не удалится. В примере ниже это строка 'IV':
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] del new_list[1:4] print(new_list) >>> ['ноль', 'IV']
Чтобы очистить список, достаточно передать полный срез [:]:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] del new_list[:] print(new_list) >>> []
Также del можно использовать с отрицательными индексами:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] del new_list[-4] print(new_list) >>> ['ноль', [2.1, 'два и два'], 3, 'IV']
Со срезами это тоже работает:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] del new_list[-3:-1] print(new_list) >>> ['ноль', 1, 'IV']
Если при удалении единичного элемента указать несуществующий индекс, то Python выдаст ошибку IndexError.
Как удалить первый элемент списка в Python
Довольно часто, например, при реализации стека, нужно удалить первый элемент списка. Возьмём наш new_list и посмотрим, какими способами это можно сделать.
С помощью метода pop(0)
Передаём в качестве аргумента pop() индекс 0:
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] new_list.pop(0) print(new_list) >>> [1, [2.1, 'два и два'], 3, 'IV']
С помощью ключевого слова del
Используем del с элементом с индексом 0.
new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] del new_list[0] print(new_list) >>> [1, [2.1, 'два и два'], 3, 'IV']
Как удалить несколько элементов
Если элементы, от которых нужно избавиться, находятся по соседству друг с другом, то удобнее всего использовать del.
Допустим, в последовательности чисел от 0 до 9 нужно удалить 4, 5, 6 и 7. Тогда решение будет выглядеть так:
#Сначала создадим лист с числами от 0 до 9. num_list = list(i for i in range(10)) print(num_list) >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] #После чего укажем срез чисел от 4 до 7. #Обратите внимание: элемент с индексом 8 не удаляется. del num_list[4:8] print(num_list) >>> [0, 1, 2, 3, 8, 9]
Как удалить последний элемент списка в Python
Если мы хотим избавиться от последнего элемента, то, как и в случае с первым, удобнее всего это сделать с помощью pop() или del.
С помощью метода pop()
Так как по умолчанию метод принимает аргумент -1, то можно вообще ничего не передавать:
num_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] num_list.pop() print (num_list) >>> ['ноль', 1, [2.1, 'два и два'], 3]
Но если вы истинный приверженец дзена Python («Явное лучше неявного»), то можно указать -1 — ничего не изменится.
С помощью ключевого слова del
А вот если хотите удалить последний элемент с помощью del, то передать -1 нужно обязательно:
num_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV'] del num_list[-1] print(num_list) >>> ['ноль', 1, [2.1, 'два и два'], 3]
Подведём итоги
Язык Python даёт четыре основных инструмента для удаления элементов из списка:
- remove() — удаляет по названию;
- pop() — удаляет по индексу, положительному или отрицательному;
- clear() — удаляет всё содержимое списка;
- del — позволяет удалить как отдельный элемент, так и целый срез по индексу.
Читайте также:
- Что нужно знать о списках в Python
- Тест: насколько хорошо ты разбираешься во фронтенде?
- Как начать программировать на Python