Python Language
Sammlungen-Modul

Einführung

Bemerkungen

Sammlungen. Zähler

Counter ist eine Diktierunterklasse, mit der Sie Objekte leicht zählen können. Es gibt nützliche Methoden zum Arbeiten mit den Häufigkeiten der Objekte, die Sie zählen.

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

Der obige Code erstellt ein Objekt mit der Anzahl aller Elemente, die an den Konstruktor übergeben werden. Dieses Beispiel hat den Wert Counter({1: 1, 2: 1, 3: 1})

Konstruktionsbeispiele

Briefzähler

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

Wortzähler

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

Rezepte

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

Zählen Sie die einzelnen Elemente

>>> c['a']
4

Anzahl der einzelnen Elemente festlegen

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

Gesamtzahl der Elemente in Zähler ermitteln (4 + 2 + 0 - 3)

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

Elemente abrufen (nur diejenigen mit einem positiven Zähler werden beibehalten)

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

Schlüssel mit 0 oder negativem Wert entfernen

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

Alles entfernen

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

Hinzufügen, einzelne Elemente entfernen

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

collection.defaultdict

Collections.defaultdict (default_factory) gibt eine Unterklasse von dict , die über einen Standardwert für fehlende Schlüssel verfügt. Das Argument sollte eine Funktion sein, die den Standardwert zurückgibt, wenn sie ohne Argumente aufgerufen wird. Wenn nichts übergeben wird, wird standardmäßig " None .

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

Gibt einen Verweis auf ein defaultdict zurück, das ein String-Objekt mit seiner default_factory-Methode erstellt.

In der defaultdict verwendet defaultdict einen der eingebauten Typen wie str , int , list oder dict als default_factory, da diese leere Typen zurückgeben, wenn sie ohne Argumente aufgerufen werden:

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

Das Aufrufen des defaultdict mit einer nicht vorhandenen Taste führt nicht zu einem Fehler wie in einem normalen Wörterbuch.

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

Ein weiteres Beispiel mit 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 Wörterbuchmethoden arbeiten mit dem Standardwörterbuch

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

Wenn Sie list als default_factory verwenden, wird für jeden neuen Schlüssel eine Liste erstellt.

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

Die Reihenfolge der Schlüssel in Python-Wörterbüchern ist beliebig: Sie werden nicht von der Reihenfolge bestimmt, in der Sie sie hinzufügen.

Zum Beispiel:

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

(Die oben angegebene willkürliche Reihenfolge bedeutet, dass Sie mit dem obigen Code andere Ergebnisse erzielen können als hier gezeigt.)

Die Reihenfolge, in der die Schlüssel erscheinen, ist die Reihenfolge, in der sie wiederholt werden würden, z. B. mithilfe einer for Schleife.

Die collections.OrderedDict Klasse stellt Wörterbuchobjekte bereit, die die Reihenfolge der Schlüssel beibehalten. OrderedDict s können wie unten gezeigt mit einer Reihe von bestellten Artikeln erstellt werden (hier eine Liste von Tupel-Schlüssel-Wert-Paaren):

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

Oder wir erstellen ein leeres OrderedDict und fügen dann Elemente hinzu:

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

Durch Iteration durch ein OrderedDict wird der Schlüsselzugriff in der Reihenfolge ermöglicht, in der sie hinzugefügt wurden.

Was passiert, wenn wir einem vorhandenen Schlüssel einen neuen Wert zuweisen?

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

Der Schlüssel behält seinen ursprünglichen Platz im OrderedDict .

collection.namedtuple

Definieren Sie einen neuen Typ Person mit namedtuple wie namedtuple :

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

Das zweite Argument ist die Liste der Attribute, die das Tupel haben wird. Sie können diese Attribute auch als durch Leerzeichen oder durch Kommas getrennte Zeichenfolge auflisten:

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

oder

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

Nach der Definition kann ein benanntes Tupel durch Aufrufen des Objekts mit den erforderlichen Parametern instanziiert werden, z.

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

