8.3. collections – Типы контейнеров¶collections – Container datatypes

8.3.1. ChainMap объекты¶ChainMap objects

Класс ChainMap используется для быстрого объединения нескольких отображений в единое целое. Он часто работает намного быстрее, чем создание нового словаря и выполнение множества вызовов update().

Класс можно использовать для имитации вложенных областей видимости; он полезен в шаблонизаторах.

class collections.ChainMap(*maps)¶

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

Базовые отображения хранятся в списке. Этот список является общедоступным и может быть получен или изменён с помощью атрибута maps. Других состояний нет.

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

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

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

maps¶

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

new_child(m=None)¶

Возвращает новый ChainMap, содержащий новое отображение, за которым следуют все отображения из текущего экземпляра. Если указан m, он становится новым отображением в начале списка отображений; если не указан, используется пустой словарь, так что вызов d.new_child() эквивалентен: ChainMap({}, *d.maps). Этот метод используется для создания подконтекстов, которые можно обновлять, не изменяя значения ни в одном из родительских отображений.

Изменено в версии 3.4: Добавлен необязательный параметр m.

parents¶

Свойство, возвращающее новый ChainMap, содержащий все отображения текущего экземпляра, кроме первого. Это полезно для пропуска первого отображения при поиске. Варианты использования аналогичны ключевому слову nonlocal, используемому в вложенных областях видимости. Также случаи использования перекликаются со встроенной функцией super(). Ссылка на d.parents эквивалентна: ChainMap(*d.maps[1:]).

import builtins
pylookup = ChainMap(locals(), globals(), vars(builtins))

import os, argparse

defaults = {'color': 'red', 'user': 'guest'}

parser = argparse.ArgumentParser()
parser.add_argument('-u', '--user')
parser.add_argument('-c', '--color')
namespace = parser.parse_args()
command_line_args = {k:v for k, v in vars(namespace).items() if v}

combined = ChainMap(command_line_args, os.environ, defaults)
print(combined['color'])
print(combined['user'])

c = ChainMap()        # Создать корневой контекст
d = c.new_child()     # Создать вложенный дочерний контекст
e = c.new_child()     # Дочерний контекст c, независимый от d
e.maps[0]             # Словарь текущего контекста – как locals() в Python
e.maps[-1]            # Корневой контекст – как globals() в Python
e.parents             # Цепочка объемлющих контекстов – как nonlocals в Python

d['x']                # Получить первый ключ в цепочке контекстов
d['x'] = 1            # Установить значение в текущем контексте
del d['x']            # Удалить из текущего контекста
list(d)               # Все вложенные значения
k in d                # Проверить все вложенные значения
len(d)                # Количество вложенных значений
d.items()             # Все вложенные элементы
dict(d)               # Развернуть в обычный словарь

class DeepChainMap(ChainMap):
    'Variant of ChainMap that allows direct updates to inner scopes'

    def __setitem__(self, key, value):
        for mapping in self.maps:
            if key in mapping:
                mapping[key] = value
                return
        self.maps[0][key] = value

    def __delitem__(self, key):
        for mapping in self.maps:
            if key in mapping:
                del mapping[key]
                return
        raise KeyError(key)

>>> d = DeepChainMap({'zebra': 'black'}, {'elephant': 'blue'}, {'lion': 'yellow'})
>>> d['lion'] = 'orange'         # обновить существующий ключ на два уровня ниже
>>> d['snake'] = 'red'           # новые ключи добавляются в самый верхний словарь
>>> del d['elephant']            # удалить существующий ключ на один уровень ниже
DeepChainMap({'zebra': 'black', 'snake': 'red'}, {}, {'lion': 'orange'})

8.3.2. Counter объекты¶Counter objects

Предоставляется инструмент счётчика для удобного и быстрого подсчёта. Например:

>>> # Подсчитать вхождения слов в списке
>>> cnt = Counter()
>>> for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
...     cnt[word] += 1
>>> cnt
Counter({'blue': 3, 'red': 2, 'green': 1})

