Списки Python

Введение

Из официальной документации

list A built-in Python sequence. Despite its name it is more akin to an array in other languages than to a linked list since access to elements is O(1).

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

Доступ к элементам O(1) означает что скорость, с которой вы запросив элемент по его индексу получите результат, равна одной операции.

Под каждый элемент списка выделен одинаковый размер памяти, например у меня это 8 байт. Когда вы вызываете элемент с индексом i Python знает адрес памяти нулевого элемента списка и просто прибавляет к нему 8 умноженное на i

Список - это изменяемый объект.

Различные способы создания списков в Python описаны в этой статье

Воспользуемся стандартным способом создать список - с помощью квадратных скобок []

lst = ['a', 'b', 'c']
print(lst)

['a','b','c']

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

У каждого элемента есть минимум два уникальных индекса. Один индекс соответсвует обходу списка слева направо 0, 1, 2. Второй соответствует обходу в обратную сторону -0, -1, -2

Индекс 'a' = 0 либо -0, индекс 'b' = 1 либо -2, индекс 'c' = 2 либо -1.

Можно пользоваться индексом и в обратную сторону. Тогда индекс c = -1, индекс b = -2, индекс a = -3

Обратиться к элементу списка

Пример обращения к элементам списка.

lst = ['a', 'b', 'c'] print(lst[0]) print(lst[1]) print(lst[2]) print(lst[-1]) print(lst[-2]) print(lst[-3]) print(lst[-0])

a b c c b a a

Обрезать список

При использовании слайсов вида

[x:y]

Элементом с индексом x включается а y нет.

Рассмотрим список

lst = [100, 200, 300, 400, 500]

print(lst[1:3])

[200, 300]

Элемент с индексом 3 это 400 и он не попал в результат.

Можно использовать заведомо несуществующий индекс. Если он справа слайс будет продолжен до последнего элемента. Если он слева то вернётся пустой список. Exception не появится.

print("lst[:10]:\n", l[:10]) print("lst[10:]:\n", l[10:]) print("lst[10:2]:\n", l[10:2])

lst[:10]: [100, 200, 300, 400, 500] lst[10:] [] lst[10:2] []

Рассмотрим ещё несколько примеров вырезания из списка его части

lst = [100, 200, 300, 400, 500] print("lst: ", lst)

lst: [100, 200, 300, 400, 500]

lst = [100, 200, 300, 400, 500] print("lst[0]: ", lst[0]) print("lst[1]: ", lst[1]) print("lst[-0]: ", lst[-0]) print("lst[-1]: ", lst[-1])

lst[0]: 100 lst[1]: 200 lst[-0]: 100 lst[-1]: 500

lst = [100, 200, 300, 400, 500] print("lst[1:3]:\n", lst[1:3]) print("lst[1:-1]:\n", lst[1:-1]) print("lst[2:]:\n", lst[2:]) print("lst[:2]:\n", lst[:2]) print("lst[:10]:\n", lst[:10]) print("lst[10:]:\n", lst[10:])

lst[1:3]: [200, 300] lst[1:-1]: [200, 300, 400] lst[2:]: [300, 400, 500] lst[:2]: [100, 200] lst[:10]: [100, 200, 300, 400, 500] lst[10:] []

# All list elements lst = [100, 200, 300, 400, 500] print("lst[:]:\n", lst[:])

lst[:]: [100, 200, 300, 400, 500]

При вырезании из списка его части создаётся новый объект.

lst = [0, 1, 2] x = lst y = lst[0:] print(lst, x, y) print(id(lst) == id(x)) print(id(lst) == id(y))

[0, 1, 2] [0, 1, 2] [0, 1, 2] True False

append()

Чтобы добавить в конец списка новый элемент применяется метод append()

Операция

x.append("z")

эвивалентна

x[len(x):] = "z"

x.append("z") и x[len(x):] = "z" дадут одинаковый результат но в целом x.append(что-то) и x[len(x):] = что-то - не являются полными аналогами так как если что-то - это итерируемый объект с длиной большей единицы поведение будет не как у append а как у extend

Пример с одинаковым результатом:

x = ['a','b','c'] x.append('d') print(x) print(len(x)) x[len(x):] = 'e' print(x) print(len(x))

['a','b','c','d'] 4 ['a','b','c','d','e'] 5

Пример с разным результатом:

x = ['a','b','c'] x.append('xyz') print(x) print(len(x)) x[len(x):] = 'xyz' print(x) print(len(x))

['a','b','c','xyz'] 4 ['a','b','c','d','x','y','z'] 7

append() добавил строку из трёх символов как один элемент, x[len(x):] распаковал строку и добавил каждый символ отдельно.

Нужно понимать, что append() всегда добавляет что-то как один последний элемент списка.

