Python Language
Samlingsmodul

Introduktion

Anmärkningar

collections.Counter

Räknare är en dikt underklass som låter dig enkelt räkna objekt. Den har verktygsmetoder för att arbeta med frekvenserna för de objekt du räknar.

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

ovanstående kod skapar ett objekt, räknar, som har frekvenserna för alla element som skickas till konstruktören. Detta exempel har värdet Counter({1: 1, 2: 1, 3: 1})

Konstruktörsexempel

Brevräknare

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

Ordräknare

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

recept

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

Få räkning av enskilda element

>>> c['a']
4

Ställ in antalet individuella element

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

Få totalt antal element i räknaren (4 + 2 + 0 - 3)

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

Skaffa element (endast de med positiv räkning behålls)

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

Ta bort nycklar med 0 eller negativt värde

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

Ta bort allt

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

Lägg till ta bort enskilda element

>>> 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) returnerar en underklass av dict som har ett standardvärde för saknade nycklar. Argumentet bör vara en funktion som returnerar standardvärdet när det anropas utan argument. Om inget har passerat, är det standardvärde som None .

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

returnerar en referens till ett standarddikt som skapar ett strängobjekt med dess standard_faktoriska metod.

En typisk användning av defaultdict är att använda en av de inbyggda typerna som str , int , list eller dict som default_factory, eftersom dessa returnerar tomma typer när de kallas utan argument:

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

Att ringa standarddict med en nyckel som inte finns skapar inte något fel som i en vanlig ordlista.

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

Ett annat exempel med 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})

Normala ordboksmetoder fungerar med standardordlistan

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

Om du använder list som default_factory skapas en lista för varje ny nyckel.

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

Ordningen på nycklar i Python-ordböcker är godtycklig: de styrs inte av ordningen du lägger till dem.

Till exempel:

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

(Den godtyckliga beställningen som anges ovan betyder att du kan få olika resultat med ovanstående kod än den som visas här.)

Ordningen i vilken nycklarna visas är den ordning som de skulle upprepas över, t.ex. med en for loop.

collections.OrderedDict klassen innehåller ordboksobjekt som behåller ordning på nycklar. OrderedDict kan skapas som visas nedan med en serie beställda objekt (här, en lista med tupel-nyckelvärdespar):

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

Eller så kan vi skapa en tom OrderedDict och sedan lägga till objekt:

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

Iterating via en OrderedDict tillåter nyckelåtkomst i den ordning de lades till.

Vad händer om vi tilldelar ett nytt värde till en befintlig nyckel?

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

Nyckeln behåller sin ursprungliga plats i OrderedDict .

collections.namedtuple

Definiera en ny typ av Person använder namedtuple så här:

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

Det andra argumentet är listan över attribut som tupeln kommer att ha. Du kan lista dessa attribut också som antingen mellanslag eller kommaseparerad sträng:

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

eller

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

När den har definierats kan en namngiven tupel instanseras genom att anropa objektet med nödvändiga parametrar, t.ex.

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

Namngivna argument kan också användas:

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

Nu kan du komma åt attributen för den namngivna uppupeln:

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

Det första argumentet till den namngivna konstruktören (i vårt exempel 'Person' ) är typename . Det är typiskt att använda samma ord för konstruktören och typnamnet, men de kan vara olika:

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

collections.deque

Returnerar ett nytt deque initialiserats från vänster till höger (med bilaga ()) med data från iterable. Om iterable inte anges är den nya deque tom.

Deques är en generalisering av staplar och köer (namnet uttalas som "däck" och är förkortat med "dubbelkön"). Deques stödjer gängsäkra, minneseffektiva tillbehör och dyker upp från båda sidor om deque med ungefär samma O (1) -prestanda i båda riktningarna.

Även om listobjekt stöder liknande operationer, är de optimerade för snabba funktioner i fast längd och medför O (n) minnesrörelsekostnader för pop (0) och infoga (0, v) -operationer som ändrar både storleken och positionen för den underliggande datarepresentationen .

Ny i version 2.4.

Om maxlen inte anges eller är None , kan deques växa till godtycklig längd. I annat deque begränsas deque till den angivna maximala längden. När en avgränsad deque är full, när nya artiklar läggs till, kastas ett motsvarande antal objekt från motsatt ände. Avgränsade längddäck ger funktioner som liknar svansfiltret i Unix. De är också användbara för att spåra transaktioner och andra pooler med data där bara den senaste aktiviteten är av intresse.

Ändrad i version 2.6: Tillagd maxlen-parameter.

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

Källa: https://docs.python.org/2/library/collections.html

collections.ChainMap

ChainMap är ny i version 3.3

Returnerar ett nytt ChainMap objekt med ett antal maps . Detta objekt grupperar flera punkter eller andra mappningar tillsammans för att skapa en enda uppdaterbar vy.

ChainMap är användbara för att hantera kapslade sammanhang och överlägg. Ett exempel i pythonvärlden finns i implementeringen av Context klassen i Djangos mallmotor. Det är användbart för att snabbt länka ett antal kartläggningar så att resultatet kan behandlas som en enda enhet. Det är ofta mycket snabbare än att skapa en ny ordbok och köra samtal för flera update() .

När som helst har en kedja av uppslagningsvärden kan det vara fallet för ChainMap . Ett exempel inkluderar att ha både användarspecificerade värden och en ordlista med standardvärden. Ett annat exempel är POST och GET parameterkartan som finns i webbanvändning, t.ex. Django eller Flask. Genom att använda ChainMap returnerar man en kombinerad bild av två distinkta ordböcker.

Den maps parameterlistan beställs från första sökt till sista sökt. Sökningar söker i bakomliggande mappningar successivt tills en nyckel hittas. Däremot fungerar skrivningar, uppdateringar och raderingar endast vid den första kartläggningen.

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)

Notera inverkan av ordningen på vilket värde som hittas först i den efterföljande sökningen

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