>>> # Найти десять самых распространённых слов в «Гамлете»
>>> import re
>>> words = re.findall(r'\w+', open('hamlet.txt').read().lower())
>>> Counter(words).most_common(10)
[('the', 1143), ('and', 966), ('to', 762), ('of', 669), ('i', 631),
 ('you', 554),  ('a', 546), ('my', 514), ('hamlet', 471), ('in', 451)]

class collections.Counter([iterable-or-mapping])¶

Counter – это подкласс dict для подсчёта хешируемых объектов. Это неупорядоченная коллекция, в которой элементы хранятся как ключи словаря, а их количества – как значения словаря. Количества могут быть любыми целыми числами, включая ноль и отрицательные значения. Класс Counter аналогичен мультимножествам (bags или multisets) в других языках.

Элементы подсчитываются из итерируемого объекта или инициализируются из другого отображения (или счётчика):

>>> c = Counter()                           # новый пустой счётчик
>>> c = Counter('gallahad')                 # новый счётчик из итерируемого объекта
>>> c = Counter({'red': 4, 'blue': 2})      # новый счётчик из отображения
>>> c = Counter(cats=4, dogs=8)             # новый счётчик из именованных аргументов

Объекты Counter имеют интерфейс словаря, за исключением того, что при отсутствии элемента они возвращают нулевой счёт вместо возбуждения KeyError:

>>> c = Counter(['eggs', 'ham'])
>>> c['bacon']                              # счёт отсутствующего элемента равен нулю
0

Установка счёта в ноль не удаляет элемент из счётчика. Используйте del для полного удаления:

>>> c['sausage'] = 0                        # запись счётчика с нулевым значением
>>> del c['sausage']                        # del действительно удаляет запись

Новое в версии 3.1.

Объекты Counter поддерживают три метода в дополнение к тем, что доступны для всех словарей:

elements()¶

Возвращает итератор по элементам, повторяя каждый столько раз, сколько указано в его счёте. Элементы возвращаются в произвольном порядке. Если счёт элемента меньше единицы, elements() игнорирует его.

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

most_common([n])¶

Возвращает список из n наиболее часто встречающихся элементов и их счётов, от самого частого к самому редкому. Если n опущен или равен None, most_common() возвращает все элементы счётчика. Элементы с одинаковым счётом упорядочиваются произвольно:

>>> Counter('abracadabra').most_common(3)
[('a', 5), ('r', 2), ('b', 2)]

subtract([iterable-or-mapping])¶

Элементы вычитаются из iterable или из другого mapping (или счётчика). Как dict.update(), но вычитает счёты вместо их замены. И входные, и выходные значения могут быть нулевыми или отрицательными.

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> d = Counter(a=1, b=2, c=3, d=4)
>>> c.subtract(d)
>>> c
Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

Новое в версии 3.2.

Для объектов Counter доступны обычные методы словаря, за исключением двух, которые работают иначе для счётчиков.

fromkeys(iterable)¶

Этот метод класса не реализован для объектов Counter.

update([iterable-or-mapping])¶

Элементы подсчитываются из iterable или добавляются из другого mapping (или счётчика). Как dict.update(), но добавляет счёты вместо их замены. Кроме того, iterable должен быть последовательностью элементов, а не последовательностью пар (key, value).

Распространённые приёмы работы с объектами Counter:

sum(c.values())                 # сумма всех значений
c.clear()                       # сбросить все значения
list(c)                         # список уникальных элементов
set(c)                          # преобразовать в множество
dict(c)                         # преобразовать в обычный словарь
c.items()                       # преобразовать в список пар (elem, cnt)
Counter(dict(list_of_pairs))    # создать из списка пар (элемент, кол-во)
c.most_common()[:-n-1:-1]       # n наименее частых элементов
+c                              # удалить нулевые и отрицательные значения

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

