Что такое списки в Python?

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

Какой у списков в Python формальный синтаксис?


[value, value, ...]
list([iterable])

Для чего вообще нужны списки?

Списки в Python — одна из 4 структур данных, предназначенных для работы с итерируемыми объектами. Представим, что нам нужно написать скрипт, который проверяет, является ли модель машины производства компании Tesla. Код будет выглядеть следующим образом:

# Объявим переменную, содержащую список всех моделей машин
tesla_models = ['Model S', 'Model 3', 'Model X', 'Model Y'] # Название машины - это строка. Строки объявляются в двойных (") или одинарных (') кавычках
# Проверем, производит ли Tesla модель AMG GT 4 door. содержащую список всех моделей машин
print('AMG GT 4 door' in tesla_models) # Выведет False (Ложь). Эту модель производит Mercedes-Benz
# А Model 3  – флагманская модель Tesla
print('Model 3' in tesla_models) # Выведет True (Истина)
# Значения регистрозависимы — Model Y не одно и то же, что и model y
print('model y' in tesla_models) # Выведет False

Что еще можно делать со списками в Python?

Ниже собраны примеры решений задач на основные вопросы, с которыми сталкиваются Python разработчики и дата-саентисты:

Как узнать длину списка в Python?

Функция len(), позволяет получить одномерную длину списка.

len(['one', 'two']) # вернет 2
len(['one', [2, 3], 'four']) # вернет 3, а не 4


len() также работает со строками, словарями и другими структурами данных, схожими со списками.

Обратите внимание, что len() — это встроенная функция, а не метод списка.

Производительность функции len() равна O(1) (константная), то есть скорость получения длины списка не зависит от его длины.

Как проверить, существует ли элемент в списке?

За проверку вхождения значения в список отвечает оператор in.

lst = ['test', 'twest', 'tweast', 'treast']
'test' in lst # Вывод: True
'toast' in lst # Вывод: False

Примечание: оператор in в множествах асимптотически быстрее, чем в списках. Если его предстоит использовать много раз в потенциально больших списках, вы можете преобразовать список во множество (set) и проверить наличие значений во множестве.

lst = ['test', 'twest', 'tweast', 'treast']
slst = set(lst)
'test' in slst # Out: True

Как получить значение списка по индексу?

У каждого элемента списка есть свой уникальный номер. Этот номер называется индексом. Списки в Python имеют нулевую индексацию, как у массивов в других языках. Это означает, что первый элемент списка имеет индекс 0, второй элемент — индекс 1, третий — 2 и т. д.

lst = [1, 2, 3, 4]
lst[0] # 1
lst[1] # 2

Если запросить элемент по индексу за пределами списка, Python выкинет исключение IndexError.

lst = [1, 2, 3, 4]
lst[10] # IndexError: list index out of range

Отрицательные индексы интерпретируются как подсчёт с конца списка.

lst = [1, 2, 3, 4]
lst[-1]  # 4
lst[-2]  # 3
lst[-5]  # IndexError: list index out of range

То же действие можно воспроизвести следующим образом:

lst = [1, 2, 3, 4]
lst[len(lst)-1]  # 4

Списки в Python поддерживают слайсинг. Синтаксис слайса:  lst[начало:конец:шаг]. Результатом слайса будет новый список, содержащий элементы от начала до конца - 1.

lst = [1, 2, 3, 4]
lst[1:]      # [2, 3, 4]
lst[:3]      # [1, 2, 3]
lst[::2]     # [1, 3]
lst[::-1]    # [4, 3, 2, 1]
lst[-1:0:-1] # [4, 3, 2]
lst[5:8]     # [] since starting index is greater than length of lst, returns empty list
lst[1:10]    # [2, 3, 4] same as omitting ending index

Слайсингом можно развернуть список в обратную сторону:

lst = [1, 2, 3, 4]
lst[::-1]    # [4, 3, 2, 1]

Использование отрицательного шага эквивалентно следующему коду:

reversed(lst)[0:2] # 0 = 1 -1
# 2 = 3 -1

Как перебрать значения списка в Python?

Python позволяет использовать цикла for со списками:

my_list = ['foo', 'bar', 'baz']
for item in my_list:
    print(item)
# Вывод:
# foo
# bar
# baz

Индекс текущего элемента в цикле можно получить используя функцию enumerate:

for (index, item) in enumerate(my_list):
    print('The item in position {} is: {}'.format(index, item))
