Что у нас в списке

Списки в Python

Всем привет! В этой статье мы познакомимся с методами для работы со списками в python . Но сначала вспомним, что такое список? Список — это изменяемый и последовательный тип данных. Это значит, что мы можем добавлять, удалять и изменять любые элементы списка.

Начнем с метода append() , который добавляет элемент в конец списка:

# Создаем список, состоящий из четных чисел от 0 до 8 включительно
numbers = list ( range ( 0 , 10 , 2 ))
# Добавляем число 200 в конец списка
numbers. append ( 200 )
print (numbers)
# [0, 2, 4, 6, 8, 200]
numbers. append ( 1 )
numbers. append ( 2 )
numbers. append ( 3 )
print (numbers)
# [0, 2, 4, 6, 8, 200, 1, 2, 3]

Мы можем передавать методу append() абсолютно любые значения:

all_types = [ 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]]
all_types. append ( 1024 )
all_types. append ( ‘Hello world!’ )
all_types. append ([ 1 , 2 , 3 ])
print (all_types)
# [10, 3.14, ‘Python’, [‘I’, ‘am’, ‘list’], 1024, ‘Hello world!’, [1, 2, 3]]

Метод append() отлично выполняет свою функцию. Но, что делать, если нам нужно добавить элемент в середину списка? Это умеет метод insert () . Он добавляет элемент в список на произвольную позицию. insert() принимает в качестве первого аргумента позицию, на которую нужно вставить элемент, а вторым — сам элемент.

# Создадим список чисел от 0 до 9
numbers = list ( range ( 10 ))
# Добавление элемента 999 на позицию с индексом 0
numbers. insert ( 0 , 999 )
print (numbers)
# [999, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers. insert ( 2 , 1024 )
print (numbers)
# [999, 0, 1024, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers. insert ( 5 , ‘Засланная строка-шпион’ )
print (numbers)
# [999, 0, 1024, 1, 2, ‘Засланная строка-шпион’, 3, 4, 5, 6, 7, 8, 9]

Отлично! Добавлять элементы в список мы научились, осталось понять, как их из него удалять. Метод pop() удаляет элемент из списка по его индексу:

numbers = list ( range ( 10 ))
print (numbers)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Удаляем первый элемент
numbers. pop ( 0 )
print (numbers)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers. pop ( 0 )
print (numbers)
# [2, 3, 4, 5, 6, 7, 8, 9]
numbers. pop ( 2 )
print (numbers)
# [2, 3, 5, 6, 7, 8, 9]
# Чтобы удалить последний элемент, вызовем метод pop без аргументов
numbers. pop ()
print (numbers)
# [2, 3, 5, 6, 7, 8]
numbers. pop ()
print (numbers)
# [2, 3, 5, 6, 7]

Теперь мы знаем, как удалять элемент из списка по его индексу. Но что, если мы не знаем индекса элемента, но знаем его значение? Для такого случая у нас есть метод remove() , который удаляет первый найденный по значению элемент в списке.

all_types = [ 10 , ‘Python’ , 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]]
all_types. remove ( 3.14 )
print (all_types)
# [10, ‘Python’, 10, ‘Python’, [‘I’, ‘am’, ‘list’]]
all_types. remove ( 10 )
print (all_types)
# [‘Python’, 10, ‘Python’, [‘I’, ‘am’, ‘list’]]
all_types. remove ( ‘Python’ )
print (all_types) # [10, ‘Python’, [‘I’, ‘am’, ‘list’]]

А сейчас немного посчитаем, посчитаем элементы списка с помощью метода count()

numbers = [ 100 , 100 , 100 , 200 , 200 , 500 , 500 , 500 , 500 , 500 , 999 ]
print (numbers. count ( 100 ))
# 3
print (numbers. count ( 200 ))
# 2
print (numbers. count ( 500 ))
# 5
print (numbers. count ( 999 ))
# 1

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

numbers = [ 100 , 2 , 11 , 9 , 3 , 1024 , 567 , 78 ]
numbers. sort ()
print (numbers)
# [2, 3, 9, 11, 78, 100, 567, 1024]
fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. sort ()
print (fruits)
# [‘Apple’, ‘Banan’, ‘Grape’, ‘Orange’, ‘Peach’]

Мы можем изменять порядок сортировки с помощью параметра reverse . По умолчанию этот параметр равен False

fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. sort ()
print (fruits)
# [‘Apple’, ‘Banan’, ‘Grape’, ‘Orange’, ‘Peach’]
fruits. sort ( reverse = True )
print (fruits)
# [‘Peach’, ‘Orange’, ‘Grape’, ‘Banan’, ‘Apple’]

Иногда нам нужно перевернуть список, не спрашивайте меня зачем. Для этого в самом лучшем языке программирования на этой планете JavaScr..Python есть метод reverse() :

numbers = [ 100 , 2 , 11 , 9 , 3 , 1024 , 567 , 78 ]
numbers. reverse ()
print (numbers)
# [78, 567, 1024, 3, 9, 11, 2, 100]
fruits = [ ‘Orange ‘, ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. reverse ()
print (fruits)
# [‘Apple’, ‘Banan’, ‘Peach’, ‘Grape’, ‘Orange’]

Допустим, у нас есть два списка и нам нужно их объединить. Программисты на C++ cразу же кинулись писать циклы for , но мы пишем на python , а в python у списков есть полезный метод extend() . Этот метод вызывается для одного списка, а в качестве аргумента ему передается другой список, extend() записывает в конец первого из них начало второго:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
vegetables = [ ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]
fruits. extend (vegetables)
print (fruits)
# [‘Banana’, ‘Apple’, ‘Grape’, ‘Tomato’, ‘Cucumber’, ‘Potato’, ‘Carrot’]

В природе существует специальный метод для очистки списка — clear()

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
vegetables = [ ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]
fruits. clear ()
vegetables. clear ()
print (fruits)
# []
print (vegetables)
# []

Осталось совсем чуть-чуть всего лишь пара методов, так что делаем последний рывок! Метод index() возвращает индекс элемента. Работает это так: вы передаете в качестве аргумента в index() значение элемента, а метод возвращает его индекс:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
print (fruits. index ( ‘Apple’ ))
# 1
print (fruits. index ( ‘Banana’ ))
# 0
print (fruits. index ( ‘Grape’ ))
# 2

Финишная прямая! Метод copy() , только не падайте, копирует список и возвращает его брата-близнеца. Вообще, копирование списков — это тема достаточно интересная, давайте рассмотрим её по-подробнее.

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

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits
print (fruits)
# [‘Banana’, ‘Apple’, ‘Grape’]
print (new_fruits)
# [‘Banana’, ‘Apple’, ‘Grape’]

Но есть одно маленькое «НО»:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits
fruits. pop ()
print (fruits)
# [‘Banana’, ‘Apple’]
print (new_fruits)
# Внезапно, из списка new_fruits исчез последний элемент
# [‘Banana’, ‘Apple’]

При прямом присваивании списков копирования не происходит. Обе переменные начинают ссылаться на один и тот же список! То есть если мы изменим один из них, то изменится и другой. Что же тогда делать? Пользоваться методом copy() , конечно:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits. copy ()
fruits. pop ()
print (fruits)
# [‘Banana’, ‘Apple’]
print (new_fruits)
# [‘Banana’, ‘Apple’, ‘Grape’]

Отлично! Но что если у нас список в списке? Скопируется ли внутренний список с помощью метода copy() — нет:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ , [ ‘Orange’ , ‘Peach’ ]]
new_fruits = fruits. copy ()
fruits[ — 1 ]. pop ()
print (fruits)
# [‘Banana’, ‘Apple’, ‘Grape’, [‘Orange’]]
print (new_fruits)
# [‘Banana’, ‘Apple’, ‘Grape’, [‘Orange’]]

Списки в Python: что это такое и как с ними работать

Рассказали всё самое важное о списках для тех, кто только становится «змееустом».

Иллюстрация: Оля Ежак для Skillbox Media

Дмитрий Зверев

Сегодня мы подробно поговорим о, пожалуй, самых важных объектах в Python — списках. Разберём, зачем они нужны, как их использовать и какие удобные функции есть для работы с ними.

В статье есть всё, что начинающим разработчикам нужно знать о списках в Python:

Что такое списки

Список (list) — это упорядоченный набор элементов, каждый из которых имеет свой номер, или индекс, позволяющий быстро получить к нему доступ. Нумерация элементов в списке начинается с 0: почему-то так сложилось в C, а C — это база. Теорий на этот счёт много — на «Хабре» даже вышло большое расследование 🙂

