Списки: срезы и методы

Для списков применим механизм срезов, о котором мы уже говорили, рассматривая строки. Например, пусть у нас имеется список из городов:

lst = ["Москва", "Санкт-Петербург", "Тверь", "Казань"]

Используя синтаксис:

список[start:end]

можно выделять элементы, начиная с индекса start и заканчивая, но не включая индекс end. В частности, вот такая конструкция:

lst[1:3]

возвратит список из двух городов:

<p align=center>['Санкт-Петербург', 'Тверь']

То есть, здесь создается новый объект list, содержащий эти элементы:

lst2 = lst[2:4]

Прежний список lst не меняется. Если индексы принимают отрицательные значение, то отсчет идет с конца списка:

lst[-2:-1]

получим

['Тверь']

так как индекс -1 – последний элемент не включается, остается только «Тверь». Или, можно записать так:

lst[0:-1]

тогда возьмем с первого элемента и до предпоследнего:

['Москва', 'Санкт-Петербург', 'Тверь']

У срезов можно записывать любые числовые индексы к ошибкам это не приведет. Например:

lst[1:9999]

вернет список со 2-го элемента и по последний:

['Санкт-Петербург', 'Тверь', 'Казань']

Этот же результат можно получить и так:

lst[1:]

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

lst[:3]

то элементы выбираются с самого начала и до третьего индекса, то есть, получим:

['Москва', 'Санкт-Петербург', 'Тверь']

Если не указывать ни начало, ни конец, то будет возвращен список:

lst[:]

Спрашивается: создает ли данная операция копию списка? Да, создается и в этом легко убедиться, записав такие строчки:

c = lst[:]
print(id(c), id(lst))

И мы увидим разные значения id, которые говорят, что обе переменные ссылаются на разные списки. Также копию списка, можно сделать с помощью функции-конструктора list:

c=list(lst)

Далее, в срезах можно указывать шаг следования (по умолчанию он равен 1). Для этого пишется еще одно двоеточие и указывается шаг:

lst[::2]

получим:

['Москва', 'Тверь']

Или, такие варианты:

lst[1:4:2]
lst[:4:3]
lst[1::2]

Если указать отрицательный шаг, то перебор будет происходить в обратном порядке:

lst[::-1]

Так как список – это изменяемый объект, то мы можем срезам присваивать новые значения. Делается это таким образом:

lst[1:3] = "Владимир", "Астрахань"

В результате, получаем список:

['Москва', 'Владимир', 'Астрахань', 'Казань']

Или даже так. Большему срезу присвоить меньшее число элементов:

lst[0:3] = 'Пермь', 'Пенза'

В итоге получаем список:

['Пермь', 'Пенза', 'Казань']

Однако, если нам нужно просто удалить какой-либо элемент, то это делается с помощью оператора del:

del lst[1]

В результате будет удален элемент с индексом 1 из списка lst:

['Пермь', 'Казань']

Методы списков

Давайте теперь предположим, что у нас имеется список из чисел:

a = [1, -54, 3, 23, 43, -45, 0]

и мы хотим в конец этого списка добавить значение. Это можно сделать с помощью метода:

a.append(100)

И обратите внимание: метод append ничего не возвращает, то есть, он меняет сам список благодаря тому, что он относится к изменяемому типу данных. Поэтому писать здесь конструкцию типа

a = a.append(100)

категорически не следует, так мы только потеряем весь наш список! И этим методы списков отличаются от методов строк, когда мы записывали:

string="Hello"
string = string.upper()

Здесь метод upper возвращает измененную строку, поэтому все работает как и ожидается. А метод append ничего не возвращает, и присваивать значение None переменной a не имеет смысла, тем более, что все работает и так:

a = [1, -54, 3, 23, 43, -45, 0]
a.append(100)

Причем, мы в методе append можем записать не только число, но и другой тип данных, например, строку:

a.append("hello")

