Методы списков

list.append(a)
Добавляет элемент a в конец списка. Примеры.
>>> x = [1, 2, 3]
>>>
>>> x.append('A')
>>> x
[1, 2, 3, 'A']

Данный метод эквивалентен команде x[len(x):] = ['A'], но .append() "читабельнее".

Списки добавляются в конец не распаковываясь:

>>> x.append([3, 2, 1])
>>> x
[1, 2, 3, 'A', [3, 2, 1]]
list.extend(iterable)
Добавляет элементы из iterable в конец списка x. Примеры.
>>> x = [1, 2, 3]
>>>
>>> x.extend('ABC')
>>> x
[1, 2, 3, 'A', 'B', 'C']
>>>
>>> x.extend(range(5))
>>> x
[1, 2, 3, 'A', 'B', 'C', 0, 1, 2, 3, 4]

Данный метод эквивалентен команде x[len(x):] = iterable, но .extend() "читабельнее".

list.insert(i, a)
Добавляет элемент a перед элементом с индексом i, то есть x.insert(0, a) вставит элемент в начало списка, а команда x.insert(len(x), a) вставит элемент в конец списка. Примеры.
>>> x = [1, 2, 3]
>>>
>>> x.insert(1, 'A')    # элемент 'A' будет иметь индекс 1
>>> x
[1, 'A', 2, 3]
>>>
>>> x.insert(3, 'B')
>>> x
[1, 'A', 2, 'B', 3]
>>>
>>>
>>> x.insert(0, '!')     # вставка в начало списка
>>> x
['!', 1, 'A', 2, 'B', 3]
>>>
>>> x.insert(len(x), '@')     # вставка в конец списка
>>> x
['!', 1, 'A', 2, 'B', 3, '@']
list.remove(a)
Удаляет из списка элемент a. Если в списке несколько элементов a, то будет удален первый из них. Если указанного элемента нет в списке, то будет вызвано исключение. Примеры.
>>> x = [0, 'a', 1, 1, 2, 3]
>>>
>>> x.remove('a')
>>> x
[0, 1, 1, 2, 3]
>>>
>>> x.remove(1)
>>> x
[0, 1, 2, 3]
>>>
>>> x.remove(4)
ValueError: list.remove(x): x not in list
list.pop([i])
Удаляет из списка элемент с указанным индексом i и возвращает его. Квадратные скобки указывают на то, что данный параметр не является обязательным, так как по умолчанию равен \(-1\) и если не указывать i, то будет удален и возвращен последний элемент в списке. Примеры.
>>> x = [1, 2, 3]
>>>
>>> x.pop(0)
1
>>> x
[2, 3]

Возвращаемое значение может быть присвоено другим переменным и использоваться в дальнейшем:

>>> item = x.pop(1)
>>> x
[2]
>>> item
3

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

>>> x = [1, 2, 3]
>>>
>>> x.pop()
3
>>> x
[1, 2]
list.clear()
Удаляет все элементы из списка. Примеры.
>>> x = [1, 2, 3]
>>>
>>> x.clear()
>>> x
[]

Данный метод эквивалентен del x[:].

list.index(a[, start[, end]])
Находит указанный элемент a и возвращает его индекс, отсчитанный от \(0\). Если в списке находится несколько указанных элементов, то будет возвращен индекс первого из них. Если список не содержит указанный элемент a, то будет вызвано исключение. Необязательные параметры start и end позволяют задать срез в котором необходимо выполнить поиск, но индекс найденного элемента будет отсчитан от \(0\), а не от указанного начала среза в параметре start. Примеры.
>>> x = list('ABCCDEFCGHI')
>>> x
['A', 'B', 'C', 'C', 'D', 'E', 'F', 'C', 'G', 'H', 'I']
>>>
>>> x.index('C')
2
>>> x[2]
'C'

Параметры start и end позволяют задать область поиска:

>>> x.index('C', 5)     # равносильно поиску в срезе x[5:]
7
>>>
>>> x.index('C', 5, 9)  # равносильно поиску в срезе x[5:9]
7

Если указанного элемента нет в списке, то это вызовет ошибку:

