[python]Collectionsモジュールの説明

Collectionsモジュールの各クラスはpythonに組み込まれたデータ型listとdictの機能を補完するために使用され、いくつかの特性の場合、Collectionsのクラスを使用するとより良い効果が得られます.
Collectionsモジュールに含まれるクラス:namedtuple()
factory function for creating tuple subclasses with named fields deque
list-like container with fast appends and pops on either end ChainMap
dict-like class for creating a single view of multiple mappings Counter
dict subclass for counting hashable objects OrderedDict
dict subclass that remembers the order entries were added defaultdict
dict subclass that calls a factory function to supply missing values UserDict
wrapper around dictionary objects for easier dict subclassing UserList
wrapper around list objects for easier list subclassing UserString
wrapper around string objects for easier string subclassing
namedtuple
応用需要:tupleの中の要素は要素のtupleの中の位置を通じてインデックスを行うしかないことを知っています.最大の問題は要素の位置が要素の本当の意味と結合しにくいことです.結局、コードは人に理解されなければなりません.tupleの要素が多すぎると、コードのメンテナンスに大きな課題をもたらします.
namedtupleは、上記の痛みを解決するために、tupleの要素に名前を付けることでkeyと考えられ、keyを通じてvalueにアクセスすることで、位置インデックスがコードを読む人に与える悩みを解決することができます.
>  collections. namedtuple (typename, field_names, *, verbose=False, rename=False, module=None)
typenameはnamedtupleクラスの名前である文字列で、namedtupleが返す値の名前をtypenameと同じように設定することに慣れています.typenameは文字列の形式で表されます.namedtuple(typename,field_names)を実行するとtupleサブクラスが返され、各要素の別名はfield_namesの文字列に名前を付けます.
field_namesはtuple要素の別名です.keyと考えられます.これにより、位置を使用してtuple要素をインデックスすることを回避できます.field_namesは複数のfield_からname構成、各field_nameは文字列でなければなりません.field_nameは2つの方法でfield_を構成することができるnames、1つはすべてfield_をnameはlistにロードされ(['a','b','c','d'])、もう1つはfield_nameはすべて1つの文字列にロードされ、field_name間は、('a b cd'または'a,b,c')を区切り記号(スペース、カンマ、tab)で区切ります.特に、namedtupleはオブジェクトではなくクラスを生成することに注意してください.

>>> Point1 = namedtuple('Point','x,y,z')
>>> Point2 = namedtuple('Point','x y z')
>>> Point3 = namedtuple('Point',['x', 'y', 'z'])

namedtupleクラスを生成するにはインスタンス化オブジェクトが必要です.namedtupleクラスは初期化時にいくつかの別名があり、インスタンス化するにはいくつかのパラメータが必要です.パラメータを直接持ち込むこともできますし、オブジェクトを別名=値でインスタンス化することもできます.

>>> p=Point1(1,2,3)
>>> p
Point(x=1, y=2, z=3)
>>> q=Point(z=33,y=22,x=11)
>>> q
Point(x=11, y=22, z=33)

> classmethod somenamedtuple. _make (iterable)
上記の初期化方法に加えて、iterableによってオブジェクトをインスタンス化することもできます.

>>> Point

>>> p=Point._make([11,12,13])
>>> p
Point(x=11, y=12, z=13)

この関数の利点は、namedtupleオブジェクトに自動的に値を割り当てることができ、つまり_make()関数は、他の関数の入力パラメータ(ファクトリメソッド)として使用されます.

EmployeeRecord = namedtuple('EmployeeRecord', 'name, age, title, department, paygrade')

import csv
for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):
    print(emp.name, emp.title)

>  somenamedtuple. _asdict ()
キー値ペアがnamedtupleの別名と対応する値であるOrderedDictを返します.

>>> p
Point(x=11, y=12, z=13)
>>> p._asdict()
OrderedDict([('x', 11), ('y', 12), ('z', 13)])

>  somenamedtuple. _replace (kwargs)
namedtupleオブジェクトをインスタンス化した後、一部の要素の値を置き換えるには_replaceメソッド.