# Вывод:
# The item in position 0 is: foo
# The item in position 1 is: bar
# The item in position 2 is: baz

Так же, можно проходить по списку используя функцию range. Range генерирует ряд чисел в рамках заданного диапазона, соответственно началом диапазона является число 0 (индекс первого элемента), а концом индекс последнего элемента. Len возвращает длину списка, так как индекс первого элемента является нулем, вычитать из длины списка единицу не нужно, индекс последнего элемента будет соответствовать длине списка:

for i in range(0, len(my_list)):
    print(my_list[i])
# Вывод:
# foo
# bar
# baz

Ранее отмечалось, что списки являются изменяемой (или иммютабельной, от англ. immutable) структурой данных. Это означает, что если изменить список во время итерации, мы можем получить неожиданные результаты, например:

for item in my_list:
    if item == 'foo':
        del my_list[0]
    print(item)
# Вывод:
# foo
# baz

В примере мы удалили первый элемент на первой итерации изменив список, что привело к пропуску bar. На второй итерации, baz стал вторым элементом списка.

Какие есть методы списков в Python?

Метод списка append

append(value) — позволяет добавить новый элемент в конец списка.

a = [1, 2, 3, 4, 5]

# Добавим значения 6, 7, и 7 в список a
a.append(6)
a.append(7)
a.append(7)
# a: [1, 2, 3, 4, 5, 6, 7, 7]

# Добавим к значениям списка другой список
b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
# Если вы добавляете список к списку, добавляемый вами будет одним элементом в конце первого списка. Для расширения списка используйте метод extends

# Добавим к списку элемент другого типа
my_string = "hello world"
a.append(my_string)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]

Метод списка extends

extends (enumerable) — расширяет список, добавляя элементы переданного итерируемого объекта.

a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9, 10]
a.extend(b) # Добавляем в список a все элементы из списка b
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

a.extend(range(3)) # Добавляем в список a все элементы последовательности (0, 1, 2)
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]

Списки также можно объединять с помощью оператора +. При этом, оператор + не изменяет список, а создает новый.

a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

Метод списка index

index (value, [startIndex]) — возвращает индекс первого вхождения значения. Если вводного значения нет в списке, возникнет исключение ValueError. Если указан второй аргумент, поиск начнется с указанного индекса.

