Python Language
Module Collections

Introduction

Remarques

collections.Counter

Counter est une sous-classe dict qui vous permet de compter facilement des objets. Il a des méthodes utilitaires pour travailler avec les fréquences des objets que vous comptez.

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

le code ci-dessus crée un objet, compte, qui a les fréquences de tous les éléments passés au constructeur. Cet exemple a la valeur Counter({1: 1, 2: 1, 3: 1})

Exemples de constructeurs

Compteur de lettres

>>> 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})

Compteur de mots

>>> 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})

Recettes

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

Obtenir le nombre d'éléments individuels

>>> c['a']
4

Définir le nombre d'éléments individuels

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

Obtenir le nombre total d'éléments dans le compteur (4 + 2 + 0 - 3)

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

Obtenir des éléments (seuls ceux avec un compteur positif sont conservés)

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

Supprimer les clés avec une valeur 0 ou négative

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

Tout enlever

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

Ajouter supprimer des éléments individuels

>>> 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) renvoie une sous-classe de dict qui a une valeur par défaut pour les clés manquantes. L'argument doit être une fonction qui renvoie la valeur par défaut lorsqu'elle est appelée sans arguments. Si rien n'est passé, la valeur par défaut est None .

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

renvoie une référence à un defaultdict qui créera un objet de chaîne avec sa méthode default_factory.

Une utilisation typique de defaultdict est d'utiliser l'un des types intégrés tels que str , int , list ou dict comme default_factory, car ceux-ci renvoient des types vides lorsqu'ils sont appelés sans arguments:

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

L'appel du defaultdict avec une clé qui n'existe pas ne produit pas d'erreur comme dans un dictionnaire normal.

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

Un autre exemple avec 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})

Les méthodes de dictionnaire normales fonctionnent avec le dictionnaire par défaut

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

Utiliser list comme default_factory va créer une liste pour chaque nouvelle clé.

>>> 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

L'ordre des clés dans les dictionnaires Python est arbitraire: elles ne sont pas régies par l'ordre dans lequel vous les ajoutez.

Par exemple:

>>> 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}
```

(L'ordre arbitraire implicite ci-dessus signifie que vous pouvez obtenir des résultats différents avec le code ci-dessus à celui montré ici.)

L'ordre dans lequel les clés apparaissent est l'ordre dans lequel elles seront itérées, par exemple en utilisant une boucle for .

La classe collections.OrderedDict fournit des objets de dictionnaire qui conservent l'ordre des clés. OrderedDict peuvent être créées comme indiqué ci-dessous avec une série d’éléments ordonnés (ici, une liste de paires de clés-valeurs):

>>> 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)])

Ou nous pouvons créer un OrderedDict vide, puis ajouter des éléments:

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

L'itération via un OrderedDict permet l'accès à la clé dans l'ordre dans OrderedDict ils ont été ajoutés.

Que se passe-t-il si nous attribuons une nouvelle valeur à une clé existante?

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

La clé conserve sa place d'origine dans le OrderedDict .

collections.namedtuple

Définir un nouveau type Person utilisant namedtuple comme ceci:

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

Le second argument est la liste des attributs que le tuple aura. Vous pouvez répertorier ces attributs également sous forme de chaîne séparée par des espaces ou des virgules:

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

ou

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

Une fois défini, un tuple nommé peut être instancié en appelant l'objet avec les paramètres nécessaires, par exemple:

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

Les arguments nommés peuvent également être utilisés:

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

Vous pouvez maintenant accéder aux attributs du namedtuple:

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

Le premier argument du constructeur namedtuple (dans notre exemple 'Person' ) est le nom de typename . Il est courant d'utiliser le même mot pour le constructeur et le nom de fichier, mais ils peuvent être différents:

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

collections.deque

Retourne un nouvel objet deque initialisé de gauche à droite (en utilisant append ()) avec les données de l'itérable. Si itable n'est pas spécifié, le nouveau deque est vide.

Les Deques sont une généralisation des piles et des files d'attente (le nom se prononce «deck» et est l'abréviation de «double-queue queue»). Deques supportent ajouter ses thread-sûr, efficace et craquements mémoire de chaque côté de la deque avec approximativement la même O (1) la performance dans les deux sens.

Bien que les objets de liste prennent en charge des opérations similaires, ils sont optimisés pour les opérations rapides de longueur fixe et entraînent des coûts de mouvement de mémoire O (n) pour les opérations pop (0) et insert (0, v). .

Nouveau dans la version 2.4.

Si maxlen n'est pas spécifié ou est None , Deques peut atteindre une longueur arbitraire. Sinon, le deque est limité à la longueur maximale spécifiée. Une fois qu'un deque longueur limitée est plein, lorsque de nouveaux éléments sont ajoutés, un nombre correspondant d'éléments est éliminé de l'extrémité opposée. Les déques de longueur limitée offrent des fonctionnalités similaires à celles du filtre de queue sous Unix. Ils sont également utiles pour le suivi des transactions et des autres pools de données pour lesquels seule l’activité la plus récente présente un intérêt.

Modifié dans la version 2.6: Ajout du paramètre 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'])

Source: https://docs.python.org/2/library/collections.html

collections.ChainMap

ChainMap est nouveau dans la version 3.3

Renvoie un nouvel objet ChainMap plusieurs maps . Cet objet regroupe plusieurs dicts ou autres mappages pour créer une seule vue pouvant être mise à jour.

ChainMap s sont utiles pour gérer les contextes et les superpositions imbriqués. Un exemple dans le monde python se trouve dans l'implémentation de la classe Context dans le moteur de template de Django. Il est utile pour lier rapidement un certain nombre de mappages afin que le résultat puisse être traité comme une seule unité. Il est souvent beaucoup plus rapide que de créer un nouveau dictionnaire et d'exécuter plusieurs appels update() .

Chaque fois que l'on a une chaîne de valeurs de recherche, il peut y avoir un cas pour ChainMap . Un exemple consiste à avoir à la fois des valeurs spécifiées par l'utilisateur et un dictionnaire de valeurs par défaut. Un autre exemple est celui des cartes de paramètres POST et GET trouvées dans l'utilisation du Web, par exemple Django ou Flask. En utilisant ChainMap on renvoie une vue combinée de deux dictionnaires distincts.

La liste des paramètres des maps est triée de la première recherche à la dernière recherche. Les recherches recherchent les mappages sous-jacents successivement jusqu'à ce qu'une clé soit trouvée. En revanche, les écritures, les mises à jour et les suppressions ne fonctionnent que sur le premier mappage.

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)

Notez l'impact de l'ordre sur lequel la valeur est trouvée en premier dans la recherche ultérieure

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