В одном списке одновременно могут лежать данные разных типов — например, и строки, и числа. А ещё в один список можно положить другой и ничего не сломается:

Все элементы в списке пронумерованы. Мы можем без проблем узнать индекс элемента и обратиться по нему.

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

Когда мы создаём объект list, в памяти компьютера под него резервируется место. Нам не нужно переживать о том, сколько выделяется места и когда оно освобождается, — Python всё сделает сам. Например, когда мы добавляем новые элементы, он выделяет память, а когда удаляем старые — освобождает.

Под капотом списков в Python лежит структура данных под названием «массив». У массива есть два важных свойства: под каждый элемент он резервирует одинаковое количество памяти, а все элементы следуют друг за другом, без «пробелов».

Однако в списках Python можно хранить объекты разного размера и типа. Более того, размер массива ограничен, а размер списка в Python — нет. Но всё равно мы знаем, сколько у нас элементов, а значит, можем обратиться к любому из них с помощью индексов.

И тут есть небольшой трюк: списки в Python представляют собой массив ссылок. Да-да, решение очень элегантное — каждый элемент такого массива хранит не сами данные, а ссылку на их расположение в памяти компьютера!

Как создать список в Python

Чтобы создать объект list, в Python используют квадратные скобки — []. Внутри них перечисляют элементы через запятую:

Мы создали список a и поместили в него три числа, которые разделили запятыми. Давайте выведем его с помощью функции print():

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

Мы уже говорили, что списки могут хранить данные любого типа. В примере ниже объект b хранит: строку — cat, число — 123 и булево значение — True:

Также в Python можно создавать вложенные списки:

Мы получили объект, состоящий из двух чисел — 1 и 2 — и вложенного list с двумя элементами — [3, 4].

Операции со списками

Если просто хранить данные в списках, то от них будет мало толку. Поэтому давайте рассмотрим, какие операции они позволяют выполнить.

Индексация

Доступ к элементам списка получают по индексам, через квадратные скобки []:

Мы обратились ко второму элементу и вывели его с помощью print().

Здесь важно помнить две вещи:

у каждого элемента есть свой индекс;
индексы начинаются с 0.

Давайте ещё поиграем с индексами:

В последней строке мы обратились к несуществующему индексу, поэтому Python выдал ошибку.

Кроме того, Python поддерживает обращение к нескольким элементам сразу — через интервал. Делается это с помощью двоеточия — :.

Двоеточие позволяет получить срез списка. Полная форма оператора выглядит так: начальный_индекс:конечный_индекс:шаг.

Здесь мы указываем, с какого индекса начинается «срез», на каком заканчивается и с каким шагом берутся элементы — по умолчанию 1. Единственный нюанс с конечным индексом: хоть мы и можем подумать, что закончим именно на нём, на самом деле Python остановится на элементе с индексом конечный_индекс — 1. Почему создатели языка решили так сделать? Кто их знает.

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

Здесь мы шли по элементам с шагом 2. Начали с индекса 1 — это первое число внутри скобок, а закончили на индексе 6, не включая его. Двигались с шагом 2, то есть через один элемент, и получили [2, 4].

Протестируйте этот тип индексации сами, чтобы лучше понять, как работают срезы в Python.

Изменение элементов

Списки — это динамическая структура данных. А значит, мы можем менять их уже после создания.

Например, можно заменить один элемент на другой:

Мы обратились к элементу по индексу и заменили его на число 4. Всё прошло успешно, список изменился.

Но нужно быть осторожными, потому что может случиться такое:

Сначала мы создали список a с двумя элементами — 1 и 2. Затем объявили переменную b и присвоили ей содержимое a. Потом заменили первый элемент в a и… удивились, что он заменился и в b.

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

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

Поэтому, когда мы присвоили списку b список a, то на самом деле присвоили ему ссылку на первый элемент — по сути, сделав их одним списком.

Объединение списков

Иногда полезно объединить два списка. Чтобы это сделать, используют оператор +:

Мы создали два списка — a и b. Затем переприсвоили a новым списком, который стал объединением старого a и b.

Разложение списка

Элементы списка можно присвоить отдельным переменным:

Здесь из списка a поочерёдно достаются элементы, начиная с индекса 0, и присваиваются переменным. И в отличие от присвоения одного списка другому, в этом случае Python создаст три отдельных целых числа, которые никак не будут связаны с элементами списка, и присвоит их трём переменным. Поэтому, если мы изменим, например, переменную d2, со списком a ничего не случится.