>>> p
Point(x=11, y=12, z=13)
>>> p._replace(x=33)
Point(x=33, y=12, z=13)

パケットを取り外す方法を使用して_replace()のパラメータ.

>>> p
Point(x=11, y=12, z=13)
>>> new_point = {'x':100,'y':101,'z':102}
>>> p._replace(**new_point)
Point(x=100, y=101, z=102)

>   somenamedtuple. _fields
すべてのtuple要素の別名を返します.

>>> p._fields            # view the field names
('x', 'y')

>>> Color = namedtuple('Color', 'red green blue') # Three tuple: red, green, blue
>>> Pixel = namedtuple('Pixel', Point._fields + Color._fields) # Five tuple: x,y,red,green,blue
>>> Pixel(11, 22, 128, 255, 0)
Pixel(x=11, y=22, red=128, green=255, blue=0)

namedtupleオブジェクトのプロパティの値のみを取得する場合は、組み込み関数getattr()を使用するか、「点」記号を直接使用します.

>>> p
Point(x=11, y=12, z=13)
>>> getattr(p,'z')
13
>>> getattr(p,'y')
12
>>> p.x
11

 
deque(listへの拡張)
応用需要:queueデータ構造のデータは先進的な先出であり、一方向からデータを挿入し、他方からデータを排出するしかない.両方ともpopデータを使用する場合はdequeデータ構造を使用します.Dequeのフルネームは「double-ended queue」です.
> class collections. deque ([iterable[, maxlen]])
要素がiterableであるdequeオブジェクトを返します.iterableが空の場合、空のdequeオブジェクトが返されます.
maxlenはdequeの最大長を指定し、パラメータの値を指定しない場合、dequeは無限に増加することができます.iterableの長さがmaxlenより大きい場合、後に入ったデータは、iterableがすべて遍歴するまで、先に入った「押し出し」をします.

>>> deque(range(10))
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> deque(range(100),10)  #     ，        “   ”
deque([90, 91, 92, 93, 94, 95, 96, 97, 98, 99], maxlen=10)

listにappend、extend、clear、remove、insert、pop、reverseメソッドがあるように、dequeにも上記のメソッドがあり、これらのメソッドのほかにdequeデータ構造特有のものもあります.
>  appendleft (x)
機能はappend()に似ていますが、左側の開始位置にパラメータxを追加するだけです.
>  extendleft (iterable)
機能はextend()に似ていますが、左側の開始位置にiterableを追加するだけです.
>  popleft ()
機能はpop()に似ていますが、左側の開始位置のデータを「押し出す」だけで、この値を返します.
>  rotate (n)
Dequeのすべての要素をループしてnビット右に移動します.nが負の場合、ループはnビット左にシフトする.
>  maxlen
Dequeオブジェクトのmaxlenの値を返し、dequeがmaxlenパラメータを設定していない場合はNoneを返します.
 
ChainMap(dictへの拡張)
≪適用オブジェクト|Apply Objects|emdw≫:複数のdictを同じリストに統合し、1つのkeyが複数のvalueに対応する場合(複数のdictに同じkeyが存在する場合)に、最初に現れるkキー値のペアを基準に、後で現れるものは無視されます.
> class collections. ChainMap (*maps)
ChainMapオブジェクトを返します(リストと考えられますが、要素はすべてmapsオブジェクトです).ただし、mapsが空の場合、ChainMapには空のdictが1つしかありません.mapが空でない場合、ChainMapはすべてのmapsオブジェクトを保存します.

>>> x = {'b': 10, 'c': 11}
>>> y = {'a': 1, 'b': 2}
>>> z = ChainMap(x, y)
>>> z
ChainMap({'b': 10, 'c': 11}, {'a': 1, 'b': 2})
>>> ChainMap()
ChainMap({})

ChainMapオブジェクトについて、いくつか説明する必要があります.

ChainMapキー値ペアを問い合わせる方法はdictと同様であり、異なる点はChainMapが最初のキー値ペアに遭遇するまでリスト内のすべてのdictを巡回することである.クエリのキー値ペアが存在しない場合、KeyError例外