>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c + d                       # сложение двух счётчиков: c[x] + d[x]
Counter({'a': 4, 'b': 3})
>>> c - d                       # вычитание (остаются только положительные значения)
Counter({'a': 2})
>>> c & d                       # пересечение: min(c[x], d[x])
Counter({'a': 1, 'b': 1})
>>> c | d                       # объединение: max(c[x], d[x])
Counter({'a': 3, 'b': 2})

Унарное сложение и вычитание – это сокращения для добавления пустого счётчика или вычитания из пустого счётчика.

>>> c = Counter(a=2, b=-4)
>>> +c
Counter({'a': 2})
>>> -c
Counter({'b': 4})

8.3.3. deque объекты¶deque objects

class collections.deque([iterable[, maxlen]])¶

Возвращает новый объект deque, инициализированный слева направо (с помощью append()) данными из iterable. Если iterable не указан, новый deque пуст.

Deques представляют собой обобщение стеков и очередей (название произносится «дэк» и является сокращением от «двусторонняя очередь»). Deques поддерживают потокобезопасные и эффективные по памяти операции добавления и извлечения элементов с любого из концов очереди с примерно одинаковой производительностью O(1) в обоих направлениях.

Хотя объекты list поддерживают аналогичные операции, они оптимизированы для быстрых операций фиксированной длины и несут затраты памяти O(n) для операций pop(0) и insert(0, v), которые изменяют как размер, так и положение базового представления данных.

Если maxlen не указан или равен None, deque могут расти до произвольной длины. В противном случае deque ограничен заданной максимальной длиной. Как только deque с ограниченной длиной заполняется, при добавлении новых элементов соответствующее количество элементов отбрасывается с противоположного конца. Deque с ограниченной длиной предоставляют функциональность, аналогичную фильтру tail в Unix. Они также полезны для отслеживания транзакций и других пулов данных, где интерес представляет только самая последняя активность.

Объекты deque поддерживают следующие методы:

append(x)¶

Добавляет x в правую часть deque.

appendleft(x)¶

Добавляет x в левую часть deque.

clear()¶

Удаляет все элементы из deque, после чего его длина равна 0.

count(x)¶

Подсчитывает количество элементов deque, равных x.

Новое в версии 3.2.

extend(iterable)¶

Расширяет правую часть deque, добавляя элементы из итерируемого объекта.

extendleft(iterable)¶

Расширяет левую часть deque, добавляя элементы из итерируемого объекта. Обратите внимание: последовательное добавление слева приводит к обращению порядка элементов в итерируемом объекте.

pop()¶

Удаляет и возвращает элемент с правой стороны deque. Если элементов нет, возбуждает IndexError.

popleft()¶

Удаляет и возвращает элемент с левой стороны deque. Если элементов нет, возбуждает IndexError.

remove(value)¶

Удаляет первое вхождение value. Если не найдено, возбуждает ValueError.

reverse()¶

Переворачивает элементы deque по месту и затем возвращает None.

Новое в версии 3.2.

rotate(n)¶

Поворачивает deque на n шагов вправо. Если n отрицательно, поворачивает влево. Поворот на один шаг вправо эквивалентен: d.appendleft(d.pop()).

Объекты deque также предоставляют один атрибут только для чтения:

maxlen¶

Максимальный размер deque или None, если неограничен.

Новое в версии 3.1.

В дополнение к вышеперечисленному, двусторонние очереди поддерживают итерацию, сериализацию, len(d), reversed(d), copy.copy(d), copy.deepcopy(d), проверку принадлежности с помощью оператора in и доступ по индексу, например d[-1]. Индексированный доступ занимает O(1) на обоих концах, но замедляется до O(n) в середине. Для быстрого произвольного доступа используйте списки.

Пример:

>>> from collections import deque
>>> d = deque('ghi')                 # создать новый deque с тремя элементами
>>> for elem in d:                   # обход элементов deque
...     print(elem.upper())
G
H
I