a = [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
a.index(7) # Вернется 6
a.index(49) # Возникнет исключение ValueError, т. к. значения 49 нет в списке a.
a.index(7, 7) # Вернется 7
a.index(7, 8) # Возникнет ValueError, т. к. в списке a нет значения 7, которое начиналось бы с индекса 8

Метод списка insert

insert (index, value) — добавляет значение value непосредственно перед указанным индексом index. После вставки новое значение занимает индекс index.

a = [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

a.insert(0, 0)  # вставляет 0 на позицию 0
a.insert(2, 5)  # вставляет 5 на позицию 2
# a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

Метод списка pop

pop ([index]) — удаляет и возвращает значение по индексу index. Без аргумента index удаляет и возвращает последний элемент списка.

a = [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

a.pop(2) # Возвращает 5
# a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
a.pop(8) # Возвращает 7
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Без аргумента:
a.pop() # Возвращает: 10
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Метод списка remove

remove(value) — удаляет первое вхождение указанного значения. Если указанного значения нет в списке, выдаётся исключение ValueError.

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a.remove(0)
a.remove(9)
# a: [1, 2, 3, 4, 5, 6, 7, 8]

a.remove(10) # исключение ValueError, значения 10 нет в списке

Метод списка reverse

reverse() — переворачивает список задом наперёд и возвращает None.

a = [1, 2, 3, 4, 5, 6, 7, 8]
a.reverse()
# a: [8, 7, 6, 5, 4, 3, 2, 1]

Метод списка count

count(value) — подсчитывает количество появлений значения в списке.

a = [1, 2, 3, 4, 5, 6, 7, 7]
a.count() # Возвращает 2

Метод списка sort

sort() — сортирует список в числовом и лексическом порядке и возвращает None

a = [1, 2, 3, 4, 5, 6, 7, 8]
a.sort() # Отсортирует список в числовом порядке
# a = [1, 2, 3, 4, 5, 6, 7, 8]

Списки также можно сортировать в обратном порядке используя флаг reverse=True в методе sort().

a = [1, 2, 3, 4, 5, 6, 7, 8]
a.sort(reverse=True)
# a = [8, 7, 6, 5, 4, 3, 2, 1]

Для сортировки списка по атрибутам элементов, можно использовать аргумент key:

class Person(object):
	def __init__(self, name, height):
		self.name = name
		self.height = height

	def __repr__(self):
		return self.name
        
lst = [Person("John Cena", 175),
     Person("Chuck Norris",  180),
     Person("Jon Skeet", 185)]
lst.sort(key=lambda item: item.name) # Отсортируется по аттрибуту name
# lst: [Chuck Norris, John Cena, Jon Skeet]
lst.sort(key=lambda item: item.height) # Отсортируется по аттрибуту height
# lst: [John Cena, Chuck Norris, Jon Skeet]

Метод списка clear

clear() — удаляет все элементы из списка

a = [1, 2, 3, 4, 5, 6, 7, 8]
a.clear()
# a = []


Метод списка copy

copy() — возвращает пустую копию списка.

aa = a.copy()
# aa = [1, 2, 3, 4, 5]

Как получить значение по индексу из многомерного списка в Python?

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

Доступ к значениям многомерного списка:

alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]
# Значение второго элемента в первом списке первого списка
print(alist[0][0][1]) # Выведет 2
# Значение третьего элемента во втором списке второго списка втором списк
print(alist[1][1][2]) # Выведет 10

Использование методов списков на примере добавления значения в мгогомерный список:

alist[0][0].append(11)
# Добавим значение 11 в конец первого списка в первом списке
print(alist[0][0][2]) # Выведет 11

Использование вложенных циклов for для обхода многомерного списка:

# Один из способов циклического обхода многомерных списков
for row in alist:
    for col in row:
        print(col)
# Вывод:
# [1, 2, 11]
# [3, 4]
# [5, 6, 7]
# [8, 9, 10]
# [12, 13, 14]

Использование слайсов в многомерном списке:

print(alist[1][1:])
#[[8, 9, 10], 15, [12, 13, 14]]

Как проверить, что список пустой?

Пустой список эквивалентен значению False, поэтому не нужно проверять len(lst) == 0, а достаточно вызвать lst или not lst:

alst = []
if not lst:
	print("list is empty")
# Вывод: List is empty

All и any в Python — как проверить, что каждое или любое значение списка соответствует критерию?

Функция all() помогает определить, все ли значения итерируемого объекта соответствуют значению True

nums = [1, 1, 0, 1]
all(nums)
# False

chars = ['a', 'b', 'c', 'd']
all(chars)
# True

Аналогично, any() определяет, соответствует ли одно или несколько значений в итерируемом объекте значению True

nums = [1, 1, 0, 1]
any(nums)
# True

vals = [None, None, None, False]
any(vals)
# False

All и any удобно использовать с генераторами:

vals = [1, 2, 3, 4]
any(val > 12 for val in vals) # False
any((val * 2) > 6 for val in vals) # True

Как сравнить списки в Python?

Python поддерживает лексическое сравнение списков с помощью операторов сравнения. Оба операнда должны быть одного типа.

[1, 10, 100] < [2, 10, 100]
# True, потому что 1 < 2
[1, 10, 100] < [1, 10, 100]
# False, потому что списки равны
[1, 10, 100] <= [1, 10, 100]
# True, потому что списки равны
[1, 10, 100] < [1, 10, 101]
# True, потому что 100 < 101
[1, 10, 100] < [0, 10, 100]
# False, потому что 0 < 1

Если один из списков содержится в начале другого, выигрывает самый короткий список.

[1, 10] < [1, 10, 100]
# True

Как удалить дубликаты в списке?

Удаление повторяющихся значений в списке можно сделать путём преобразования списка во множество (set). Множества представляют собой неупорядоченную коллекцию уникальных значений. Если требуется сохранить структуру данных в виде списка, то множество можно преобразовать обратно в список с помощью функции list():

names = ["aixk", "duke", "edik", "tofp", "duke"]
list(set(names))
# Вывод: ['duke', 'tofp', 'aixk', 'edik']

Обратите внимание, что при преобразовании списка во множество теряется исходный порядок. Для сохранения исходного порядка можно использовать OrderedDict.

import collections
>>> collections.OrderedDict.fromkeys(names).keys()
# Out: ['aixk', 'duke', 'edik', 'tofp']