が放出されます.

>>> z
ChainMap({'b': 10, 'c': 11}, {'a': 1, 'b': 2})
>>> z['b']
10
>>> z['a']
1
>>> z['e']
    raise KeyError(key)
KeyError: 'e'

キー値ペアを変更する方法はdictと同様で、ChainMapリストの最初のdictのみを変更するのとは異なり、以下の列から分かるように、key['b']=100を変更すると、リストの1つのdictのみが変更される.キー値ペアkey['a']=101を追加する場合、このキー値ペア

が最初のdictにのみ増加する.

>>> z
ChainMap({'b': 10, 'c': 11}, {'a': 1, 'b': 2})
>>> z['b']=100
>>> z['a']=101
>>> z
ChainMap({'b': 100, 'c': 11, 'a': 101}, {'a': 1, 'b': 2})

Python Documentationで説明したように、
Lookups search the underlying mappings successively until a key is found. In contrast, writes, updates, and deletions only operate on the first mapping.

dictのメソッドはChainMapで正常に使用できますが、keyとvalueからなるtupleを返すitems()メソッドに注意してください.ChainMapで同じkeyに複数のvalueが存在する可能性があるため、競合を回避するためには、原則として最初に現れるキー値ペアを基準として

とする.

>>> z.items()
ItemsView(ChainMap({'b': 100, 'c': 11, 'a': 101}, {'a': 1, 'b': 2}))
>>> list(z.items())
[('b', 100), ('c', 11), ('a', 101)]

> maps
ChainMapをlist方式で返すと,ChainMapは本質的に複数のdictが入ったリストであることがわかる.

>>> z
ChainMap({'b': 100, 'c': 11, 'a': 101}, {'a': 1, 'b': 2})
>>> z.maps
[{'b': 100, 'c': 11, 'a': 101}, {'a': 1, 'b': 2}]

> new_child (m=None)
新しいChainMapを返します.最初の要素はmで、後ろには元のdictリストが続いています.new_child()関数が空の場合、新しいChainMapの最初のdictは空になります.

>>> z.new_child()  # First dict is empty
ChainMap({}, {'b': 100, 'c': 11, 'a': 101}, {'a': 1, 'b': 2})
>>> z.new_child({'a': 1, 'b':2})   # First dict is new
ChainMap({'a': 1, 'b': 2}, {'b': 100, 'c': 11, 'a': 101}, {'a': 1, 'b': 2})

> parents
ChainMapの2番目以降のdictを返し、1番目のdictは無視されます.

>>> z
ChainMap({'b': 100, 'c': 11, 'a': 101}, {'a': 1, 'b': 2})
>>> z.parents
ChainMap({'a': 1, 'b': 2})

 
Counter
≪適用オブジェクト|Apply Objects|emdw≫:listまたはiterableの各要素の出現回数を統計し、要素と要素の回数がキー値ペアの辞書を含むCounterオブジェクトを返します.
> class collections. Counter ([iterable-or-mapping])
リスト内の要素の出現回数を統計するには、次の例のようにCounter()を使用するのが非常に簡単です.

>>> Counter(['red', 'blue', 'red', 'green', 'blue', 'blue'])
Counter({'blue': 3, 'red': 2, 'green': 1})
>>> Counter('aaaffereffswfwgffdfsdf')
Counter({'f': 9, 'a': 3, 'e': 2, 's': 2, 'w': 2, 'd': 2, 'r': 1, 'g': 1})

Counterオブジェクトを生成すると、list、set、tuple、dictを呼び出して対応するタイプのデータを生成できます.

>>> dict(Counter('aaaffereffswfwgffdfsdf'))
{'a': 3, 'f': 9, 'e': 2, 'r': 1, 's': 2, 'w': 2, 'g': 1, 'd': 2}
>>> list(Counter('aaaffereffswfwgffdfsdf'))
['a', 'f', 'e', 'r', 's', 'w', 'g', 'd']
>>> set(Counter('aaaffereffswfwgffdfsdf'))
{'r', 'd', 's', 'e', 'f', 'g', 'a', 'w'}
>>> dict(Counter('aaaffereffswfwgffdfsdf'))
{'a': 3, 'f': 9, 'e': 2, 'r': 1, 's': 2, 'w': 2, 'g': 1, 'd': 2}
>>> c.items()
dict_items([('a', 3), ('f', 9), ('e', 2), ('r', 1), ('s', 2), ('w', 2), ('g', 1), ('d', 2)])