Перебор элементов

Мы можем перебирать элементы списка с помощью циклов for и while.

https://amdy.su/wp-admin/options-general.php?page=ad-inserter.php#tab-8

Так выглядит перебор через for:

Здесь мы перебираем каждый элемент списка и выводим их с помощью функции print().

А вот так выглядит перебор через цикл while:

Этот перебор чуть сложнее, потому что мы используем дополнительную переменную i, чтобы обращаться к элементам списка. Также мы использовали встроенную функцию len(), чтобы узнать размер нашего списка. А ещё в условии цикла while мы указали знак «меньше» (<), потому что индексация элементов идёт до значения количество элементов списка — 1. Как и в прошлом примере, все элементы по очереди выводятся с помощью функции print().

Сравнение списков

Python поддерживает сравнение списков. Два списка считаются равными, если они содержат одинаковые элементы. Функция возвращает булево значение — True или False:

Получили, что списки равны.

В некоторых языках равенство ещё проверяется и по тому, ссылаются ли переменные на один и тот же объект. Обычно это делается через оператор ===. В Python это можно сделать через оператор is, который проверяет, имеют ли две переменные один и тот же адрес в памяти:

Получили, что две переменные ссылаются на один и тот же адрес в памяти.

Встроенные функции для списков Python

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

len()

Возвращает длину списка:

sorted()

Возвращает отсортированный список:

min() и max()

Возвращают наименьший и наибольший элемент списка:

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

Чтобы проще управлять элементами списка, в стандартной библиотеке Python есть набор популярных методов для списков. Разберём основные из них.

append()

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

extend()

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

Внутрь метода extend() нужно передать итерируемый объект — например, другой list или строку.

Вот так метод extend() добавит строку:

Заметьте, что строка добавилась посимвольно.

insert()

Добавляет новый элемент по индексу:

Сначала мы передаём индекс, по которому хотим вставить новый элемент, а затем сам элемент.

remove()

Удаляет элемент из списка:

Метод удаляет только первое вхождение элемента. Остальные остаются нетронутыми.

Если элемента нет в списке, Python вернёт ошибку и программа прервётся:

Ошибка говорит, что элемента нет в списке.

clear()

Удаляет все элементы из списка и делает его пустым:

index()

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

Если элемента нет в списке, выведется ошибка:

pop()

Удаляет элемент по индексу и возвращает его как результат:

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

count()

Считает, сколько раз элемент повторяется в списке:

sort()

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

reverse()

Переставляет элементы в обратном порядке:

copy()

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

Метод	Что делает
a.append(x)	Добавляет элемент x в конец списка a. Если x — список, то он появится в a как вложенный
a.extend(b)	Добавляет в конец a все элементы списка b
a.insert(i, x)	Вставляет элемент x на позицию i
a.remove(x)	Удаляет в a первый элемент, значение которого равно x
a.clear()	Удаляет все элементы из списка a и делает его пустым
a.index(x)	Возвращает индекс элемента списка
a.pop(i)	Удаляет элемент по индексу и возвращает его
a.count(x)	Считает, сколько раз элемент повторяется в списке
a.sort()	Сортирует список. Чтобы отсортировать элементы в обратном порядке, нужно установить дополнительный аргумент reverse=True
a.reverse()	Возвращает обратный итератор списка a
a.copy()	Создаёт поверхностную копию списка. Для создания глубокой копии используйте метод deepcopy из модуля copy

Что запомнить

Лучше не учить это всё, а применять на практике. А ещё лучше — попытаться написать каждый метод самостоятельно, не используя никакие встроенные функции.

Сколько бы вы ни писали код на Python, всё равно придётся подсматривать в документацию и понимать, какой метод что делает. И для этого есть разные удобные сайты — например, полный список методов можно посмотреть на W3Schools.

Списки в Python

Как и строки, списки в языке Python относятся к упорядоченным последовательностям. Однако в отличие от строк, списки являются изменяемыми объектами и могут содержать значения любых типов: уже известные нам числа и строки, сами списки, а также объекты любого другого типа данных. При этом изменяться списки могут непосредственно без всяких дополнительных манипуляций и фокусов. Сделать это можно как при помощи операций присваивания по индексам и срезам, так и при помощи методов типа или специальной инструкции удаления del . По сути списки являются самым гибким типом упорядоченных коллекций в Python , реализуя практически все необходимое для создания и обработки структур данных любой степени сложности. Итак.

