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

Списки могут выглядеть следующим образом:

my_list = [1, 2, 3, 4, 5]
my_list2 = ['один', 'два', 'три', 'четыре', 'пять!']
my_list3 = [1, 'два', 3.5, [4, 'четыре'], 'пять!'] #Вложенные списки
print(my_list)
print(my_list2)
print(my_list3)
#[1, 2, 3, 4, 5]
#['один', 'два', 'три', 'четыре', 'пять!']
#[1, 'два', 3.5, [4, 'четыре'], 'пять!']

Способы создания списков

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

s = 'строка'
s = list(s)
print(s)
#['с', 'т', 'р', 'о', 'к', 'а']

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

nums = [i for i in range(1, 10)]
print(nums)
#[1, 2, 3, 4, 5, 6, 7, 8, 9]

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

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

+---+---+---+---+---+---+
| p | y | t | h | o | n |
+---+---+---+---+---+---+
  0   1   2   3   4   5
 -6  -5  -4  -3  -2  -1
my_list = ['один', 'два', 'три', 'четыре', 'пять!']
print(my_list[0])
print(my_list[2])
print(my_list[-1])
#один
#три
#пять!

Выведем вложенный список и элемент вложенного списка:

my_list3 = [1, 'два', 3.5, [4, 'четыре'], 'пять!']
print(my_list3[3])
print(my_list3[3][1])
#[4, 'четыре']
#четыре

Срезы в списках

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

Формула среза в списках, такая же, как и в строках X[I:J:Step]
Извлечь все содержимое строки Х, начиная со смещения I до смещения J, не включая его, с шагом Step.

my_list = ['один', 'два', 'три', 'четыре', 'пять!']
print(my_list[1:4])
print(my_list[1:])
print(my_list[:3])
print(my_list[::2])
#['два', 'три', 'четыре']
#['два', 'три', 'четыре', 'пять!']
#['один', 'два', 'три']
#['один', 'три', 'пять!']

Если использовать -1 в качестве шага, то можно получить список в обратном порядке:

my_list = ['один', 'два', 'три', 'четыре', 'пять!']
print(my_list[::-1])
#['пять!', 'четыре', 'три', 'два', 'один']

Изменение значений в списке

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

my_list = ['один', 'два', 'три', 'четыре', 'пять!']
my_list[0] = 1
my_list[2] = 3
my_list[-1] = 5
print(my_list)
#[1, 'два', 3, 'четыре', 5]

Проверка наличия элемента в списке

Если нужно проверить, имеется ли в списке нужное значение, используется операция in:

my_list = ['один', 'два', 'три', 'четыре', 'пять!']
item = 'два'
if item in my_list:
print(f'В списке есть элемент "{item}"')
#В списке есть элемент "два"

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

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

my_list_1 = [1, 2, 3]
my_list_2 = [4, 5, 6]
my_list_3 = my_list_1 + my_list_2
print(my_list_3)
#[1, 2, 3, 4, 5, 6]
my_list_1 = ['один', 'два', 'три']
my_list_2 = ['четыре', 'пять', 'шесть']
my_list_3 = my_list_1 + my_list_2
print(my_list_3)
#['один', 'два', 'три', 'четыре', 'пять', 'шесть']

Повторение списка:

my_list_1 = ['один', 'два', 'три']
my_list_1 = my_list_1 * 3
my_list_2 = [1, 2, 3]
my_list_2 *= 3 #Короткая запись
print(my_list_1)
print(my_list_2)
#['один', 'два', 'три', 'один', 'два', 'три', 'один', 'два', 'три']
#[1, 2, 3, 1, 2, 3, 1, 2, 3]

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

my_list_1 = ['один', 'два', 'три']
my_list_2 = ['четыре', 'пять', 'шесть']
if my_list_1 == my_list_2:
print('Совпдают')
else:
print('Не совпадают')
#Не совпадают

Узнать длину списка:

my_list = ['один', 'два', 'три']
print(len(my_list))
#3

Сумма элементов списка (только числовые значения):

my_list = [1, 2, 3]
print(sum(my_list))

Максимальное и минимальное значение элементов в списке:

my_list = [1, 2, 3]
print(min(my_list))
print(max(my_list))
#1
#3

Строковые значения сравниваются в алфавитном порядке:

my_list = ['один', 'два', 'три', 'ааааа']
print(min(my_list))
print(max(my_list))
#ааааа
#три

Перебор списков с помощью циклов

Циклом for:

my_list = ['один', 'два', 'три', 'четыре', 'пять!']
for i in range(len(my_list)):
print(my_list[i])
#один
#два
#три
#четыре
#пять!
my_list = ['один', 'два', 'три', 'четыре', 'пять!']
for item in my_list:
print(item)
#один
#два
#три
#четыре
#пять!