>>> x.index('Z')
ValueError: 'Z' is not in list
list.count(a)
Возвращает количество вхождений в список указанного элемента a. Примеры.
>>> x = list('ABCCDEFCGHI')
>>> x
['A', 'B', 'C', 'C', 'D', 'E', 'F', 'C', 'G', 'H', 'I']
>>>
>>> x.count('C')
3
>>>
>>> x.count('Z')
0
list.sort(key=None, reverse=False)
Сортирует элементы списка. Данный метод не возвращает отсортированный список, а меняет исходный список. Примеры.

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

>>> x = ['bb', 'c', 'aaa']
>>>
>>> x.sort()
>>> x
['aaa', 'bb', 'c']
>>>
>>> x = [ 5, -0.5, 3, 0, 1, 0.5, 2]
>>>
>>> x.sort()
>>> x
[-0.5, 0, 0.5, 1, 2, 3, 5]

Стоит сразу отметить что списки с комплексными числами не сортируются:

>>> x = [5+1j, 5-1j, 5+0j, -5+1j, 2+2j]
>>> x.sort()
Traceback (most recent call last):
TypeError: '<' not supported between instances of 'complex' and 'complex'

Зато списки с обыкновенными и десятичными дробями могут быть отсортированы:

>>> from fractions import Fraction
>>>
>>> x = [Fraction(11, 13), Fraction(5, 6), Fraction(2, 5), Fraction(1, 3)]
>>>
>>> x.sort()
>>> x
[Fraction(1, 3), Fraction(2, 5), Fraction(5, 6), Fraction(11, 13)]
>>>
>>>
>>> from decimal import *
>>>
>>> x = [Decimal('1.123321'), Decimal('1.123322'), Decimal('1.123211')]
>>>
>>> x.sort()
>>> x
[Decimal('1.123211'), Decimal('1.123321'), Decimal('1.123322')]

Впрочем, отсортированы могут быть любые объекты, поддерживающие оператор <:

>>> x = [(0,1,0), (1,1,0), (0,1,1), (0,0,0)]
>>>
>>> x.sort()
>>> x
[(0, 0, 0), (0, 1, 0), (0, 1, 1), (1, 1, 0)]

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

>>> x = ['ccc', 'd', 'bb', 'a']
>>>
>>> x.sort()
>>> x
['a', 'bb', 'ccc', 'd']

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

>>> def len_str(s):
...     return len(s)

После, имя данной функции нужно присвоить параметру key:

>>> x.sort(key=len_str)
>>> x
['a', 'd', 'bb', 'ccc']

Параметр reverse установленный в значение True сортирует элементы в обратном порядке:

>>> x.sort(key=len_str, reverse=True)
>>> x
['ccc', 'bb', 'a', 'd']

Параметр key позволяет выполнять очень гибкую сортировку. Давайте приведем еще один пример, в котором строки сортируются по второму символу:

>>> x = ['ubuu', 'waww', 'sdss','ecee']
>>>
>>> def sym2(s):
...     return s[1]
...
>>> x.sort(key=sym2)
>>> x
['waww', 'ubuu', 'ecee', 'sdss']

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

>>> x = [-3, -10, -1, 10, 2, 0, 5]
>>>
>>> x.sort()
>>> x
[-10, -3, -1, 0, 2, 5, 10]
>>>
>>>
>>> def abs_num(n):
...     return abs(n)
...
>>> x.sort(key=abs_num)
>>> x
[0, -1, 2, -3, 5, -10, 10]
list.reverse()
Расставляет элементы списка в обратном порядке. Данный метод не возвращает список с переставленными элементами, а меняет исходный список. Примеры.
>>> x = list('ABCDEFG')
>>> x
['A', 'B', 'C', 'D', 'E', 'F', 'G']
>>>
>>> x.reverse()
>>> x
['G', 'F', 'E', 'D', 'C', 'B', 'A']
list.copy()
Возвращает поверхностную копию списка. Примеры.
>>> A = [1, 2, 3]
>>>
>>> B = a
>>>
>>> C = a.copy()
>>>
>>> A[0] = 'AAA'    # изменения в списке A повлияют на B
>>>
>>> B
['AAA', 2, 3]
>>>
>>> C     # но изменения в A не влияют на C
[1, 2, 3]