(от англ. list) – это изменяемая упорядоченная коллекция объектов произвольного типа. Сами объекты называются , а доступ к ним может быть получен при помощи целочисленного индекса или среза.

Создание списков в Python

Проще всего литерал списка в Python создается при помощи квадратных скобок, внутри которых элементы списка перечисляются через запятую (см. пример №1 ). В случае необходимости последний элемент списка можно также завершать запятой. Это никак не повлияет на количество элементов списка, а значит и его длину.

Пример №1. Создание списков в Python (часть 1).

Как видим, внутри списков действительно разрешается использовать объекты любого типа данных, создавая при этом любые их комбинации и уровни вложенности. А благодаря наличию в синтаксисе квадратных скобок, сложные и объемные литералы списков можно без проблем записывать на нескольких строках, придавая исходному коду удобочитаемый вид.

Создать список можно также при помощи встроенного конструктора типа list() . Если использовать его без аргумента, то он вернет нам пустой список. Если же передать ему итерируемый объект, например, строку или кортеж, то конструктор вернет список, элементами которого будут соответствующие элементы переданного объекта (см. пример №2 ).

Пример №2. Создание списков в Python (часть 2).

Но и это еще не все. В Python для создания списков могут использоваться специальные генераторы списков, которые применяют выражение к каждому элементу передаваемого итерируемого объекта и на основе их вычисления возвращают новый список (см. пример №3 ).

Пример №3. Создание списков в Python (часть 3).

Таким образом, в простейшем случае для генерации списка нужно в квадратных скобках написать выражение, которое будет применяться к каждому элементу передаваемого итерируемого объекта, и через пробел прописать соответствующий заголовок цикла for без завершающего двоеточия. Но это в простейшем случае. Полный синтаксис генераторов мы рассмотрим в отдельном параграфе позже.

Стоит заметить, что любой генератор списка можно реализовать через цикл for . Более того, в сложных случаях именно так и следует поступать. Но в простейших случаях генераторы списка интуитивно понятнее, работают чуть быстрее цикла for и занимают чуть меньше места по объему кода.

Доступ по индексу и срезы списков

Операции доступа по индексу и получения срезов для списков имеют практически тот же самый синтаксис и смысл, что и для строк (см. пример №4 ).

Пример №4. Доступ к элементам списка по индексу (часть 1).

Однако в отличие от строк списки являются изменяемыми последовательностями. Поэтому в результате обращения к элементу списка по его индексу возвращается некоторый объект, расположенный по указанному смещению. А поскольку таким объектом может оказаться не только строка, но и любой другой объект, то для получения доступа к элементам на более глубоком уровне вложенности может потребоваться целая цепочка из нескольких индексов (см. пример №5 ).

Пример №5. Доступ к элементам списка по индексу (часть 2).

Следует добавить, что цепочка доступа к конкретному элементу может иметь и более сложную конструкцию, включающую не только квадратные скобки с индексами для доступа к элементам списков, но и квадратные скобки с ключами для доступа к элементам словарей, и точки для доступа к атрибутам объектов. Например, для списка li = [<'one': 'top', 'two': ['abc', [4, 5]]>, 0.3] цепочка получения доступа ко второму элементу вложенного списка [4, 5] будет иметь вид li[0][‘two’][1][1] .

Что касается получения срезов для списков, то в результате операции всегда возвращается новый список, состоящий из указанных в срезе элементов исходного списка (см. пример №6 ). Сам же исходный список не изменяется до тех пор, пока мы не присвоим срезу новое значение (см. примеры №8 и №9 ).

Пример №6. Операция взятия среза у списков.

При извлечении срезов следует помнить, что нумерация элементов в списках начинается с нуля, а элемент с индексом второго предела, указанного в квадратных скобках, не будет присутствовать в срезе. Например, в срезе списка li_1[0:7] будут присутствовать первые семь элементов с индексами от 0 до 6 , но не включая элемент с индексом 7 .

Как и в случае со строками, один или оба предела среза можно опускать. Если не указывать первый предел, интерпретатор будет начинать срез с первого элемента списка (с индексом 0 ), а при отсутствии второго предела срез будет идти до конца списка. Если опустить оба предела, мы получим копию списка. Опять же, при необходимости разрешается указывать и третий предел, который будет задавать шаг среза (см. пример №7 ).