>>> d.append('j')                    # добавить новый элемент справа
>>> d.appendleft('f')                # добавить новый элемент слева
>>> d                                # показать представление deque
deque(['f', 'g', 'h', 'i', 'j'])

>>> d.pop()                          # вернуть и удалить правый элемент
'j'
>>> d.popleft()                      # вернуть и удалить левый элемент
'f'
>>> list(d)                          # вывести содержимое deque
['g', 'h', 'i']
>>> d[0]                             # посмотреть левый элемент
'g'
>>> d[-1]                            # посмотреть правый элемент
'i'

>>> list(reversed(d))                # вывести содержимое deque в обратном порядке
['i', 'h', 'g']
>>> 'h' in d                         # поиск в deque
True
>>> d.extend('jkl')                  # добавить несколько элементов за раз
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> d.rotate(1)                      # поворот вправо
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
>>> d.rotate(-1)                     # поворот влево
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> deque(reversed(d))               # создать новую deque в обратном порядке
deque(['l', 'k', 'j', 'i', 'h', 'g'])
>>> d.clear()                        # очистить deque
>>> d.pop()                          # невозможно извлечь элемент из пустой deque
Traceback (most recent call last):
    File "<pyshell#6>", line 1, in -toplevel-
        d.pop()
IndexError: pop from an empty deque

>>> d.extendleft('abc')              # extendleft() меняет порядок ввода на обратный
>>> d
deque(['c', 'b', 'a'])

def tail(filename, n=10):
    'Return the last n lines of a file'
    with open(filename) as f:
        return deque(f, n)

def moving_average(iterable, n=3):
    # moving_average([40, 30, 50, 46, 39, 44]) --> 40.0 42.0 45.0 43.0
    # http://en.wikipedia.org/wiki/Moving_average
    it = iter(iterable)
    d = deque(itertools.islice(it, n-1))
    d.appendleft(0)
    s = sum(d)
    for elem in it:
        s += elem - d.popleft()
        d.append(elem)
        yield s / n

def delete_nth(d, n):
    d.rotate(-n)
    d.popleft()
    d.rotate(n)

8.3.4. defaultdict объекты¶defaultdict objects

class collections.defaultdict([default_factory[, ...]])¶

Возвращает новый объект, подобный словарю. defaultdict является подклассом встроенного класса dict. Он переопределяет один метод и добавляет одну изменяемую переменную экземпляра. Остальная функциональность такая же, как у класса dict, и здесь не документируется.

Первый аргумент задаёт начальное значение для атрибута default_factory; по умолчанию None. Все остальные аргументы обрабатываются так же, как если бы они были переданы конструктору dict, включая именованные аргументы.

Объекты defaultdict поддерживают следующий метод в дополнение к стандартным операциям dict:

__missing__(key)¶

Если атрибут default_factory равен None, это возбуждает исключение KeyError с key в качестве аргумента.

Если default_factory не равен None, он вызывается без аргументов, чтобы предоставить значение по умолчанию для заданного key; это значение вставляется в словарь для key и возвращается.

Если вызов default_factory возбуждает исключение, это исключение распространяется без изменений.

Этот метод вызывается методом __getitem__() класса dict, когда запрошенный ключ не найден; то, что он возвращает или возбуждает, затем возвращается или возбуждается методом __getitem__().

Обратите внимание, что __missing__() не вызывается для любых операций, кроме __getitem__(). Это означает, что get(), как и обычные словари, будет возвращать None в качестве значения по умолчанию, а не использовать default_factory.

Объекты defaultdict поддерживают следующую переменную экземпляра:

default_factory¶

