Понимание списков в Python 3

Введение

A list is a data structure in Python that is a mutable, or changeable, ordered sequence of elements. Each element or value that is inside of a list is called an item. Just as strings are defined as characters between quotes, lists are defined by having values between square brackets [ ].

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

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

Предварительные требования

У вас должен быть установлен Python 3 и настроена среда программирования на вашем компьютере или сервере. Если у вас нет настроенной среды программирования, вы можете обратиться к руководствам по установке и настройке для локальной среды программирования или для среды программирования на вашем сервере, подходящей для вашей операционной системы (Ubuntu, CentOS, Debian и т. д.).

Строковые списки

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

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

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

print(sea_creatures)

Output
['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

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

В этом руководстве мы рассмотрим некоторые способы работы со списками в Python.

Индексация списков

Каждый элемент в списке соответствует номеру индекса, который является целым числом, начиная с номера индекса 0.

Для списка sea_creatures разбиение по индексу выглядит так:

Первый элемент, строка 'shark', начинается с индекса 0, и список заканчивается на индексе 4 с элементом 'anemone'.

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

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

print(sea_creatures[1])

Output
cuttlefish

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

sea_creatures[0] = 'shark'
sea_creatures[1] = 'cuttlefish'
sea_creatures[2] = 'squid'
sea_creatures[3] = 'mantis shrimp'
sea_creatures[4] = 'anemone'

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

print(sea_creatures[18])

Output
IndexError: list index out of range

Помимо положительных номеров индексов, мы также можем получить доступ к элементам списка с отрицательным номером индекса, отсчитывая их с конца списка, начиная с -1. Это особенно полезно, если у нас есть длинный список, и мы хотим указать на элемент к концу списка.

Для того же списка sea_creatures отрицательный разбор индексов выглядит следующим образом:

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

print(sea_creatures[-3])

Output
squid

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

print('Sammy is a ' + sea_creatures[0])

Output
Sammy is a shark

Мы смогли объединить строковый элемент по индексу номер 0 со строкой 'Сэмми - '. Мы также можем использовать оператор + для конкатенации двух или более списков вместе.

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

Изменение элементов в списках

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

Если мы хотим изменить строковое значение элемента с индексом 1 с 'чернильная рыба' на 'осьминог', мы можем сделать это так:

sea_creatures[1] = 'octopus'

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

print(sea_creatures)

Output
['shark', 'octopus', 'squid', 'mantis shrimp', 'anemone']

Мы также можем изменить значение элемента, используя отрицательный номер индекса:

sea_creatures[-3] = 'blobfish'
print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']

Теперь 'пузырепод' заменил 'кальмар' на отрицательном номере индекса -3 (который соответствует положительному номеру индекса 2).

Способность изменять элементы в списках дает нам возможность изменять и обновлять списки эффективным способом.

Разделение списков

Мы также можем выбрать несколько элементов из списка. Допустим, мы хотим вывести только средние элементы из sea_creatures, мы можем сделать это, создав срез. С помощью срезов мы можем вызвать несколько значений, создав диапазон индексов, разделенных двоеточием [x:y]:

print(sea_creatures[1:4])

Output
['octopus', 'blobfish', 'mantis shrimp']

При создании среза, как в [1:4], первое число индекса – это место начала среза (включительно), а второе число индекса – это место окончания среза (исключительно), поэтому в нашем примере выше элементы на позиции, 1, 2 и 3 выводятся.

Если мы хотим включить один из концов списка, мы можем опустить одно из чисел в синтаксисе list[x:y]. Например, если мы хотим вывести первые 3 элемента списка sea_creatures – которые будут 'shark', 'octopus', 'blobfish' – мы можем сделать это, набрав:

print(sea_creatures[:3])

Output
['shark', 'octopus', 'blobfish']

Это вывело начало списка, останавливаясь прямо перед индексом 3.

Чтобы включить все элементы в конце списка, мы бы изменили синтаксис:

print(sea_creatures[2:])

Output
['blobfish', 'mantis shrimp', 'anemone']

Мы также можем использовать отрицательные числовые индексы при разделении списков, аналогично положительным числовым индексам:

print(sea_creatures[-4:-2])
print(sea_creatures[-3:])

Output
['octopus', 'blobfish']
['blobfish', 'mantis shrimp', 'anemone']

Один последний параметр, который мы можем использовать срезанием, называется stride, который относится к тому, сколько элементов двигаться вперед после того, как первый элемент извлечен из списка. До сих пор мы опускали параметр шага, и Python по умолчанию устанавливает шаг равным 1, так что между двумя номерами индексов извлекаются все элементы.

Синтаксис этой конструкции выглядит так: list[x:y:z], где z относится к шагу. Давайте создадим более крупный список, затем нарежем его и установим шаг в значение 2:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

print(numbers[1:11:2])

Output
[1, 3, 5, 7, 9]

Наша конструкция numbers[1:11:2] выводит значения между индексными номерами включительно от 1 и исключительно до 11, затем значение шага 2 указывает программе выводить только каждый второй элемент.

Мы можем опустить первые два параметра и использовать только шаг в качестве параметра синтаксиса list[::z]:

print(numbers[::3])

Output
[0, 3, 6, 9, 12]

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

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Срезание списков с положительными и отрицательными индексными номерами и указание шага позволяет нам контролировать списки и получать нужный нам вывод.

Изменение списков с помощью операторов

Операторы можно использовать для внесения изменений в списки. Мы рассмотрим использование операторов + и *, а также их составные формы += и *=.

Оператор + можно использовать для объединения двух или более списков:

sea_creatures = ['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']
oceans = ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

print(sea_creatures + oceans)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Поскольку оператор + может выполнять объединение, его можно использовать для добавления элемента (или нескольких) в виде списка в конец другого списка. Не забудьте поместить элемент в квадратные скобки:

sea_creatures = sea_creatures + ['yeti crab']
print (sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

Оператор * можно использовать для умножения списков. Возможно, вам нужно сделать копии всех файлов в каталоге на сервере или поделиться плейлистом с друзьями – в этих случаях вам потребуется умножить коллекции данных.

Давайте умножим список sea_creatures на 2 и список oceans на 3:

print(sea_creatures * 2)
print(oceans * 3)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']
['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Используя оператор *, мы можем реплицировать наши списки заданное количество раз.

Мы также можем использовать составные формы операторов + и * с оператором присваивания =. Составные операторы += и *= могут использоваться для заполнения списков быстрым и автоматизированным способом. Вы можете использовать эти операторы, чтобы заполнить списки заполнителями, которые вы можете изменить впоследствии с помощью предоставленных пользователем данных, например.

Давайте добавим элемент в виде списка в список sea_creatures. Этот элемент будет служить заполнителем, и мы хотели бы добавить этот элемент-заполнитель несколько раз. Для этого мы будем использовать оператор += с циклом for.

for x in range(1,4):
    sea_creatures += ['fish']
    print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish', 'fish']

На каждой итерации цикла for в исходный список sea_creatures добавляется дополнительный элемент списка ‘fish’.

Оператор *= ведет себя аналогичным образом:

sharks = ['shark']

for x in range(1,4):
    sharks *= 2
    print(sharks)

Output
['shark', 'shark']
['shark', 'shark', 'shark', 'shark']
['shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

Операторы + и * могут использоваться для конкатенации списков и умножения списков. Составные операторы += и *= могут конкатенировать списки и умножать списки, передавая новую идентичность исходному списку.

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

Элементы можно удалять из списков с помощью оператора del. Это удалит значение по указанному вами номеру индекса в списке.

Из списка sea_creatures давайте удалим элемент ‘octopus’. Этот элемент находится на позиции индекса 1. Чтобы удалить элемент, мы будем использовать оператор del, затем вызовем переменную списка и номер индекса этого элемента:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1]
print(sea_creatures)

Output
['shark', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

Теперь элемент на позиции индекса 1, строка ‘octopus’, больше не находится в нашем списке sea_creatures.

Мы также можем указать диапазон с оператором del. Скажем, мы хотели бы удалить не только элемент ‘octopus’, но также ‘blobfish’ и ‘mantis shrimp’. Мы можем вызвать диапазон в sea_creatures с оператором del, чтобы выполнить это:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1:4]
print(sea_creatures)

Output
['shark', 'anemone', 'yeti crab']

Используя диапазон с оператором del, мы смогли удалить элементы между индексами 1 (включительно) и 4 (исключительно), оставив список из 3 элементов после удаления 3 элементов.

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

Создание списка с элементами списка

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

sea_names = [['shark', 'octopus', 'squid', 'mantis shrimp'],['Sammy', 'Jesse', 'Drew', 'Jamie']]

Эти списки внутри списков называются вложенными списками.

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

print(sea_names[1][0])
print(sea_names[0][0])

Output
Sammy
shark

Первый список, так как он равен элементу, будет иметь индексное число 0, которое будет первым числом в конструкции, и второй список будет иметь индексное число 1. В каждом внутреннем вложенном списке будут отдельные индексные номера, которые мы будем вызывать во втором индексном номере:

sea_names[0][0] = 'shark'
sea_names[0][1] = 'octopus'
sea_names[0][2] = 'squid'
sea_names[0][3] = 'mantis shrimp'

sea_names[1][0] = 'Sammy'
sea_names[1][1] = 'Jesse'
sea_names[1][2] = 'Drew'
sea_names[1][3] = 'Jamie'

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

Заключение

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

Отсюда вы можете узнать больше о работе со списками в Python, прочитав “Как использовать методы списка”, и о включениях списка для создания списков на основе существующих списков. Чтобы узнать больше о типах данных в целом, вы можете прочитать наш учебник “Понимание типов данных”.