Пример №7. Порядок использования шага среза у списков.

Как видим, шаг среза также может иметь отрицательное значение (аналогично строкам). В этом случае отсчет элементов списка и шагов ведется в противоположном направлении, а границы среза указываются справа налево, т.е. индекс элемента, стоящего правее в списке должен указываться первым. Например, в срезе примера li_1[-3:1:-3] отсчет ведется справа налево, начиная с 3 -го элемента, отсчитываемого с конца списка, до элемента с индексом 1 , который находится левее и в срез не включается.

Изменяемость списков означает, что мы можем не только получать доступ к элементам списка, но также изменять их значения, вообще удалять или добавлять в список новые элементы. При этом изменению подвергается не копия списка, как в случае со строками, а непосредственно сам список. Так для изменения значения отдельного элемента списка нужно просто найти элемент в списке по индексу и присвоить ему новое значение (см. пример №8 ).

Пример №8. Изменение значений элементов списков.

В более сложных случаях, когда нужно удалить или добавить элементы, а также изменить значения сразу нескольких элементов, следует использовать срезы (см. пример №9 ).

Пример №9. Изменение списков при помощи срезов (часть 1).

Обратите внимание, что для удаления конкретного элемента списка нужно взять срез, включающий только этот элемент, и присвоить ему пустой список. Если же использовать просто индекс, элемент останется, а пустой список станет его значением (см. предыдущий пример №8 ). Кроме того, при использовании срезов присваиваться должны итерируемые объекты, например, списки, строки или кортежи. В противном случае интерпретатор выдаст ошибку.

При желании в срезах можно использовать и третий параметр, т.е. шаг среза. Но здесь нужно быть осторожным, т.к. количество элементов такого среза должно соответствовать количеству элементов в присваиваемом итерируемом объекте (см. пример №10 ).

Пример №10. Изменение списков при помощи срезов (часть 2).

Как видим, операции взятия среза у списков обладают внушительным арсеналом возможностей. Более того, при помощи этих возможностей вполне могут быть реализованы и некоторые методы класса list , которые мы рассмотрим чуть ниже.

Операторы списков в Python

Поскольку списки относятся к упорядоченным последовательностям, то операторы + , += , * и *= имеют для них практически тот же смысл, что и для строк (см. пример №11 ).

Пример №11. Использование операторов + и * применительно к спискам.

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

Что касается оператора проверки на вхождение in , то применительно к спискам он совершает поиск требуемого объекта (левый операнд) среди элементов целевого списка (правый операнд). В случае успеха операция возвращает True , иначе – False (см. пример №12 ).

Пример №12. Использование оператора in применительно к спискам.

Напомним, что оператор in может использоваться не только самостоятельно, но и совместно с оператором отрицания not , который инверсирует возвращаемое логическое значение оператора in . Соответственно, например, операция ‘крот’ not in [‘кот’, ‘кит’] вернет True вместо False .

Если возникает необходимость в обходе элементов списка, то, по аналогии со строками, можно смело использовать оператор цикла for (см. пример №13 ).

Пример №13. Использование цикла for для обхода элементов списка.

Оператор идентичности is возвращает True , если оба операнда указывают на один и тот же объект в памяти компьютера. В противном случае операция возвращает False . Например, инструкция type(0.53) is float вернет True , т.к. вызов функции type(0.53) возвращает не что иное, как сам объект типа float . Добавим, что как и оператор проверки на вхождение in , оператор is может использоваться совместно с оператором отрицания not .

Еще одним полезным и универсальным оператором языка Python является оператор удаления del , который позволяет с легкостью удалять переменные, элементы по индексу или ключу, атрибуты объектов и т.д. Применительно к спискам мы можем использовать del для удаления всего списка, срезов или отдельных его элементов (см. пример №14 ).

Пример №14. Использование оператора del применительно к спискам.

На этом рассмотрение базовых операций над списками мы заканчиваем. Осталось рассмотреть методы класса list и встроенные функции, применимые к спискам.

Функции и методы списков в Python

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