тогда в конец списка будет добавлен этот элемент. Или, булевое  значение:

a.append(True)

Или еще один список:

a.append([1,2,3])

И так далее. Главное, чтобы было указано одно конкретное значение. Вот так работать не будет:

a.append(1,2)

Если нам нужно вставить элемент в произвольную позицию, то используется метод

a.insert(3, -1000)

Здесь мы указываем индекс вставляемого элемента и далее значение самого элемента.

Следующий метод remove удаляет элемент по значению:

a.remove(True)
a.remove('hello')

Он находит первый подходящий элемент и удаляет его, остальные не трогает. Если же указывается несуществующий элемент:

a.remove('hello2')

то возникает ошибка. Еще один метод для удаления

a.pop()

выполняет удаление последнего элемента и при этом, возвращает его значение. В самом списке последний элемент пропадает. То есть, с помощью этого метода можно сохранять удаленный элемент в какой-либо переменной:

end = a.pop()

Также в этом методе можно указывать индекс удаляемого элемента, например:

a.pop(3)

Если нам нужно очистить весь список – удалить все элементы, то можно воспользоваться методом:

a.clear()

Получим пустой список. Следующий метод

a = [1, -54, 3, 23, 43, -45, 0]
c = a.copy()

возвращает копию списка. Это эквивалентно конструкции:

c = list(a)

В этом можно убедиться так:

c[1] = 1

и список c будет отличаться от списка a.

Следующий метод count позволяет найти число элементов с указанным значением:

c.count(1)
c.count(-45)

Если же нам нужен индекс определенного значения, то для этого используется метод index:

c.index(-45)
c.index(1)

возвратит 0, т.к. берется индекс только первого найденного элемента. Но, мы здесь можем указать стартовое значение для поиска:

c.index(1, 1)

Здесь поиск будет начинаться с индекса 1, то есть, со второго элемента. Или, так:

c.index(23, 1, 5)

Ищем число 23 с 1-го индекса и по 5-й не включая его. Если элемент не находится

c.index(23, 1, 3)

то метод приводит к ошибке. Чтобы этого избежать в своих программах, можно вначале проверить: существует ли такой элемент в нашем срезе:

23 in c[1:3]

и при значении True далее уже определять индекс этого элемента.

Следующий метод

c.reverse()

меняет порядок следования элементов на обратный.

Последний метод, который мы рассмотрим, это

c.sort()

выполняет сортировку элементов списка по возрастанию. Для сортировки по убыванию, следует этот метод записать так:

c.sort(reverse=True)

Причем, этот метод работает и со строками:

lst = ["Москва", "Санкт-Петербург", "Тверь", "Казань"]
lst.sort()

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

Это все основные методы списков и чтобы вам было проще ориентироваться, приведу следующую таблицу:

Метод

Описание

append()

Добавляет элемент в конец списка

insert()

Вставляет элемент в указанное место списка

remove()

Удаляет элемент по значению

pop()

Удаляет последний элемент, либо элемент с указанным индексом

clear()

Очищает список (удаляет все элементы)

copy()

Возвращает копию списка

count()

Возвращает число элементов с указанным значением

index()

Возвращает индекс первого найденного элемента

reverse()

Меняет порядок следования элементов на обратный

sort()

Сортирует элементы списка

Задания для самоподготовки

1. Пользователь вводит с клавиатуры числа, до тех пор, пока не введет число 0. На основе введенных данных нужно сформировать список, состоящий из квадратов введенных чисел.

2. Написать программу удаления из списка

['+7912123456', '+7915213456', '+6915213456', '+4915213456', '+7915213456']

всех номеров с кодом «+7».

3. Написать программу циклического сдвига элементов списка влево. Например, дан список:

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

после сдвига на один элемент влево, должны получить:

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

Реализовать через цикл, перебирая все элементы.

4. Написать аналогичную программу циклического сдвига, но теперь вправо.

Видео по теме