Кортежи и последовательности.

Мы видели, что списки и строки имеют много общих свойств, такие как индексирование и операция взятия среза. Они являются двумя примерами типа данных последовательностей. Поскольку Python - развивающийся язык, другие типы данных последовательностей могут быть добавлены. Существует также другой стандартный тип данных последовательностей: tuple (кортеж).

Кортеж состоит из ряда значений, разделенных запятыми, например:

>>> t = 12345, 54321, 'hello!' >>> t[0]12345>>> t(12345, 54321, 'hello!')>>> # Кортежи могут быть вложенными:... u = t, (1, 2, 3, 4, 5)>>> u((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))>>> # Кортежи неизменяемые:... t[0] = 88888Traceback (most recent call last): File "<stdin>", line 1, in <module>TypeError: 'tuple' object does not support item assignment>>> # но они могут содержать изменяемые объекты:... v = ([1, 2, 3], [3, 2, 1])>>> v([1, 2, 3], [3, 2, 1])

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

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

Особая проблема - создание кортежей, включающих 0 или 1 элемент: у синтаксиса есть некоторые дополнительные особенности для этого. Пустые кортежи создаются пустой парой скобок; кортежи с одним элементом - значением после которого идет запятая (недостаточно заключить одиночное значение в скобки). Не совсем красиво, но эффективно. Например:

>>> empty = ()>>> singleton = 'hello', # <-- заметьте запятую в конце >>> len(empty)0>>> len(singleton)1>>> singleton('hello',)

Выражение t = 12345, 54321, 'hello!' является примером упаковки кортежа: значения 12345, 54321 и 'hello!' упаковываются вместе в кортеж. Обратная операция также возможна:

>>> x, y, z = t

Это называется распаковкой последовательности и работает для любой последовательности с правой стороны. Распаковка последовательности требует, чтобы было в наличии так много переменных с левой стороны от знака равенства, сколько есть элементов в последовательности. Обратите внимание, что множественное присваивание на самом деле есть просто комбинирование упаковки кортежа и распаковки последовательности.

 

Множества.

Python также включает тип данных для множеств (sets). Множество - это неупорядоченная коллекция, не содержащая повторов элементов. Основное применение включает проверку наличия члена и устранение дублирующихся записей. Объекты множеств также поддерживают математические операции, такие как объединение, пересечение, разность и симметричная разность.

Для создания множеств могут быть использованы фигурные скобки или функция set(). Заметьте: для создания пустого множества вы должны использовать set(), а не {}; последние создают пустой словарь, структуру данных, которую мы обсудим в следующем разделе.

Вот краткая демонстрация:

>>> basket = { 'apple', 'orange', 'apple', 'pear', 'orange', 'banana' }>>> print(basket)                 # покажет, что дубликаты были удалены { 'orange', 'banana', 'pear', 'apple' }>>> 'orange' in basket            # быстрая проверка членства True >>> 'crabgrass' in basket False >>> # Демонстрируются операции над множествами на уникальных буквах из двух слов... >>> a = set('abracadabra')>>> b = set('alacazam')>>> a                             # уникальные буквы в a { 'a', 'r', 'b', 'c', 'd' }>>> a - b                         # буквы в a, но не в b { 'r', 'd', 'b' }>>> a | b                         # буквы или в a или в b { 'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l' }>>> a & b                         # буквы и в a и в b { 'a', 'c' }>>> a ^ b                         # буквы в a или b, но не в обоих { 'r', 'd', 'b', 'm', 'z', 'l' }

Подобно генераторам списка, генераторы множеств также поддерживаются:

>>> a = {x for x in 'abracadabra' if x not in 'abc' }>>> a{ 'r', 'd' }

 

Словари.

Другой полезный тип данных, встроенный в Python, - это словарь. Словари иногда встречаются в других языках как "ассоциативные записи" или "ассоциативные массивы". В отличие от последовательностей, которые индексируются диапазоном чисел, словари индексируются по ключам, которые могут быть любым неизменяемым типом; строки и числа всегда могут быть ключами. Кортежи могут быть использованы как ключи, если они содержат только строки, числа или кортежи; если кортеж включает какой-либо изменяемый объект, прямо или косвенно, он не может быть использован в качестве ключа. Вы не можете использовать списки как ключи, поскольку списки могут быть изменены на месте с помощью присваивания по индексу, срезу или такими методами как append() и extend().

Лучше всего думать о словарях как о неупорядоченном множестве пар key: value (ключ: значение) с тем требованием, что ключ уникален (внутри одного словаря). Пара скобок создает пустой словарь: {}. Размещение разделенного запятыми списка пар ключ: значение внутри скобок добавляет начальные пары в словарь; таким же способом словари выводятся.

Основными операциями над словарями являются сохранение значения с каким-либо ключом и извлечение значения по данному ключу. Также возможно удаление пары key:value с помощью del. Если вы сохраняете, используя ключ, который уже используется, то старое значение, связанное с этим ключом, будет потеряно. Ошибкой является извлечение значения, используя несуществующий ключ.