li.count(x) – возвращает количество в списке li элементов с указанным значением x (см. пример №15 ). Отметим, что в отличие от аналогичного метода для строк, здесь указывать интервал для поиска нельзя, т.к. метод принимает только один аргумент.
li.index(x[, start[, end]]) – возвращает индекс i первого вхождения элемента li[i] со значением x в список li или в срез списка li[start:end] , если он задан. В случае неудачного поиска метод вызывает исключение ValueError . Обратите внимание, что при использовании среза отсчет индекса элемента все равно стартует с начала всего списка.

Пример №15. Методы списков (часть 1).

li.insert(i, x) – вставляет элемент со значением x в указанную позицию i . Тот же результат можно получить и при помощи инструкции li[i:i] = [x] (см. пример №16 ).
li.append(x) – добавляет элемент со значением x в конец списка li (тоже самое что и li[len(li):len(li)] = [x] ).
li.extend(iterable) – добавляет элементы из итерируемого объекта iterable в конец списка li (тоже самое что и li[len(li):len(li)] = iterable ). Не забываем, что итерируемыми являются, например, строки, списки, кортежи, но не числа.

Пример №16. Методы списков (часть 2).

li.remove(x) – удаляет из списка li первый попавшийся элемент, имеющий значение x . Если элемента с указанным значением в списке не окажется, будет вызвано исключение ValueError (см. пример №17 ).
li.pop([i]) – удаляет из списка li элемент с указанным индексом i , а затем возвращает его. Если индекс не указан (параметр необязательный), удаляется последний элемент списка, т.к. по умолчанию i принимается равным -1 .
li.clear() – удаляет все элементы из списка (тоже самое что и del li[:] ).

Пример №17. Методы списков (часть 3).

li.reverse() – изменяет порядок следования элементов в списке li на обратный. Получить тот же результат можно и с помощью инструкции li = li[::-1] (см. пример №18 ).
li.copy() – возвращает поверхностную копию списка li ( li[:] ).

Пример №18. Методы списков (часть 4).

li.sort(*, key=None, reverse=False) – сортирует элементы списка li . При сортировке используется обычная операция сравнения при помощи оператора < . Соответственно сортировать в одном списке числа и строки без манипуляций не получится. Если же нужно повлиять на алгоритм сортировки элементов списка, следует использовать собственную функцию сравнения, принимающую единственный аргумент и возвращающую значение, которое и будет использовано в операции сравнения. Объект функции нужно передать в качестве значения именованному аргументу key=my_func . Тогда при сортировке для каждого элемента списка будет вызываться переданная функция, а в сравнении будет участвовать не сам элемент, а результат вызова функции (см. пример №19 ). Кроме того, если использовать именованный аргумент reverse=True , сортировка будет производиться в обратном порядке.

Пример №19. Методы списков (часть 5).

Помимо собственных методов к спискам применим и ряд встроенных функций: min() (возвращает элемент с минимальным значением, при этом элементы должны быть одного типа с возможностью сравнения), max() (возвращает элемент с максимальным значением, при этом элементы должны быть одного типа с возможностью сравнения), sum() (возвращает сумму элементов списка, при этом элементы должны быть числами), len() (возвращает количество элементов в списке), sorted(iterable, *, key=None, reverse=False) (встроенная функция сортировки), filter(function, iterable) (фильтрация элементов списка) и т. д.

Краткие итоги параграфа