> elements ()
Counterオブジェクトを生成した後、すべてのkeyを知りたい場合はelements()を使用します.

>>> c
Counter({'f': 9, 'a': 3, 'e': 2, 's': 2, 'w': 2, 'd': 2, 'r': 1, 'g': 1})
>>> c.elements()

>>> list(c.elements())
['a', 'a', 'a', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'f', 'e', 'e', 'r', 's', 's', 'w', 'w', 'g', 'd', 'd']

>  most_common ([n])
Counterオブジェクトを生成すると、キー値のペアが多すぎる場合があります.頻度が最も高いいくつかの項目だけを気にします.この方法を使用して、パラメータnは前のn個の最もよく現れるキー値のペアを表します.

>>> c
Counter({'f': 9, 'a': 3, 'e': 2, 's': 2, 'w': 2, 'd': 2, 'r': 1, 'g': 1})
>>> c.most_common(3)
[('f', 9), ('a', 3), ('e', 2)]

>>> # Find the ten most common words in Hamlet
>>> import re
>>> words = re.findall(r'\w+', open('hamlet.txt').read().lower())
>>> Counter(words).most_common(10)
[('the', 1143), ('and', 966), ('to', 762), ('of', 669), ('i', 631),
 ('you', 554),  ('a', 546), ('my', 514), ('hamlet', 471), ('in', 451)]

 
OrderedDict(dictへの拡張)
適用要件:dictのキー値ペアが「無秩序」に格納されていることを知っていますが、dictのキー値ペアを挿入の前後順に並べたい場合があります.この場合、OrderDictクラスを使用できます.
> class collections. OrderedDict ([items])
入力パラメータはitemタイプ、すなわち(key,value)からなるtupleであり、戻り値は秩序辞書である.itemsに1つのkeyが複数のvalueに対応する場合、最初に表示されたキー値ペアのみが保存され、後で無視されます.

>>> s
[('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
>>> OrderedDict(s)
OrderedDict([('red', 1), ('blue', 4)])

パラメータを持たないと、空のOrderedDictオブジェクトが作成され、辞書のようにOrderedDictにオブジェクトを追加できます.先に挿入されるキー値のペアは、後に挿入される前に配置されます.これは、秩序辞書の特徴です.

>>> a=OrderedDict()
>>> a
OrderedDict()
>>> a['red']=1
>>> a['blue']=2
>>> a
OrderedDict([('red', 1), ('blue', 2)])

OrderedDictオブジェクトをリスト、set、dictのパラメータとして、対応するタイプに変換できます.

>>> a
OrderedDict([('red', 1), ('blue', 2)])
>>> dict(a)
{'red': 1, 'blue': 2}
>>> list(a)
['red', 'blue']
>>> set(a)
{'blue', 'red'}
>>> a.items()
odict_items([('red', 1), ('blue', 2)])

 
defaultdict(dictへの拡張)
適用要件:keyが存在しない場合、dictはkeyが見つからない場合にkeyを投げ出すのではなく、list、set、int、floatなどの方法を返します.
> class collections. defaultdict ([default_factory[, ...]])
default_factoryはファクトリメソッドを表し、defaultdictを使用して辞書を作成(返す)します.辞書の値はdefault_です.factoryタイプ.一般的にdefault_factoryはlistまたはsetに設定し、listまたはsetにデータを保存します.次の例はdefault_factoryをlistに設定し、同じkeyのvalueを一緒に保存します.

>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
>>> d = defaultdict(list)
>>> for k,v in s:
	d[k].append(v)

>>> d
defaultdict(, {'red': [1, 3, 1], 'blue': [2, 4, 4]})