Этот атрибут используется методом __missing__(); он инициализируется из первого аргумента конструктора, если он присутствует, или None, если отсутствует.

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> for k, v in s:
...     d[k].append(v)
...
>>> list(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

>>> d = {}
>>> for k, v in s:
...     d.setdefault(k, []).append(v)
...
>>> list(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

>>> s = 'mississippi'
>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1
...
>>> list(d.items())
[('i', 4), ('p', 2), ('s', 4), ('m', 1)]

>>> def constant_factory(value):
...     return lambda: value
>>> d = defaultdict(constant_factory('<missing>'))
>>> d.update(name='John', action='ran')
>>> '%(name)s %(action)s to %(object)s' % d
'John ran to <missing>'

>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
>>> d = defaultdict(set)
>>> for k, v in s:
...     d[k].add(v)
...
>>> list(d.items())
[('blue', {2, 4}), ('red', {1, 3})]

8.3.5. Фабричная функция namedtuple() для кортежей с именованными полями¶namedtuple() Factory Function for Tuples with Named Fields

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

collections.namedtuple(typename, field_names, verbose=False, rename=False)¶

Возвращает новый подкласс кортежа с именем typename. Новый подкласс используется для создания объектов, подобных кортежу, поля которых доступны через обращение к атрибутам, а также индексируемы и итерируемы. Экземпляры подкласса также имеют полезную docstring (с именем типа и полями) и полезный метод __repr__(), который выводит содержимое кортежа в формате name=value.

Параметр field_names может быть строкой, в которой имена полей разделены пробелами и/или запятыми, например 'x y' или 'x, y'. Как вариант, field_names может быть последовательностью строк, например ['x', 'y'].

В качестве имени поля может использоваться любой допустимый идентификатор Python, кроме имён, начинающихся с подчёркивания. Допустимые идентификаторы состоят из букв, цифр и подчёркиваний, но не начинаются с цифры или подчёркивания и не могут быть ключевым словом, таким как class, for, return, global, pass или raise.

Если rename равно true, недопустимые имена полей автоматически заменяются позиционными именами. Например, ['abc', 'def', 'ghi', 'abc'] преобразуется в ['abc', '_1', 'ghi', '_3'], удаляя ключевое слово def и дублирующееся имя поля abc.

Если verbose равно true, определение класса выводится после его создания. Эта опция устарела; вместо этого проще вывести атрибут _source.

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

Изменено в версии 3.1: Добавлена поддержка rename.

>>> # Базовый пример
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(11, y=22)     # создать экземпляр с позиционными или именованными аргументами
>>> p[0] + p[1]             # доступен по индексу, как обычный кортеж (11, 22)
33
>>> x, y = p                # распаковывается как обычный кортеж
>>> x, y
(11, 22)
>>> p.x + p.y               # поля также доступны по имени
33
>>> p                       # читаемое __repr__ в стиле name=value
Point(x=11, y=22)

Именованные кортежи особенно полезны для присвоения имён полям кортежам результатов, возвращаемым модулями csv или sqlite3:

EmployeeRecord = namedtuple('EmployeeRecord', 'name, age, title, department, paygrade')

import csv
for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):
    print(emp.name, emp.title)

import sqlite3
conn = sqlite3.connect('/companydata')
cursor = conn.cursor()
cursor.execute('SELECT name, age, title, department, paygrade FROM employees')
for emp in map(EmployeeRecord._make, cursor.fetchall()):
    print(emp.name, emp.title)

В дополнение к методам, унаследованным от кортежей, именованные кортежи поддерживают три дополнительных метода и два атрибута. Чтобы избежать конфликтов с именами полей, имена методов и атрибутов начинаются с подчёркивания.

classmethod somenamedtuple._make(iterable)¶

Метод класса, который создаёт новый экземпляр из существующей последовательности или итерируемого объекта.

>>> t = [11, 22]
>>> Point._make(t)
Point(x=11, y=22)

somenamedtuple._asdict()¶

Возвращает новый OrderedDict, который сопоставляет имена полей с соответствующими значениями:

>>> p = Point(x=11, y=22)
>>> p._asdict()
OrderedDict([('x', 11), ('y', 22)])

Изменено в версии 3.1: Возвращает OrderedDict вместо обычного dict.

somenamedtuple._replace(kwargs)¶

Возвращает новый экземпляр именованного кортежа, заменяя указанные поля новыми значениями:

>>> p = Point(x=11, y=22)
>>> p._replace(x=33)
Point(x=33, y=22)

>>> for partnum, record in inventory.items():
...     inventory[partnum] = record._replace(price=newprices[partnum], timestamp=time.now())

somenamedtuple._source¶

Строка с исходным кодом на чистом Python, использованным для создания класса именованного кортежа. Исходный код делает именованный кортеж самодокументируемым. Его можно вывести на печать, выполнить с помощью exec() или сохранить в файл и импортировать.

Новое в версии 3.3.

somenamedtuple._fields¶

Кортеж строк с именами полей. Полезен для интроспекции и для создания новых типов именованных кортежей из существующих.

>>> p._fields            # просмотреть имена полей
('x', 'y')

>>> Color = namedtuple('Color', 'red green blue')
>>> Pixel = namedtuple('Pixel', Point._fields + Color._fields)
>>> Pixel(11, 22, 128, 255, 0)
Pixel(x=11, y=22, red=128, green=255, blue=0)

Чтобы получить поле, имя которого хранится в строке, используйте функцию getattr():

>>> getattr(p, 'x')
11

Чтобы преобразовать словарь в именованный кортеж, используйте оператор двойной звёздочки (как описано в разделе Распаковка списков аргументов):

>>> d = {'x': 11, 'y': 22}
>>> Point(**d)
Point(x=11, y=22)

Поскольку именованный кортеж – это обычный класс Python, легко добавить или изменить функциональность с помощью подкласса. Вот как добавить вычисляемое поле и формат печати с фиксированной шириной:

>>> class Point(namedtuple('Point', 'x y')):
    __slots__ = ()
    @property
    def hypot(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5
    def __str__(self):
        return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)

>>> for p in Point(3, 4), Point(14, 5/7):
    print(p)
Point: x= 3.000  y= 4.000  hypot= 5.000
Point: x=14.000  y= 0.714  hypot=14.018

Приведённый выше подкласс устанавливает __slots__ в пустой кортеж. Это помогает снизить потребление памяти, предотвращая создание словарей экземпляров.

Наследование не подходит для добавления новых хранимых полей. Вместо этого просто создайте новый тип именованного кортежа на основе атрибута _fields:

>>> Point3D = namedtuple('Point3D', Point._fields + ('z',))

Значения по умолчанию можно реализовать, используя _replace() для настройки экземпляра-прототипа:

>>> Account = namedtuple('Account', 'owner balance transaction_count')
>>> default_account = Account('<owner name>', 0.0, 0)
>>> johns_account = default_account._replace(owner='John')
>>> janes_account = default_account._replace(owner='Jane')

Перечислимые константы можно реализовать с помощью именованных кортежей, но проще и эффективнее использовать простой Enum:

>>> Status = namedtuple('Status', 'open pending closed')._make(range(3))
>>> Status.open, Status.pending, Status.closed
(0, 1, 2)
>>> from enum import Enum
>>> class Status(Enum):
...     open, pending, closed = range(3)

8.3.6. Объекты OrderedDict¶OrderedDict objects

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

class collections.OrderedDict([items])¶

Возвращает экземпляр подкласса dict, поддерживающий обычные методы dict. OrderedDict – это словарь, который запоминает порядок, в котором ключи были вставлены впервые. Если новая запись перезаписывает существующую, исходная позиция вставки остаётся неизменной. Удаление записи и повторная вставка перемещает её в конец.

Новое в версии 3.1.

popitem(last=True)¶

Метод popitem() для упорядоченных словарей возвращает и удаляет пару (ключ, значение). Пары возвращаются в порядке LIFO, если last равно true, или в порядке FIFO, если false.

move_to_end(key, last=True)¶

Перемещает существующий ключ на любой конец упорядоченного словаря. Элемент перемещается в правый конец, если last равно true (по умолчанию), или в начало, если last равно false. Возбуждает KeyError, если ключ не существует:

>>> d = OrderedDict.fromkeys('abcde')
>>> d.move_to_end('b')
>>> ''.join(d.keys())
'acdeb'
>>> d.move_to_end('b', last=False)
>>> ''.join(d.keys())
'bacde'

Новое в версии 3.2.

В дополнение к обычным методам отображений, упорядоченные словари также поддерживают обратную итерацию с помощью reversed().

Проверки на равенство между объектами OrderedDict чувствительны к порядку и реализованы как list(od1.items())==list(od2.items()). Проверки на равенство между объектами OrderedDict и другими объектами Mapping не чувствительны к порядку, как обычные словари. Это позволяет объектам OrderedDict использоваться вместо обычного словаря где угодно.

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

>>> # обычный неотсортированный словарь
>>> d = {'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}

>>> # словарь, отсортированный по ключу
>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])

