Python Language
Модуль коллекций

Вступление

замечания

collections.Counter

Счетчик - это подкласс класса dict, который позволяет легко подсчитывать объекты. Он имеет полезные методы для работы с частотами объектов, которые вы считаете.

import collections
counts = collections.Counter([1,2,3])

приведенный выше код создает объект, счетчик, который имеет частоты всех элементов, переданных конструктору. Этот пример имеет значение Counter({1: 1, 2: 1, 3: 1})

Примеры конструктора

Счетчик писем

>>> collections.Counter('Happy Birthday')
Counter({'a': 2, 'p': 2, 'y': 2, 'i': 1, 'r': 1, 'B': 1, ' ': 1, 'H': 1, 'd': 1, 'h': 1, 't': 1})

Счетчик слов

>>> collections.Counter('I am Sam Sam I am That Sam-I-am That Sam-I-am! I do not like that Sam-I-am'.split())
Counter({'I': 3, 'Sam': 2, 'Sam-I-am': 2, 'That': 2, 'am': 2, 'do': 1, 'Sam-I-am!': 1, 'that': 1, 'not': 1, 'like': 1})

Рецепты

>>> c = collections.Counter({'a': 4, 'b': 2, 'c': -2, 'd': 0})

Получить количество отдельных элементов

>>> c['a']
4

Установить количество отдельных элементов

>>> c['c'] = -3
>>> c
Counter({'a': 4, 'b': 2, 'd': 0, 'c': -3})

Получить общее количество элементов в счетчике (4 + 2 + 0 - 3)

>>> sum(c.itervalues())  # negative numbers are counted!
3

Получить элементы (сохраняются только те, у которых есть положительный счетчик)

