Списки в Python
В этой статье вы узнаете всё о списках в Python: как их создавать, как удалять и добавлять элементы, как списки работают со срезами и т. д.
В Python есть множество комплексных типов данных, называемых последовательностями. Список — один из часто используемых и универсальных типов данных. Это аналог массивов в других языках программирования.
Как создать список
Список можно создать, записав его будущие элементы в квадратные скобки []
через запятую.
В списке допускается любое количество элементов разных типов (целые числа, числа с плавающей точкой, строки и т. д.).
# пустой список
my_list = []
# список целых чисел
my_list = [1, 2, 3]
# список с элементами разных типов
my_list = [1, "Привет", 3.4]
Элементом списка может быть и другой список. Такие списки называются вложенными.
# внутри основного списка — вложенный список
my_list = ["мышь", [8, 4, 6], ['a']]
Как получить доступ к элементам списка
1. По индексу
Чтобы получить доступ к элементу списка, можно воспользоваться оператором индекса []
.
Примечание. Обратите внимание, что индексирование кортежа начинается с 0. Поэтому у списка из 5 элементов будут индексы с 0 по 4.
Попытка взять элемент по индексу, не входящему в диапазон, приведет к IndexError. Индекс — обязательно целое число. Нельзя использовать числа с плавающей точкой и другие типы, это приведет к TypeError.
Вложенные списки можно получить с помощью вложенной индексации.
# Индексация списков
my_list = ['п', 'р', 'о', 'б', 'а']
# Вывод: п
print(my_list[0])
# Вывод: о
print(my_list[2])
# Вывод: а
print(my_list[4])
# Вложенный список — [2, 0, 1, 5]
n_list = ["Счастье", [2, 0, 1, 5]]
# Вложенная индексация
print(n_list[0][1])
print(n_list[1][3])
# Ошибка! Для индексации используются только целочисленные значения
print(my_list[4.0])
Вывод:
п
o
а
ч
5
Traceback (most recent call last):
File "<string>", line 21, in <module>
TypeError: list indices must be integers or slices, not float
2. По отрицательному индексу
Python поддерживает отрицательные индексы в последовательностях. Индекс -1 указывает на последний элемент, -2 — на предпоследний и т. д.
# Отрицательные индексы в списках
my_list = ['п', 'р', 'о', 'б', 'а']
print(my_list[-1])
print(my_list[-5])
Вывод:
а
п
Срезы списков
С помощью оператора среза :
можно получить диапазон элементов в списке.
my_list = ['c', 'o' , 'd', 'e', 'c', 'h', 'i', 'c', 'k']
# элементы с 3 по 5
print(my_list[2:5])
# элементы с 1 по 4
print(my_list[:-5])
# элементы с 6 по последний
print(my_list[5:])
# элементы с первого по последний
print(my_list[:])
Вывод:
['d', 'e', 'c']
['c','o,'d','e']
['h','i','c','k']
['c','o,'d','e','c','h','i','c','k']
Как изменять элементы в списке
Список — изменяемый тип данных, его элементы можно изменять в отличие от строки или кортежа.
Чтобы изменить один или несколько элементов, можно воспользоваться оператором присваивания =
.
Допустим, у нас есть список, который называется odd
(нечётные числа). Но в нём почему-то хранятся четные числа. Давайте это исправим.
odd = [2, 4, 6, 8]
# изменяем 1-й элемент
odd[0] = 1
print(odd)
# изменяем элементы со второго по 4
odd[1:4] = [3, 5, 7]
print(odd)
Вывод:
[1, 4, 6, 8]
[1, 3, 5, 7]
Как добавлять элементы в список
Один элемент в список добавляется с помощью метода append()
, а несколько — с помощью метода extend()
.
odd = [1, 3, 5]
odd.append(7)
print(odd)
odd.extend([9, 11, 13])
print(odd)
Вывод:
[1, 3, 5, 7]
[1, 3, 5, 7, 9, 11, 13]
Для объединения двух списков используется оператор +
. Это называется конкатенацией списков.
Оператор *
повторяет список заданное количество раз.
odd = [1, 3, 5]
print(odd + [9, 7, 5])
print(["re"] * 3)
Вывод:
[1, 3, 5, 9, 7, 5]
['re', 're', 're']
С помощью метода insert()
можно вставить один элемент по данному индексу, а присвоив их пустому срезу — несколько.
odd = [1, 9]
odd.insert(1,3)
print(odd)
odd[2:2] = [5, 7]
print(odd)
Вывод:
[1, 3, 9]
[1, 3, 5, 7, 9]
Как удалять элементы из списка
Один или несколько элементов списка можно удалить с помощью ключевого слова del
. С помощью него можно удалить и весь список.
my_list = ['п', 'р', 'o', 'б', 'л', 'е', 'м', 'а']
# удаление одного элемента
del my_list[2]
print(my_list)
# удаление среза элементов
del my_list[1:5]
print(my_list)
# удаление всего списка
del my_list
# этот вызов приведет к ошибке
# список не определен, т. к. мы удалили его
print(my_list)
Вывод:
['п', 'р', 'б', 'л', 'е', 'м', 'а']
['п', 'м', 'а']
Traceback (most recent call last):
File "<string>", line 18, in <module>
NameError: name 'my_list' is not defined
Чтобы удалить элемент по значению, можно использовать метод remove()
, а для удаления по индексу — метод pop()
.
Метод pop()
удаляет и возвращает последний элемент из списка, если не указан индекс. Это помогает применять списки как стек (структура данных, которая подчиняется принципу LIFO: «последним пришел — первым вышел»).
Для очистки списка используется метод clear()
.
my_list = ['п', 'р', 'o', 'б', 'л', 'е', 'м', 'а']
my_list.remove('п')
# Вывод: ['р', 'o', 'б', 'л', 'е', 'м', 'а']
print(my_list)
# Вывод: 'o'
print(my_list.pop(1))
# Вывод: ['р', 'б', 'л', 'е', 'м', 'а']
print(my_list)
# Вывод: 'м'
print(my_list.pop())
# Вывод: ['р', 'б', 'л', 'е', 'а']
print(my_list)
my_list.clear()
# Вывод: []
print(my_list)
Вывод:
['р', 'o', 'б', 'л', 'е', 'м', 'а']
o
['р', 'б', 'л', 'е', 'м', 'а']
м
['р', 'б', 'л', 'е', 'а']
[]
Наконец, мы можем удалять элементы из списка, присвоив пустой список срезу элементов.
>>> my_list = ['п', 'р', 'o', 'б', 'л', 'е', 'м', 'а']
>>> my_list[2:3] = []
>>> my_list
['п', 'р', 'б', 'л', 'е', 'м', 'а']
>>> my_list[2:5] = []
>>> my_list
['п', 'р', 'м', 'а']
Методы списков
Методы списков перечислены в таблице ниже. Их нужно использовать с помощью конструкции список.метод()
. Некоторые из них мы уже использовали.
Название метода |
Что делает |
|
Добавляет элемент в конец списка |
|
Добавляет все элементы списка в другой список |
|
Вставляет элемент по данному в качестве аргумента индексу |
|
Удаляет элемент из списка |
|
Удаляет элемент из списка и возвращает его |
|
Удаляет все элементы из списка |
|
Возвращает индекс первого совпавшего элемента |
|
Считает количество элементов в списке, совпадающих с переданным аргументом |
|
Сортирует элементы в списке в порядке возрастания |
|
Переворачивает список |
|
Возвращает неглубокую копию списка |
# Методы списков
my_list = [3, 8, 1, 6, 0, 8, 4]
# Вывод: 1
print(my_list.index(8))
# Вывод: 2
print(my_list.count(8))
my_list.sort()
# Вывод: [0, 1, 3, 4, 6, 8, 8]
print(my_list)
my_list.reverse()
# Вывод: [8, 8, 6, 4, 3, 1, 0]
print(my_list)
Вывод:
1
2
[0, 1, 3, 4, 6, 8, 8]
[8, 8, 6, 4, 3, 1, 0]
Представления списков
Представление списков — элегантный и лаконичный способ создать новый список из существующего.
Представление списков состоит из выражения, за которым следует оператор for
, и эта конструкция заключается в квадратные скобки []
.
Давайте создадим список степеней двойки от 1 до 9. Используем для это представление списка.
pow2 = [2 ** x for x in range(10)]
print(pow2)
Вывод:
[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
То же самое можно сделать и так:
pow2 = []
for x in range(10):
pow2.append(2 ** x)
Но так — длинее. Представление списков более элегантный способ.
В представлениях списков может быть больше операторов for
и if
. Оператор if
он позволяет отфильтровать элементы для нового списка. Он необязателен.
>>> pow2 = [2 ** x for x in range(10) if x > 5]
>>> pow2
[64, 128, 256, 512]
>>> odd = [x for x in range(20) if x % 2 == 1]
>>> odd
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> [y+x for x in ['Python ','C '] for y in ['Язык','Программирование на']]
['Язык Python', 'Программирование на Python', 'Язык C', 'Программирование на C']
Другие операции со списками
Проверка на вхождение элемента в список
С помощью ключевого слова in
можно узнать, есть элемент в списке или нет.
my_list = ['п', 'р', 'o', 'б', 'л', 'е', 'м', 'а']
# Вывод: True
print('п' in my_list)
# Вывод: False
print('у' in my_list)
# Вывод: True
print('с' not in my_list)
Вывод:
True
False
True
Итерирование по списку
С помощью цикла for
можно пройтись по каждому элементу в списке.
for fruit in ['яблоки','бананы','манго']:
print("Я люблю",fruit)
Вывод:
Я люблю яблоки
Я люблю бананы
Я люблю манго