Python Language
Collectiesmodule

Invoering

Opmerkingen

collections.Counter

Counter is een dict-subklasse waarmee u eenvoudig objecten kunt tellen. Het heeft hulpprogramma's voor het werken met de frequenties van de objecten die u aan het tellen bent.

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

de bovenstaande code maakt een object, counts, dat de frequenties heeft van alle elementen die aan de constructor zijn doorgegeven. Dit voorbeeld heeft de waarde Counter({1: 1, 2: 1, 3: 1})

Constructeur voorbeelden

Brieventeller

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

Woordenteller

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

Recepten

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

Krijg telling van individueel element

>>> c['a']
4

Stel het aantal afzonderlijke elementen in

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

Krijg totaal aantal elementen in teller (4 + 2 + 0 - 3)

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

Ontvang elementen (alleen die met een positieve teller worden bewaard)

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

Verwijder sleutels met 0 of negatieve waarde

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

Verwijder alles

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

Voeg afzonderlijke elementen verwijderen toe

>>> 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) retourneert een subklasse van dict met een standaardwaarde voor ontbrekende sleutels. Het argument moet een functie zijn die de standaardwaarde retourneert wanneer deze zonder argumenten wordt aangeroepen. Als er niets wordt doorgegeven, wordt dit standaard None .

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

retourneert een verwijzing naar een standaarddictum dat een stringobject maakt met zijn standaardmethode.

Een standaardgebruik van defaultdict is het gebruik van een van de ingebouwde typen zoals str , int , list of dict als default_factory, omdat deze lege typen retourneren wanneer ze zonder argumenten worden opgeroepen:

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

Het aanroepen van het standaarddict met een sleutel die niet bestaat, levert geen fout op zoals in een normaal woordenboek.

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

Een ander voorbeeld met 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})

Normale woordenboekmethoden werken met het standaardwoordenboek

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

Als u list als standaardfabriek gebruikt, maakt u een lijst voor elke nieuwe sleutel.

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

De volgorde van sleutels in Python-woordenboeken is willekeurig: ze worden niet bepaald door de volgorde waarin u ze toevoegt.

Bijvoorbeeld:

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

(De willekeurige volgorde die hierboven wordt geïmpliceerd, betekent dat u mogelijk andere resultaten krijgt met de bovenstaande code dan hier wordt weergegeven.)

De volgorde waarin de toetsen verschijnen, is de volgorde waarin ze worden herhaald, bijvoorbeeld met behulp van een for lus.

De klasse collections.OrderedDict biedt woordenboekobjecten die de volgorde van de sleutels behouden. OrderedDict s kunnen worden gemaakt zoals hieronder wordt getoond met een reeks geordende items (hier, een lijst met tuple sleutel / waarde-paren):

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

Of we kunnen een leeg OrderedDict en vervolgens items toevoegen:

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

Door een OrderedDict te doorlopen OrderedDict u toegang tot de sleutel in de volgorde waarin ze zijn toegevoegd.

Wat gebeurt er als we een nieuwe waarde toewijzen aan een bestaande sleutel?

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

De sleutel behoudt zijn oorspronkelijke plaats in het OrderedDict .

collections.namedtuple

Definieer een nieuw type Person die namedtuple als volgt gebruikt:

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

Het tweede argument is de lijst met attributen die de tuple zal hebben. U kunt deze attributen ook als spatie of door komma's gescheiden tekenreeksen vermelden:

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

of

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

Eenmaal gedefinieerd, kan een benoemd tuple worden geïnstantieerd door het object aan te roepen met de nodige parameters, bijvoorbeeld:

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

Benoemde argumenten kunnen ook worden gebruikt:

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

Nu hebt u toegang tot de kenmerken van de naamedtuple:

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

Het eerste argument voor de constructor namedtuple (in ons voorbeeld 'Person' ) is de typename . Het is gebruikelijk om hetzelfde woord te gebruiken voor de constructor en de typenaam, maar ze kunnen verschillen:

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

collections.deque

Retourneert een nieuw deque object dat van links naar rechts is geïnitialiseerd (met append ()) met gegevens uit iterable. Als iterable niet is opgegeven, is de nieuwe deque leeg.

Deques zijn een generalisatie van stapels en wachtrijen (de naam wordt uitgesproken als "deck" en staat voor "dubbele wachtrij"). Deques ondersteunen thread-safe, geheugenefficiënt voegt en springt van beide kanten van de deque met ongeveer dezelfde O (1) prestaties in beide richtingen.

Hoewel lijstobjecten vergelijkbare bewerkingen ondersteunen, zijn ze geoptimaliseerd voor snelle bewerkingen met een vaste lengte en maken ze O (n) geheugenbewegingskosten voor pop (0) en insert (0, v) bewerkingen die zowel de grootte als de positie van de onderliggende gegevensrepresentatie veranderen .

Nieuw in versie 2.4.

Als maxlen niet is opgegeven of None , kunnen deques tot een willekeurige lengte groeien. Anders wordt de deque begrensd tot de opgegeven maximale lengte. Zodra een deque lengte is begrensd, worden bij het toevoegen van nieuwe items een overeenkomstig aantal items aan het andere uiteinde weggegooid. Grenzen met begrensde lengte bieden functionaliteit vergelijkbaar met het staartfilter in Unix. Ze zijn ook handig voor het bijhouden van transacties en andere gegevenspools waarbij alleen de meest recente activiteit van belang is.

Gewijzigd in versie 2.6: parameter maxlen toegevoegd.

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

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

collections.ChainMap

ChainMap is nieuw in versie 3.3

Retourneert een nieuw ChainMap object met een aantal maps . Dit object groepeert meerdere dictaten of andere toewijzingen om een enkele, bij te werken weergave te creëren.

ChainMap 's zijn handig voor het beheren van geneste contexten en overlays. Een voorbeeld in de python-wereld is te vinden in de implementatie van de Context klasse in de template-engine van Django. Het is handig om snel een aantal toewijzingen te koppelen, zodat het resultaat als een enkele eenheid kan worden behandeld. Het is vaak veel sneller dan het maken van een nieuw woordenboek en het uitvoeren van meerdere update() -aanroepen.

ChainMap wanneer men een ketting van ChainMap heeft, kan ChainMap . Een voorbeeld is het hebben van zowel door de gebruiker opgegeven waarden als een woordenboek met standaardwaarden. Een ander voorbeeld zijn de POST en GET parameterkaarten die worden gevonden in webgebruik, bijvoorbeeld Django of Flask. Door het gebruik van ChainMap geeft men een gecombineerd beeld terug van twee verschillende woordenboeken.

De maps parameter lijst wordt besteld bij de eerste gezocht naar de laatste doorzocht. Lookups doorzoeken achtereenvolgens de onderliggende toewijzingen totdat een sleutel wordt gevonden. Schrijven, updates en verwijderingen werken daarentegen alleen bij de eerste toewijzing.

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)

Let op het effect van de volgorde waarop eerst waarde wordt gevonden in de daaropvolgende opzoekactie

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