>>> # словарь, отсортированный по значению
>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])

>>> # словарь, отсортированный по длине строки ключа
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

class LastUpdatedOrderedDict(OrderedDict):
    'Store items in the order the keys were last added'

    def __setitem__(self, key, value):
        if key in self:
            del self[key]
        OrderedDict.__setitem__(self, key, value)

class OrderedCounter(Counter, OrderedDict):
    'Counter that remembers the order elements are first encountered'

    def __repr__(self):
        return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))

    def __reduce__(self):
        return self.__class__, (OrderedDict(self),)

8.3.7. Объекты UserDict¶UserDict objects

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

class collections.UserDict([initialdata])¶

Класс, имитирующий словарь. Содержимое экземпляра хранится в обычном словаре, который доступен через атрибут data объектов UserDict. Если передан initialdata, то data инициализируется его содержимым; обратите внимание, что ссылка на initialdata не сохраняется, что позволяет использовать его для других целей.

В дополнение к поддержке методов и операций отображений, экземпляры UserDict предоставляют следующий атрибут:

data¶

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

8.3.8. Объекты UserList¶UserList objects

Этот класс действует как обёртка вокруг объектов-списков. Это полезный базовый класс для собственных классов, подобных спискам, которые могут наследовать от них и переопределять существующие методы или добавлять новые. Таким образом, можно добавлять новое поведение к спискам.

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