>>> list(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

Удалить ключи с 0 или отрицательным значением

>>> c - collections.Counter()
Counter({'a': 4, 'b': 2})

Удалить все

>>> c.clear()
>>> c
Counter()

Добавить удалить отдельные элементы

>>> c.update({'a': 3, 'b':3})
>>> c.update({'a': 2, 'c':2})  # adds to existing, sets if they don't exist
>>> c
Counter({'a': 5, 'b': 3, 'c': 2})
>>> c.subtract({'a': 3, 'b': 3, 'c': 3})  # subtracts (negative values are allowed)
>>> c
Counter({'a': 2, 'b': 0, 'c': -1})

collections.defaultdict

collections.defaultdict (default_factory) возвращает подкласс dict который имеет значение по умолчанию для отсутствующих ключей. Аргумент должен быть функцией, которая возвращает значение по умолчанию при вызове без аргументов. Если ничего не прошло, по умолчанию используется значение None .

>>> state_capitals = collections.defaultdict(str)
>>> state_capitals
defaultdict(<class 'str'>, {})

возвращает ссылку на defaultdict, который будет создавать строковый объект с его методом default_factory.

Типичным использованием defaultdict является использование одного из встроенных типов, таких как str , int , list или dict как default_factory, поскольку они возвращают пустые типы при вызове без аргументов:

>>> str()
''
>>> int()
0
>>> list
[]

Вызов defaultdict с ключом, который не существует, не вызывает ошибки, как в обычном словаре.

>>> state_capitals['Alaska']
''
>>> state_capitals
defaultdict(<class 'str'>, {'Alaska': ''})

Другой пример: int :

>>> fruit_counts = defaultdict(int)
>>> fruit_counts['apple'] += 2  # No errors should occur
>>> fruit_counts
default_dict(int, {'apple': 2})
>>> fruit_counts['banana']  # No errors should occur
0
>>> fruit_counts  # A new key is created
default_dict(int, {'apple': 2, 'banana': 0})

Обычные словарные методы работают со стандартным словарем

>>> state_capitals['Alabama'] = 'Montgomery'
>>> state_capitals
defaultdict(<class 'str'>, {'Alabama': 'Montgomery', 'Alaska': ''})

Использование list как default_factory приведет к созданию списка для каждого нового ключа.

>>> s = [('NC', 'Raleigh'), ('VA', 'Richmond'), ('WA', 'Seattle'), ('NC', 'Asheville')]
>>> dd = collections.defaultdict(list)
>>> for k, v in s:
...     dd[k].append(v)
>>> dd
defaultdict(<class 'list'>, 
    {'VA': ['Richmond'], 
     'NC': ['Raleigh', 'Asheville'], 
     'WA': ['Seattle']})

collections.OrderedDict

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

Например:

>>> d = {'foo': 5, 'bar': 6}
>>> print(d)
{'foo': 5, 'bar': 6}
>>> d['baz'] = 7
>>> print(a)
{'baz': 7, 'foo': 5, 'bar': 6}
>>> d['foobar'] = 8
>>> print(a)
{'baz': 7, 'foo': 5, 'bar': 6, 'foobar': 8}
```

(Вышеуказанный произвольный порядок означает, что вы можете получить разные результаты с приведенным выше кодом, как показано здесь.)

Порядок, в котором появляются клавиши, - это порядок, в котором они будут повторяться, например, используя цикл for .

Класс collections.OrderedDict предоставляет объекты словаря, которые сохраняют порядок ключей. OrderedDict s может быть создан, как показано ниже, с серией упорядоченных элементов (здесь, список пар ключей-значений кортежа):

>>> from collections import OrderedDict
>>> d = OrderedDict([('foo', 5), ('bar', 6)])
>>> print(d)
OrderedDict([('foo', 5), ('bar', 6)])
>>> d['baz'] = 7
>>> print(d)
OrderedDict([('foo', 5), ('bar', 6), ('baz', 7)])
>>> d['foobar'] = 8
>>> print(d)
OrderedDict([('foo', 5), ('bar', 6), ('baz', 7), ('foobar', 8)])

Или мы можем создать пустой OrderedDict а затем добавить элементы:

>>> o = OrderedDict()
>>> o['key1'] = "value1"
>>> o['key2'] = "value2"
>>> print(o)
OrderedDict([('key1', 'value1'), ('key2', 'value2')])

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

Что произойдет, если мы присвоим новое значение существующему ключу?

>>> d['foo'] = 4
>>> print(d)
OrderedDict([('foo', 4), ('bar', 6), ('baz', 7), ('foobar', 8)])

Ключ сохраняет свое первоначальное место в OrderedDict .

collections.namedtuple

Определите новый тип Person использующий namedtuple следующим образом:

Person = namedtuple('Person', ['age', 'height', 'name'])

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

Person = namedtuple('Person', 'age, height, name')

или же

Person = namedtuple('Person', 'age height name')

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

dave = Person(30, 178, 'Dave')

Именованные аргументы также могут использоваться:

jack = Person(age=30, height=178, name='Jack S.')

Теперь вы можете получить доступ к атрибутам namedtuple:

print(jack.age)  # 30
print(jack.name)  # 'Jack S.'

Первым аргументом конструктора namedtuple (в нашем примере 'Person' ) является typename . Типично использовать одно и то же слово для конструктора и typename, но они могут быть разными:

Human = namedtuple('Person',  'age, height, name')
dave = Human(30, 178, 'Dave')
print(dave)  # yields: Person(age=30, height=178, name='Dave')

collections.deque

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

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

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

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

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

Изменено в версии 2.6: Добавлен параметр maxlen.

>>> from collections import deque
>>> d = deque('ghi')                 # make a new deque with three items
>>> for elem in d:                   # iterate over the deque's elements
...     print elem.upper()
G
H
I

>>> d.append('j')                    # add a new entry to the right side
>>> d.appendleft('f')                # add a new entry to the left side
>>> d                                # show the representation of the deque
deque(['f', 'g', 'h', 'i', 'j'])

>>> d.pop()                          # return and remove the rightmost item
'j'
>>> d.popleft()                      # return and remove the leftmost item
'f'
>>> list(d)                          # list the contents of the deque
['g', 'h', 'i']
>>> d[0]                             # peek at leftmost item
'g'
>>> d[-1]                            # peek at rightmost item
'i'

>>> list(reversed(d))                # list the contents of a deque in reverse
['i', 'h', 'g']
>>> 'h' in d                         # search the deque
True
>>> d.extend('jkl')                  # add multiple elements at once
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> d.rotate(1)                      # right rotation
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
>>> d.rotate(-1)                     # left rotation
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> deque(reversed(d))               # make a new deque in reverse order
deque(['l', 'k', 'j', 'i', 'h', 'g'])
>>> d.clear()                        # empty the deque
>>> d.pop()                          # cannot pop from an empty 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() reverses the input order
>>> d
deque(['c', 'b', 'a'])

Источник: https://docs.python.org/2/library/collections.html

collections.ChainMap

ChainMap является новым в версии 3.3

Возвращает новый объект ChainMap учетом количества maps . Этот объект группирует несколько диктов или других сопоставлений вместе для создания единого обновляемого представления.

ChainMap s полезны для управления вложенными контекстами и наложениями. Пример в мире python содержится в реализации класса Context в движке шаблонов Django. Это полезно для быстрого связывания нескольких отображений, чтобы результат можно рассматривать как единое целое. Это часто намного быстрее, чем создание нового словаря и выполнение нескольких вызовов update() .

Каждый раз, когда есть цепочка значений поиска, может быть случай для ChainMap . Пример включает в себя как пользовательские значения, так и словарь значений по умолчанию. Другим примером являются карты параметров POST и GET найденные в Интернете, например Django или Flask. Благодаря использованию ChainMap возвращается комбинированный вид двух разных словарей.

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

import collections

# define two dictionaries with at least some keys overlapping.
dict1 = {'apple': 1, 'banana': 2}
dict2 = {'coconut': 1, 'date': 1, 'apple': 3}

# create two ChainMaps with different ordering of those dicts.
combined_dict = collections.ChainMap(dict1, dict2)
reverse_ordered_dict = collections.ChainMap(dict2, dict1)

Обратите внимание, что влияние порядка, по которому значение определяется первым в последующем поиске

for k, v in combined_dict.items():
    print(k, v)
    
date 1
apple 1
banana 2
coconut 1

for k, v in reverse_ordered_dict.items():
    print(k, v)

date 1
apple 3
banana 2
coconut 1