В Python списки представляют собой упорядоченные изменяемые коллекции объектов произвольного типа с доступом по индексу.
Чтобы создать список достаточно перечислить требуемые объекты (элементы списка) через запятую внутри квадратных скобок (например, li = [5.3, ‘слон’, 2] ). Доступ к элементу списка можно получить по его индексу, т.е. порядковому номеру элемента в списке. При этом следует помнить, что индексация элементов в списках начинается с нуля (например, инструкция print(li[0]) выведет первый элемент списка, т.е. число 5.3 ).
Также списки могут быть созданы при помощи конструктора list(iterable) (например, инструкция list(‘abc’) вернет список [‘a’, ‘b’, ‘c’] ) и генератора списков (например, [simb for simb in ‘abc’] вернет тот же список [‘a’, ‘b’, ‘c’] ).
Что касается срезов, то для списков они имеют практически тот же смысл, что и для строк. Однако здесь операция среза всегда возвращает новый список, состоящий из указанных в срезе элементов исходного списка. Сам же исходный список не изменяется до тех пор, пока мы не присвоим срезу новое значение.
Поскольку списки являются изменяемыми последовательностями, их можно изменять непосредственно: удалять элементы, добавлять новые, изменять значения уже существующих элементов. Например, пусть у нас есть список li = [1, 2, 3] . Тогда инструкция li[0:0] = [4] добавляет в начало списка новый элемент, li[0] = 5 изменяет значение первого элемента списка, а del li[1] удаляет второй элемент списка.
Применимы к спискам и знакомые нам арифметические операторы. Так оператор + используется для объединения списков (например, операция конкатенации [1, 2] + [3, 4] вернет список [1, 2, 3, 4] ), а комбинированный оператор += расширяет целевой список (левый операнд) за счет элементов присоединяемого в конец дополнительного списка, т.е. правого операнда (например, в результате выполнения инструкций li = [1, 2] и li += [3, 4] в переменной будет храниться список [1, 2, 3, 4] ). Что касается оператора умножения * и соответсвующего ему комбинированного оператора *= , то они расширяют список за счет дублирования имеющихся элементов указанное число раз (например, в результате выполнения инструкций li = [1, 2] и li *= 3 в переменной будет храниться список [1, 2, 1, 2, 1, 2] ).
К спискам применимы оператор in и цикл for . Первый проверяет наличие требуемого объекта среди элементов целевого списка, а второй позволяет поочередно обойти все элементы списка. Кроме того, поскольку списки относятся к изменяемым последовательностям, для них доступен еще и оператор удаления del , который позволяет удалять не только отдельные элементы списка, но также срезы и сам список целиком.
В конце мы познакомились с рядом методов типа list . Опять же, они дают нам возможность выполнять широкий спектр операций над списками, а для их использования не нужно импортировать никаких модулей, т.к. они уже встроены в сам интерпретатор. Однако не стоит забывать, что в отличие от строк, списки изменяемы, поэтому их методы в основном изменяют список непосредственно, а не возвращают его измененную копию. Найти методы списков можно в подразделе «Sequence Types – list, tuple, range» раздела «Built-in types» стандартной библиотеки.

Помогите проекту, подпишитесь!

Подписка на учебные материалы сайта оформляется сроком на один год и стоит около 15 у.е. После подписки вам станут доступны следующие возможности.

Доступ ко всем ответам на вопросы и решениям задач.
Возможность загрузки учебных кодов и программ на свой компьютер.
Доступ ко всем тренажерам и видеоурокам. Доступ к видеотрансляциям и онлайн-курсам.
Возможность внести свой скромный вклад в развитие проекта и мира во всем мире, а также выразить свою благодарить автору за его труд. Нам очень нужна ваша поддержка!

Python для начинающих

На страницу подписки

Вопросы и задания для самоконтроля

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

Ответ. Списки относятся к изменяемым упорядоченным коллекциям объектов. Так что утверждение о том, что списки неизменяемы, ложно.

2. Можно ли поменять местами элементы списка? Удалить или добавить новые? Почему? Показать решение.

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

3. Какие из представленых литералов относятся к типу list : [‘зимний’, ‘летний’] , 5.0 , ‘[3, 4]’ , «Питон, Python» ? Проверьте типы программно. Показать решение.

Списки, кортежи и словари

Для работы с наборами данных Python предоставляет такие встроенные типы как списки, кортежи и словари.

Список (list) представляет тип данных, который хранит набор или последовательность элементов. Во многих языках программирования есть аналогичная структура данных, которая называется массив.

Создание списка

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

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

Также для создания списка можно использовать функцию-конструктор list() :

Оба этих определения списка аналогичны — они создают пустой список.

Список необязательно должен содержать только однотипные объекты. Мы можем поместить в один и тот же список одновременно строки, числа, объекты других типов данных:

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

Конструктор list может принимать набор значений, на основе которых создается список:

Если необходимо создать список, в котором повторяется одно и то же значение несколько раз, то можно использовать символ звездочки *, то есть фактически применить операцию умножения к уже существующему списку:

Обращение к элементам списка

Для обращения к элементам списка надо использовать индексы, которые представляют номер элемента в списка. Индексы начинаются с нуля. То есть первый элемент будет иметь индекс 0, второй элемент — индекс 1 и так далее. Для обращения к элементам с конца можно использовать отрицательные индексы, начиная с -1. То есть у последнего элемента будет индекс -1, у предпоследнего — -2 и так далее.

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