Функции и методы списков

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

Таблица "методы списков"

Метод	Что делает
list.append(x)	Добавляет элемент в конец списка
list.extend(L)	Расширяет список list, добавляя в конец все элементы списка L
list.insert(i, x)	Вставляет на i-ый элемент значение x
list.remove(x)	Удаляет первый элемент в списке, имеющий значение x
list.pop([i])	Удаляет i-ый элемент и возвращает его. Если индекс не указан, удаляется последний элемент
list.index(x, [start [, end]])	Возвращает положение первого элемента от start до end со значением x
list.count(x)	Возвращает количество элементов со значением x
list.sort([key = функция])	Сортирует список на основе функции
list.reverse()	Разворачивает список
list.copy()	Поверхностная копия списка (новое в python 3.3)
list.clear()	Очищает список (новое в python 3.3)

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

>>> l = [1, 2, 3, 5, 7]>>> l.sort()>>> l[1, 2, 3, 5, 7]>>> l = l.sort()>>> print(l)None

И, напоследок, примеры работы со списками:

>>> a = [66.25, 333, 333, 1, 1234.5]>>> print(a.count(333), a.count(66.25), a.count('x'))2 1 0>>> a.insert(2, -1)>>> a.append(333)>>> a[66.25, 333, -1, 333, 1, 1234.5, 333]>>> a.index(333)1>>> a.remove(333)>>> a[66.25, -1, 333, 1, 1234.5, 333]>>> a.reverse()>>> a[333, 1234.5, 1, 333, -1, 66.25]>>> a.sort()>>> a[-1, 1, 66.25, 333, 333, 1234.5]

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

Индексы и срезы

Взятие элемента по индексу

Как и в других языках программирования, взятие по индексу:

>>> a = [1, 3, 8, 7]>>> a[0]1>>> a[3]7>>> a[4]Traceback (most recent call last): File "<stdin>", line 1, in <module>IndexError: list index out of range

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

В данном примере переменная a являлась списком, однако взять элемент по индексу можно и у других типов: строк, кортежей.

В Python также поддерживаются отрицательные индексы, при этом нумерация идёт с конца, например:

>>> a = [1, 3, 8, 7]>>> a[-1]7>>> a[-4]1>>> a[-5]Traceback (most recent call last): File "<stdin>", line 1, in <module>IndexError: list index out of range

Срезы

В Python, кроме индексов, существуют ещё и срезы.

item[START:STOP:STEP] - берёт срез от номера START, до STOP (не включая его), с шагом STEP. По умолчанию START = 0, STOP = длине объекта, STEP = 1. Соответственно, какие-нибудь (а возможно, и все) параметры могут быть опущены.

>>> a = [1, 3, 8, 7]>>> a[:][1, 3, 8, 7]>>> a[1:][3, 8, 7]>>> a[:3][1, 3, 8]>>> a[::2][1, 8]

Также все эти параметры могут быть и отрицательными:

>>> a = [1, 3, 8, 7]>>> a[::-1][7, 8, 3, 1]>>> a[:-2][1, 3]>>> a[-2::-1][8, 3, 1]>>> a[1:4:-1][]

В последнем примере получился пустой список, так как START < STOP, а STEP отрицательный. То же самое произойдёт, если диапазон значений окажется за пределами объекта:

>>> a = [1, 3, 8, 7]>>> a[10:20][]

Также с помощью срезов можно не только извлекать элементы, но и добавлять и удалять элементы (разумеется, только для изменяемых последовательностей).

>>> a = [1, 3, 8, 7]>>> a[1:3] = [0, 0, 0]>>> a[1, 0, 0, 0, 7]>>> del a[:-3]>>> a[0, 0, 7]

Кортежи (tuple)

Кортеж, по сути - неизменяемый список.

Зачем нужны кортежи, если есть списки?

1. Защита от дурака. То есть кортеж защищен от изменений, как намеренных (что плохо), так и случайных (что хорошо).

2. Меньший размер. Дабы не быть голословным:

3. >>> a = (1, 2, 3, 4, 5, 6)4. >>> b = [1, 2, 3, 4, 5, 6]5. >>> a.__sizeof__()6. 367. >>> b.__sizeof__()8. 44

9. Возможность использовать кортежи в качестве ключей словаря:

10. >>> d = {(1, 1, 1) : 1}11. >>> d12. {(1, 1, 1): 1}13. >>> d = {[1, 1, 1] : 1}14. Traceback (most recent call last):15. File "", line 1, in16. d = {[1, 1, 1] : 1}17. TypeError: unhashable type: 'list'

Как работать с кортежами?

С преимуществами кортежей разобрались, теперь встает вопрос - а как с ними работать. Примерно так же, как и со списками.

Создаем пустой кортеж:

>>> a = tuple() #С помощью встроенной функции tuple()>>> a()>>> a = () #С помощью литерала кортежа>>> a()>>>

Создаем кортеж из одного элемента:

>>> a = ('s')>>> a's'

Стоп. Получилась строка. Но как же так? Мы же кортеж хотели! Как же нам кортеж получить?

>>> a = ('s', )>>> a('s',)

Ура! Заработало! Все дело - в запятой. Сами по себе скобки ничего не значат, точнее, значат то, что внутри них находится одна инструкция, которая может быть отделена пробелами, переносом строк и прочим мусором. Кстати, кортеж можно создать и так:

>>> a = 's',>>> a('s',)

Но все же не увлекайтесь, и ставьте скобки, тем более, что бывают случаи, когда скобки необходимы.

Ну и создать кортеж из итерируемого объекта можно с помощью все той же пресловутой функции tuple()

>>> a = tuple('hello, world!')>>> a('h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!')

Операции с кортежами

Все операции над списками, не изменяющие список (сложение, умножение на число, методы index() и count() и некоторые другие операции). Можно также по-разному менять элементы местами и так далее.

Например, гордость программистов на python - поменять местами значения двух переменных:

a, b = b, a

Словари (dict)

Словари в Python - неупорядоченные коллекции произвольных объектов с доступом по ключу. Их иногда ещё называют ассоциативными массивами или хеш-таблицами.

Чтобы работать со словарём, его нужно создать. Создать его можно несколькими способами. Во-первых, с помощью литерала:

>>> d = {}>>> d{}>>> d = {'dict': 1, 'dictionary': 2}>>> d{'dict': 1, 'dictionary': 2}

Во-вторых, с помощью функции dict:

>>> d = dict(short='dict', long='dictionary')>>> d{'short': 'dict', 'long': 'dictionary'}>>> d = dict([(1, 1), (2, 4)])>>> d{1: 1, 2: 4}

В-третьих, с помощью метода fromkeys:

>>> d = dict.fromkeys(['a', 'b'])>>> d{'a': None, 'b': None}>>> d = dict.fromkeys(['a', 'b'], 100)>>> d{'a': 100, 'b': 100}

В-четвертых, с помощью генераторов словарей, которые очень похожи на генераторы списков.

>>> d = {a: a ** 2 for a in range(7)}>>> d{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

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

>>> d = {1: 2, 2: 4, 3: 9}>>> d[1]2>>> d[4] = 4 ** 2>>> d{1: 2, 2: 4, 3: 9, 4: 16}>>> d['1']Traceback (most recent call last): File "", line 1, in d['1']KeyError: '1'

Как видно из примера, присвоение по новому ключу расширяет словарь, присвоение по существующему ключу перезаписывает его, а попытка извлечения несуществующего ключа порождает исключение. Для избежания исключения есть специальный метод (см. ниже), или можно перехватывать исключение.

Что же можно еще делать со словарями? Да то же самое, что и с другими объектами: встроенные функции, ключевые слова (например, циклы for и while), а также специальные методы словарей.

Методы словарей

dict.clear() - очищает словарь.

dict.copy() - возвращает копию словаря.

classmethod dict.fromkeys(seq[, value]) - создает словарь с ключами из seq и значением value (по умолчанию None).

dict.get(key[, default]) - возвращает значение ключа, но если его нет, не бросает исключение, а возвращает default (по умолчанию None).

dict.items() - возвращает пары (ключ, значение).

dict.keys() - возвращает ключи в словаре.

dict.pop(key[, default]) - удаляет ключ и возвращает значение. Если ключа нет, возвращает default (по умолчанию бросает исключение).

dict.popitem() - удаляет и возвращает пару (ключ, значение). Если словарь пуст, бросает исключение KeyError. Помните, что словари неупорядочены.

dict.setdefault(key[, default]) - возвращает значение ключа, но если его нет, не бросает исключение, а создает ключ с значением default (по умолчанию None).

dict.update([other]) - обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).

dict.values() - возвращает значения в словаре.