Циклом while:

my_list = ['один', 'два', 'три', 'четыре', 'пять!']
i = 0
while i < len(my_list):
print(my_list[i])
i += 1
#один
#два
#три
#четыре
#пять!

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

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

Конструкция выглядит так:
del list[i], где list — список, i — индекс (позиция) элемента в списке:

my_list = ['один', 'два', 'три', 'четыре', 'пять!']
del my_list[0]
del my_list[-1]
print(my_list)
#['два', 'три', 'четыре']

Если нужно удалить более 1 элемента, можно использовать срезы:

my_list = ['один', 'два', 'три', 'четыре', 'пять!']
del my_list[1:3]
print(my_list)
#['один', 'четыре', 'пять!']

Основные методы списков

Найти индекс элемента: list.index(x[, start[, end]])
Необязательные аргументы start и end, указывают на промежуток поиска:

my_list = [1, 2, 3, 4, 5]
print(my_list.index(4))
#3
my_list = ['один', 'два', 'три', 'четыре', 'пять']
print(my_list.index('три', 1, 3))
#2

Если элемента нет в списке:

my_list = ['один', 'два', 'три', 'четыре', 'пять']
print(my_list.index('шесть'))
#builtins.ValueError: 'шесть' is not in list

Вставить элемент в список: list.insert(i, x)
Добавит элемент x в позицию i списка:

my_list = [1, 2, 3, 4, 4]
my_list.insert(1, 'new')
print(my_list)
#[1, 'new', 2, 3, 4, 4]

Добавить элемент в конец списка: list.append(x)

my_list = [1, 2, 3, 4, 4]
my_list.append('new')
print(my_list)
#[1, 2, 3, 4, 4, 'new']

Работа этого метода эквивалентна такому срезу с добавлением:

my_list = [1, 2, 3, 4, 4]
my_list[len(my_list):] = ['new']
print(my_list)
#[1, 2, 3, 4, 4, 'new']

Удалить элемент из списка (только первое вхождение): list.remove(x)

my_list = [1, 2, 3, 'четыре', 'четрые']
my_list.remove('четыре')
print(my_list)
#[1, 2, 3, 'четрые']

Удалить элемент из списка по индексу: list.pop([i])

my_list = [1, 2, 3, 4, 5]
my_list.pop(0)
print(my_list)
#[2, 3, 4, 5]

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

my_list = [1, 2, 3, 4, 5]
my_list.pop()
print(my_list)
#[1, 2, 3, 4]

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

my_list = [1, 2, 3, 4, 5]
del_item = my_list.pop(1)
print(my_list)
print(del_item)
#[1, 3, 4, 5]
#2

Удалить все элементы из списка: list.clear()

my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)
#[]

Работа этого метода идентична конструкции: del a[:]:

my_list = [1, 2, 3, 4, 5]
del my_list[:]
print(my_list)
#[]

Копирование списка: list.copy()

my_list = [1, 2, 3, 4, 5]
my_list_2 = my_list.copy()
print(my_list_2)
#[1, 2, 3, 4, 5]

Объединение элементов списка в строку: str.join(list)

my_list = ['один', 'два', 'три', 'четыре', 'пять']
delimiter = ' '
s = delimiter.join(my_list)
print(s)
#один два три четыре пять
my_list = ['один', 'два', 'три', 'четыре', 'пять']
delimiter = '-'
s = delimiter.join(my_list)
print(s)
#один-два-три-четыре-пять

Количество элементов х в строке: list.count(x)

my_list = ['один', 'два', 'три', 'четыре', 'пять', 'три']
print(my_list.count('три'))
#2
my_list = [1, 2, 3, 4, 5, 4]
print(my_list.count(4))
#2

Сложение списков: list1.extend(list2)

my_list_1 = ['один', 'два', 'три', 'четыре', 'пять']
my_list_2 = [1, 2, 3, 4, 5]
my_list_1.extend(my_list_2)
print(my_list_1)
#['один', 'два', 'три', 'четыре', 'пять', 1, 2, 3, 4, 5]

Сортировка списка: list.sort(*, key=None, reverse=False)

my_list_1 = [4, 5, 3, 1, 2]
my_list_1.sort()
print(my_list_1)
#[1, 2, 3, 4, 5]
my_list_1 = [4, 5, 3, 1, 2]
my_list_1.sort(reverse=True)
print(my_list_1)
#[5, 4, 3, 2, 1]

Список в обратном порядке: list.reverse()

my_list_1 = [4, 5, 3, 1, 2]
my_list_1.reverse()
print(my_list_1)
#[2, 1, 3, 5, 4]