Применение list(d.keys()) к словарю возвращает список всех ключей, используемых в словаре в произвольном порядке (если вы хотите отсортировать, просто вместо этого используйте sorted(d.keys())). Чтобы проверить, есть ли какой-нибудь один ключ в словаре, используйте ключевое слово in.

Здесь небольшие примеры, использующие словарь:

>>> tel = { 'jack': 4098, 'sape': 4139}>>> tel[ 'guido' ] = 4127>>> tel{ 'sape': 4139, 'guido': 4127, 'jack': 4098}>>> tel[ 'jack' ]4098>>> del tel[ 'sape' ]>>> tel[ 'irv' ] = 4127>>> tel{ 'guido': 4127, 'irv': 4127, 'jack': 4098}>>> list(tel.keys())[ 'irv', 'guido', 'jack' ]>>> sorted(tel.keys())[ 'guido', 'irv', 'jack' ]>>> 'guido' in tel True >>> 'jack' not in tel False

Конструктор dict() строит словари прямо из последовательностей пар ключ-значение

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]){ 'sape': 4139, 'jack': 4098, 'guido': 4127}

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

>>> {x: x**2 for x in (2, 4, 6)}{2: 4, 4: 16, 6: 36}

Когда ключи являются простыми строками, то иногда проще указать пары, используя именованные аргументы:

>>> dict(sape=4139, guido=4127, jack=4098){ 'sape': 4139, 'jack': 4098, 'guido': 4127}

 

Приемы использования цикла.

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

>>> knights = { 'gallahad': 'the pure', 'robin': 'the brave' }>>> for k, v in knights.items():...     print(k, v)...gallahad the purerobin the brave

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

>>> for i, v in enumerate([ 'tic', 'tac', 'toe' ]):...     print(i, v)...0 tic1 tac2 toe

При прохождении цикла через две и более последовательности одновременно, записи могут быть объединены в пары с помощью функции zip().

>>> questions = [ 'name', 'quest', 'favorite color' ]>>> answers = [ 'lancelot', 'the holy grail', 'blue' ]>>> for q, a in zip(questions, answers):...     print('What is your {0}? It is {1}.'. format(q, a))...What is your name? It is lancelot.What is your quest? It is the holy grail.What is your favorite color? It is blue.

Для перебора последовательности в обратном направлении, сначала указывают последовательность в прямом направлении и затем вызывают функцию reversed():

>>> for i in reversed(range(1, 10, 2)):...     print(i)...97531

Для цикла по последовательности в отсортированном порядке, используйте функцию sorted(), которая возвращает новый отсортированный список, оставляя исходный неизменным.

>>> basket = [ 'apple', 'orange', 'apple', 'pear', 'orange', 'banana' ]>>> for f in sorted(set(basket)):...     print(f)...applebananaorangepear

Иногда заманчиво изменить список, пока вы перебираете его в цикле; однако вместо этого обычно проще и безопаснее создать новый список.

>>> import math>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]>>> filtered_data = []>>> for value in raw_data:...      if not math.isnan(value):...         filtered_data.append(value)...>>> filtered_data[56.2, 51.7, 55.3, 52.5, 47.8]

 

Подробнее об условиях.

Условия, используемые в операторах while и if могут содержать любые операторы, а не только сравнения.

Операторы сравнения in и not in проверяют, встречается ли (или нет) значение в последовательности. Операторы is и is not проверяют, являются ли два объекта действительно одним и тем же объектом; это имеет значение только для изменяемых объектов, как списки. У всех операторов сравнения одинаковый приоритет, который ниже, чем у всех численных операторов.

Сравнения могут быть объединены в цепь. Например, a < b == c проверяет, меньше ли a, чем b, и вдобавок b равно ли c.

Сравнения могут быть объединены с помощью логических операторов and и or, а результат сравнения (или любого другого логического выражения) может быть перевернут на обратный с помощью not. У этих операторов более низкий приоритет, чем у операторов сравнения; среди них not имеет самый высокий приоритет, а or самый низкий, так что A and not B or C есть эквивалент (A and (not B)) or C. Как всегда скобки могут быть использованы для указания желаемой последовательности выполнения.

Логические операторы and и or являются так называемыми операторами short-circuit (короткое замыкание): их аргументы оцениваются слева на право, и оценка останавливается, как только результат определен. Например, если A и C являются правдой, но B является ложью, то A and B and C не оценивает выражение C. При использовании не логического значения возвращаемым значением оператора короткого замыкания является последний аргумент, который был оценен.

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

>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance' >>> non_null = string1 or string2 or string3>>> non_null 'Trondheim'

Заметьте, что в Python, в отличие от C, присваивание не может происходить внутри выражений. Программистов на C это может разочаровать, но это позволяет избежать распространенного класса проблем, возникающих в программах на C: ввод = в выражении, когда подразумевалось ==.