class collections.UserList([list])¶

Класс, имитирующий список. Содержимое экземпляра хранится в обычном списке, который доступен через атрибут data объектов UserList. Содержимое экземпляра изначально устанавливается в копию list, по умолчанию пустой список []. list может быть любым итерируемым объектом, например, настоящим списком Python или объектом UserList.

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

data¶

Настоящий объект list, используемый для хранения содержимого класса UserList.

Требования к созданию подклассов: Ожидается, что подклассы UserList предоставляют конструктор, который может быть вызван без аргументов или с одним аргументом. Операции со списком, возвращающие новую последовательность, пытаются создать экземпляр фактического класса реализации. Для этого предполагается, что конструктор можно вызвать с одним параметром, являющимся объектом последовательности, используемым в качестве источника данных.

Если производный класс не желает соблюдать это требование, все специальные методы, поддерживаемые этим классом, должны быть переопределены; обратитесь к исходному коду за информацией о методах, которые необходимо предоставить в этом случае.

8.3.9. Объекты UserString¶UserString objects

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

class collections.UserString([sequence])¶

Класс, имитирующий строку или объект строки Unicode. Содержимое экземпляра хранится в обычном строковом объекте, который доступен через атрибут data объектов UserString. Содержимое экземпляра изначально устанавливается в копию sequence. sequence может быть экземпляром bytes, str, UserString (или подклассом) или произвольной последовательностью, которая может быть преобразована в строку с помощью встроенной функции str().