Benannte Argumente können auch verwendet werden:

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

Jetzt können Sie auf die Attribute des namedtuple zugreifen:

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

Das erste Argument für den namedTuple-Konstruktor (in unserem Beispiel 'Person' ) ist der typename . Es ist üblich, dasselbe Wort für den Konstruktor und den Typnamen zu verwenden, sie können jedoch unterschiedlich sein:

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

Collections.deque

Gibt ein neues deque Objekt zurück, das von links nach rechts (mithilfe von append ()) mit den Daten von iterable initialisiert wurde. Wenn iterable nicht angegeben ist, ist der neue deque leer.

Deques sind eine Verallgemeinerung von Stapeln und Warteschlangen (der Name wird als "Deck" ausgesprochen und steht für "Double-Ended-Queue"). Deques unterstützen Thread-sichere, speichereffiziente Anhänge und Pop-ups von beiden Seiten der deque mit ungefähr derselben O (1) -Leistung in beiden Richtungen.

Obwohl Listenobjekte ähnliche Operationen unterstützen, sind sie für schnelle Operationen mit fester Länge optimiert und verursachen O (n) Speicherbewegungskosten für Pop (0) - und Insert-Operationen (0, v), die sowohl die Größe als auch die Position der zugrunde liegenden Datendarstellung ändern .

Neu in Version 2.4.

Wenn maxlen nicht angegeben ist oder None , können Deques beliebig lang werden. Ansonsten ist der deque an die angegebene maximale Länge gebunden. Wenn eine begrenzte deque voll ist und neue Elemente hinzugefügt werden, wird eine entsprechende Anzahl von Elementen vom gegenüberliegenden Ende entfernt. Begrenzte Längenverschiebungen bieten ähnliche Funktionen wie der Endfilter in Unix. Sie sind auch nützlich, um Transaktionen und andere Datenpools zu verfolgen, bei denen nur die letzte Aktivität von Interesse ist.

In Version 2.6 geändert: Maxlen-Parameter hinzugefügt.

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

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

Collections.ChainMap

ChainMap ist neu in Version 3.3

Gibt ein neues ChainMap Objekt bei einer Anzahl von maps . Dieses Objekt fasst mehrere Diktate oder andere Zuordnungen zusammen, um eine einzelne, aktualisierbare Ansicht zu erstellen.

ChainMap sind nützlich, um verschachtelte Kontexte und Überlagerungen zu verwalten. Ein Beispiel in der Python-Welt ist die Implementierung der Context Klasse in Djangos Template-Engine. Es ist nützlich, um eine Reihe von Zuordnungen schnell zu verknüpfen, damit das Ergebnis als eine Einheit behandelt werden kann. Dies ist häufig viel schneller als das Erstellen eines neuen Wörterbuchs und das Ausführen mehrerer Aufrufe von update() .

Immer wenn einer eine Kette von Nachschlagewerten hat, kann es für ChainMap einen Fall ChainMap . Ein Beispiel enthält sowohl vom Benutzer angegebene Werte als auch ein Wörterbuch mit Standardwerten. Ein anderes Beispiel sind die POST und GET Parameterkarten, die bei der Verwendung im Web gefunden werden, z. B. Django oder Flask. Durch die Verwendung von ChainMap eine kombinierte Ansicht von zwei verschiedenen Wörterbüchern zurückgegeben.

Die maps Parameterliste wird von zuerst gesucht bis zuletzt durchsucht. Suchvorgänge durchsuchen die zugrunde liegenden Zuordnungen nacheinander, bis ein Schlüssel gefunden wird. Im Gegensatz dazu werden Schreibvorgänge, Aktualisierungen und Löschvorgänge nur für das erste Mapping ausgeführt.

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)

Beachten Sie die Auswirkungen der Reihenfolge, auf die der Wert bei der nachfolgenden Suche zuerst gefunden wird

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