То есть, если вы хотите совместить два списка .append() вместо этого запишет второй список как последний элемент первого.

first = ['a', 'b'] second = ['c', 'd'] first.append(second) print(first)

['a', 'b', ['c', 'd']]

Для соединения списков в один используется .extend()

Другие способы добавлять в список

>>> a = [0, 1, 2] >>> b = [3, 4, 5] >>> c = a + b >>> c [0, 1, 2, 3, 4, 5] >>> c += [6, 7, 8] >>> c [0, 1, 2, 3, 4, 5, 6, 7, 8] >>> c.extend([9, 10, 11]) >>> c [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

.extend()

list.extend(iterable) Extend the list by appending all the items from the iterable. Equivalent to a[len(a):] = iterable.

first = ['a', 'b'] second = ['c', 'd'] first.extend(second) print(first)

['a', 'b', 'c', 'd']

Ещё раз хочу обратить внимание на то, что .extend() изменяет существующий список.

Чтобы создать новый список равный сумме двух существующих достаточно использовать +

lst1 = ["A", "A"] lst2 = ["b", "b"] y = lst1 + lst2 lst1.extend(lst2) print(lst1, y) print(lst1 == y) print(lst1 is y)

['A', 'A', 'b', 'b'] ['A', 'A', 'b', 'b'] True False

Копировать список

# Copy l = [100, 200, 300, 400, 500] t = l print("\n# t = l") print("t is l =", t is l) # True r = l[:] print("\n# r = l[:]") print("r is l = ", r is l) # False print("r == l = ", r == l) # True u = l.copy() print("\n# u = l.copy()") print("u is l = ", u is l) # False v = list(l) print("\n# v = list(l)") print("v is l = ", v is l) # False

# t = l t is l = True # r = l[:] r is l = False r == l = True # u = l.copy() u is l = False # v = list(l) v is l = False

a = [ [1, 2], [3, 4] ] b = a[:] print(a is b) # False print(a == b) # True print(a[0]) # [1, 2] print(b[0]) # [1, 2] print(a[0] is b[0]) # True a[0] = [8, 9] print(a[0]) # [8, 9] print(b[0]) # [1, 2] a[1].append(5) print(a[1]) # [3, 4, 5] print(b[1]) # [3, 4, 5] print(a) # [[8, 9], [3, 4, 5]] print(b) # [[1, 2], [3, 4, 5]]

False True [1, 2] [1, 2] True [8, 9] [1, 2] [3, 4, 5] [3, 4, 5] [[8, 9], [3, 4, 5]] [[1, 2], [3, 4, 5]]

К спискам можно применять умножение

s = [ [-1, +1] ] * 5 print(s) s[2].append(7) print(s)

[21, 37, 21, 37, 21, 37, 21, 37] [0, 0, 0, 0, 0, 0, 0, 0, 0]

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

s = [ [-1, +1] ] * 5 print(s) s[2].append(7) print(s)

[[-1, 1], [-1, 1], [-1, 1], [-1, 1], [-1, 1]] [[-1, 1, 7], [-1, 1, 7], [-1, 1, 7], [-1, 1, 7], [-1, 1, 7]]

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

w = "the heihei.ru website was forked from andreyolegovich.ru in 2018 simultaneously with the topbicyle.ru website".split() print(w) i = w.index('was') print(i) # 3 print(w[i]) # was print(w.count("the")) # 2 print("heihei.ru" in w) # True print("andreyolegovich.ru" not in w) # True

['the', 'heihei.ru', 'website', 'was', 'forked', 'from', 'andreyolegovich.ru', 'in', '2018', 'simultaneously', 'with', 'the', 'topbicyle.ru', 'website'] 3 was 2 True True

len()

Длину списка можно узнать с помощью функции len()

>>> l = ["Pluralsight", "OTUS", "GeekBrains"]
>>> print(len(l))

3

insert()

Чтобы добавить новый элемент в начало списка применяется метод insert()

lst.insert(0, 'z')
print(l)

['z','a','b','c','d']

print(len(lst))

5

С помощью insert() можно вставить элемент в любое место в списке

Нужно передать в insert() индекс того места в которое вы хотите поместить элемент

lst.insert(3, 'j')
print(lst)

['z','a','b','j','c','d']

print(len(lst))

6

split() и join()

Превратить строку в список можно с помощью split()

s = 'Please visit website' print(s) lst = s.split() print(lst)

Please visit website ['Please', 'visit', 'website']

Изменим список с помощою insert

lst.insert(2, "topbicycle.ru") print(lst)

['Please', 'visit', 'topbicycle.ru', 'website']

Собрать список в строку - с помощью join()

s = ' '.join(lst) print(s)

Please visit topbicycle.ru website

С помощью этих манипуляций мы вставили в строку новое слово. Напрямую вставить символ в строку нельзя.

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

Чтобы удалить последний элемент списка применяется метод pop()

lst = ['a', 'b', 'c']
lst.pop()
print(lst)

['a', 'b']

print(len(lst))

2

pop(0)

Чтобы удалить первый элемент списка

lst = ['a', 'b', 'c']
lst.pop(0)
print(lst)

['b', 'c']

print(len(lst))

2

Чтобы удалить произвольный элемент списка передайте в pop() его индекс

lst = ['a', 'b', 'c']
lst.pop(1)
print(lst)

['a', 'c']

print(len(lst))

2

Чтобы удалить все элементы списка используется метод .clear()

lst = ['a', 'b', 'c'] lst.clear() print(lst)

[]

remove

Удалять элементы из списка не по индексу а по значению можно с помощью remove()

c = "Armenia Finland Georgia Germany Italy Norway Russia Spain Sweden".split() print(c) c.remove('Norway') print(c)

['Armenia', 'Finland', 'Georgia', 'Germany', 'Italy', 'Norway', 'Russia', 'Spain', 'Sweden'] ['Armenia', 'Finland', 'Georgia', 'Germany', 'Italy', 'Russia', 'Spain', 'Sweden']

del

Удалять элементы из списка можно с помощью del

c = ['Armenia', 'Finland', 'Georgia', 'Germany', 'Italy', 'Russia', 'Spain', 'Sweden'] del c[3] print(c)

['Armenia', 'Finland', 'Georgia', 'Italy', 'Russia', 'Spain', 'Sweden']

Чтобы удалять по содержимому а не индексу - можно применить index()

c = ['Armenia', 'Finland', 'Georgia', 'Italy', 'Russia', 'Spain', 'Sweden'] del c[c.index('Sweden')] print(c)

['Armenia', 'Finland', 'Georgia', 'Italy', 'Russia', 'Spain']

Сортировка списка

Сортировать и разворачивать списки можно методами .reverse() и .sort() - тогда будет изменён исходный список.

Если менять исходный список нежелательно - тогда нужно использовать функции reversed() и sorted(). Они создают новый списки и не изменяют исходные.

Начнём с методов.

.reverse()

Метод .reverse() разворачивает список таким образом, что последний элемент становится первым, предпоследний - вторым и так далее.

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

Новый список не создаётся. Изменяется исходный.

lst = [1, 3, 2] lst.reverse() print(lst)

[2, 3, 1]

.sort()

.sort() сортирует список таким образом, что элемент с наименьшим значением становится первым, с наибольшим - последним.

lst = [8, 3, 14] lst.sort() print(lst)

[3, 8, 14]

.sort(reverse=True) сортирует список противоложным образом: элемент с наименьшим значением становится последним, с наибольшим - первым.

lst = [1, 3, 2] lst.sort(reverse=True) print(lst)

[3, 2, 1]

Сортировка строк по умолчанию происходит по первому символу

lst = 'aa AA B ## 123 45678 CCCC'.split() lst.sort() print(lst)

['##', '123', '45678', 'AA', 'B', 'CCCC', 'aa']

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

С помощью key=len можно сделать сортировку по длине элемента.

lst = 'aa AA B ## 123 45678 CCCC'.split() lst.sort(key=len) print(lst)

['B', 'aa', 'AA', '##', '123', 'CCCC', '45678']

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

aa идёт в ориганальном списке первым, поэтому он и получает индекс меньший чем AA и ##.

reversed()

С помощью функции reversed() из исходного списка можно создать итератор , который начинается с конца списка.

Исходный список не будет изменён. Превратить полученный итератор в список можно функцией list()

p = [9, 3, 1, 0] q = reversed(p) print(q) print(list(q))

<list_reverseiterator object at 0x7f93ddd42280> [0, 1, 3, 9]

sorted()

С помощью функции sorted() из исходного списка можно создать новый отсортированный список.

Исходный список не будет изменён.

x = [4, 9, 2, 1] y = sorted(x) print(y) print(x)

[1, 2, 4, 9] [4, 9, 2, 1]

Итерация по списку

cities = ["Bamberg", "Dusseldorf", "Regensburg"] for city in cities: print("I have visited", city)

I have visited Bamberg I have visited Dusseldorf I have visited Regensburg

Распаковка списка

cities = ["Bamberg", "Dusseldorf", "Regensburg"] print(cities) print(*cities)

['Bamberg', 'Dusseldorf', 'Regensburg'] Bamberg Dusseldorf Regensburg

zip

С помощью функции zip() можно из двух списков создать список кортежей.

>>> languages = ['Java', 'Python', 'JavaScript'] >>> versions = [18, 3, 2015] >>> result = zip(languages, versions) >>> print(list(result))

[('Java', 18), ('Python', 3), ('JavaScript', 2015)]

Автор статьи: Андрей Олегович