Python Language
辞書

構文

• mydict = {}
• mydict [k] =値
• 値= mydict [k]
• 値= mydict.get（k）
• value = mydict.get（k、 "default_value"）

パラメーター

備考

辞書の値へのアクセス

dictionary = {"Hello": 1234, "World": 5678}
print(dictionary["Hello"])

上記のコードは1234ます。

この例の文字列"Hello"はキーと呼ばれます 。これは、キーを角括弧でdictによって、 dict値を検索するために使用されます。

番号1234は、 dict定義内のそれぞれのコロンの後に表示されます。これは"Hello"がこのdict マップする 値と呼ばれます 。

存在しないキーでこのような値をKeyError例外が発生し、キャッチされない場合は実行を停止します。 KeyErrorを危険にさらすことなく値にアクセスしたい場合は、 dictionary.getメソッドを使用できます。デフォルトでは、キーが存在しない場合、メソッドはNoneを返します。ルックアップに失敗した場合はNone代わりに2番目の値を渡して返すことができます。

w = dictionary.get("whatever")
x = dictionary.get("whatever", "nuh-uh")

この例では、 wは値Noneを取得し、 xは値"nuh-uh"を取得します。

dict（）コンストラクタ

dict()コンストラクタを使用して、キーワード引数から、またはキーと値のペアを1つずつ繰り返して、または辞書とキーワード引数から辞書を作成できます。

dict(a=1, b=2, c=3)                   # {'a': 1, 'b': 2, 'c': 3}
dict([('d', 4), ('e', 5), ('f', 6)])  # {'d': 4, 'e': 5, 'f': 6}
dict([('a', 1)], b=2, c=3)            # {'a': 1, 'b': 2, 'c': 3}
dict({'a' : 1, 'b' : 2}, c=3)         # {'a': 1, 'b': 2, 'c': 3}

KeyErrorの例外を避ける

辞書を使用するときの一般的な落とし穴の1つは、存在しないキーにアクセスすることです。これは通常、 KeyError例外を発生させます

mydict = {}
mydict['not there']

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'not there'

キーエラーを回避する1つの方法は、 dict.getメソッドを使用することです。このメソッドでは、不在キーの場合に返されるデフォルト値を指定できます。

value = mydict.get(key, default_value)

存在する場合はmydict[key]を返しますが、それ以外の場合はdefault_value返します。これはmydictにkeyを追加しないことに注意してください。あなたがそのキーと値のペアを保持したいのであれば、あなたが使用する必要がありますmydict.setdefault(key, default_value)キーと値のペアを格納しません、。

mydict = {}
print(mydict)
# {}
print(mydict.get("foo", "bar"))
# bar
print(mydict)
# {}
print(mydict.setdefault("foo", "bar"))
# bar
print(mydict)
# {'foo': 'bar'}

この問題に対処する別の方法は、例外をキャッチすることです

try:
    value = mydict[key]
except KeyError:
    value = default_value

また、キーが辞書inあるかどうかを確認することもできます。

if key in mydict:
    value = mydict[key]
else:
    value = default_value

ただし、マルチスレッド環境では、チェックした後にキーを辞書から削除して、例外がスローされる可能性のある競合状態を作成する可能性があります。

別のオプションは、dictのサブクラスであるcollections.defaultdictを使用し、new_keyが与えられたときにdictに新しいエントリを作成するdefault_factoryを持つことです。

キーと値へのアクセス

辞書を扱うときは、 forループ、リストの理解、または単純なリストのいずれかで、辞書のすべてのキーと値にアクセスする必要があることがよくあります。

次のような辞書があるとします。

mydict = {
    'a': '1',
    'b': '2'
}

keys()メソッドを使用してkeys()リストを得ることができます：

print(mydict.keys())
# Python2: ['a', 'b']
# Python3: dict_keys(['b', 'a'])

代わりにvaluesのリストが必要な場合は、 values()メソッドを使用しvalues() 。

print(mydict.values())
# Python2: ['1', '2']
# Python3: dict_values(['2', '1'])

キーとそれに対応する値の両方を処理する場合は、 items()メソッドを使用できます。

print(mydict.items())
# Python2: [('a', '1'), ('b', '2')]
# Python3: dict_items([('b', '2'), ('a', '1')])

注記： dictはソートされていないため、 keys() 、 values() 、およびitems()にはソート順はありません。これらのメソッドが返す順序が気になる場合は、 sort() 、 sorted() 、 OrderedDict使用しsort() 。

Python 2/3の違い： Python 3では、これらのメソッドはリストではなく特別な繰り返し可能なオブジェクトを返します。これはPython 2 iterkeys() 、 itervalues() 、 iteritems()メソッドとiteritems()です。これらのオブジェクトは、ほとんどの場合、リストのように使用できますが、いくつかの違いがあります。詳細は、 PEP 3106を参照してください。

辞書の紹介

ディクショナリは、Pythonでのマッピングとも呼ばれるキー値ストアの例です。これにより、キーを参照して要素を格納および取得することができます。辞書はキーで参照されるため、検索は非常に高速です。主にキーによる項目の参照に使用されるため、ソートされません。

dictを作成する

辞書はさまざまな方法で開始することができます。

リテラル構文

d = {}                        # empty dict
d = {'key': 'value'}          # dict with initial values

# Also unpacking one or multiple dictionaries with the literal syntax is possible

# makes a shallow copy of otherdict
d = {**otherdict}
# also updates the shallow copy with the contents of the yetanotherdict.
d = {**otherdict, **yetanotherdict}

辞書の理解

d = {k:v for k,v in [('key', 'value',)]}

参照： 理解

組み込みクラス： dict()

d = dict()                    # emtpy dict
d = dict(key='value')         # explicit keyword arguments
d = dict([('key', 'value')])  # passing in a list of key/value pairs
# make a shallow copy of another dict (only possible if keys are only strings!)
d = dict(**otherdict)         

dictを変更する

アイテムを辞書に追加するには、値を指定して新しいキーを作成するだけです。

d['newkey'] = 42

値としてlistとdictionaryを追加することもできます：

d['new_list'] = [1, 2, 3]
d['new_dict'] = {'nested_dict': 1}

アイテムを削除するには、辞書からキーを削除します。

del d['newkey']

デフォルト値を持つ辞書

defaultdictとして標準ライブラリで利用可能

from collections import defaultdict

d = defaultdict(int)
d['key']                         # 0
d['key'] = 5
d['key']                         # 5

d = defaultdict(lambda: 'empty')
d['key']                         # 'empty'
d['key'] = 'full'
d['key']                         # 'full'

[*] using dict.setdefault()を使用すると、組み込みのdictクラスを使用する必要がある場合、前に存在しなかったキーにアクセスするたびにデフォルトを作成することができます。

>>> d = {}
{}
>>> d.setdefault('Another_key', []).append("This worked!")
>>> d
{'Another_key': ['This worked!']}

追加する値がたくさんある場合、 dict.setdefault()は呼び出されるたびに初期値（この例では[] ）の新しいインスタンスを作成し、不要なワークロードを作成する可能性があることにdict.setdefault() 。

[*] David BeazleyとBrian K. Jones（O'Reilly）によるPython Cookbook、第3版。 Copyright 2013 David Beazley and Brian Jones、978-1-449-34037-7。

順序付き辞書の作成

ディクショナリ内のキーを反復処理するときに、決定された順序に従う順序付き辞書を作成できます。

collectionsモジュールからOrderedDictを使用します。これは、繰り返し処理されたときに元の挿入オーダーの辞書要素を常に返します。

from collections import OrderedDict

d = OrderedDict()
d['first'] = 1
d['second'] = 2
d['third'] = 3
d['last'] = 4

# Outputs "first 1", "second 2", "third 3", "last 4"
for key in d:
    print(key, d[key])

**演算子を使用して辞書を展開する

**キーワード引数アンパック演算子を使用すると、辞書のキーと値のペアを関数の引数に渡すことができます。 公式文書の簡単な例：

>>>
>>> def parrot(voltage, state, action):
...     print("This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)

This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

Python 3.5では、この構文を使用して任意の数のdictオブジェクトをマージすることもできます。

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
>>> fishdog = {**fish, **dog}
>>> fishdog

{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

この例で示すように、重複キーは最後の値にマッピングされます（たとえば、「Clifford」は「Nemo」を上書きします）。

辞書をマージする

以下の辞書を考えてみましょう。

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}

Python 3.5以降

>>> fishdog = {**fish, **dog}
>>> fishdog
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

この例で示すように、重複キーは最後の値にマッピングされます（たとえば、「Clifford」は「Nemo」を上書きします）。

Python 3.3以降

>>> from collections import ChainMap
>>> dict(ChainMap(fish, dog))
{'hands': 'fins', 'color': 'red', 'special': 'gills', 'name': 'Nemo'}

この手法では、最後の値（ "Clifford"が "Nemo"のために捨てられます）ではなく、指定されたキーに先行する値が優先されます。

Python 2.x、3.x

>>> from itertools import chain
>>> dict(chain(fish.items(), dog.items()))
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

これは、マージのための**ベースのテクニック（ "Clifford"が "Nemo"を上書きする）のように、最後の値を使用します。

>>> fish.update(dog)
>>> fish
{'color': 'red', 'hands': 'paws', 'name': 'Clifford', 'special': 'gills'}

dict.updateは後者のdictを使用して前のdictを上書きします。

末尾のカンマ

リストやタプルのように、後にカンマを辞書に含めることができます。

role = {"By day": "A typical programmer",
        "By night": "Still a typical programmer", }

PEP 8では、末尾のカンマと閉じた中かっこの間にスペースを入れておく必要があります。

辞書値のすべての組み合わせ

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]
}

上記のような辞書があれば、対応するキーを調べるために値の集合を表すリストがあります。 "x"="a" "y"=10 、次に"x"="a" "y"=10 、すべての可能な組み合わせを探索するまで探索したいとします。

次のコードを使用して、そのような値の組み合わせをすべて返すリストを作成できます。

import itertools

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]}

keys = options.keys()
values = (options[key] for key in keys)
combinations = [dict(zip(keys, combination)) for combination in itertools.product(*values)]
print combinations

これにより、変数のcombinations格納されている以下のリストが得られます。

[{'x': 'a', 'y': 10},
 {'x': 'b', 'y': 10},
 {'x': 'a', 'y': 20},
 {'x': 'b', 'y': 20},
 {'x': 'a', 'y': 30},
 {'x': 'b', 'y': 30}]

辞書の繰り返し

辞書をイテレータとして使用する場合（ forステートメントなど）、辞書のキーを横断します 。例えば：

d = {'a': 1, 'b': 2, 'c':3}
for key in d:
    print(key, d[key])
# c 3
# b 2
# a 1

理解しても同じことが言えます

print([key for key in d])
# ['c', 'b', 'a']

for key, value in d.items():
    print(key, value)
# c 3
# b 2
# a 1

for key, value in d.values():
    print(key, value)
    # 3
    # 2
    # 1

辞書の作成

辞書を作成するためのルール：

• すべてのキーは一意でなければなりません（そうでない場合はオーバーライドされます）
• すべてのキーハッシュ可能でなければなりませんが（使用できるhashそれをハッシュする機能を、そうでない場合TypeErrorスローされます）
• キーの順序は特にありません。

# Creating and populating it with values
stock = {'eggs': 5, 'milk': 2}

# Or creating an empty dictionary
dictionary = {}

# And populating it after
dictionary['eggs'] = 5
dictionary['milk'] = 2

# Values can also be lists
mydict = {'a': [1, 2, 3], 'b': ['one', 'two', 'three']}

# Use list.append() method to add new elements to the values list
mydict['a'].append(4)   # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three']}
mydict['b'].append('four')  # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three', 'four']}

# We can also create a dictionary using a list of two-items tuples
iterable = [('eggs', 5), ('milk', 2)]
dictionary = dict(iterables)

# Or using keyword argument:
dictionary = dict(eggs=5, milk=2)

# Another way will be to use the dict.fromkeys:
dictionary = dict.fromkeys((milk, eggs))  # => {'milk': None, 'eggs': None}
dictionary = dict.fromkeys((milk, eggs), (2, 5))  # => {'milk': 2, 'eggs': 5}

辞書の例

辞書はキーを値にマップします。

car = {}
car["wheels"] = 4
car["color"] = "Red"
car["model"] = "Corvette"

ディクショナリ値は、キーでアクセスできます。

print "Little " + car["color"] + " " + car["model"] + "!"
# This would print out "Little Red Corvette!"    

辞書は、JSON形式で作成することもできます。

car = {"wheels": 4, "color": "Red", "model": "Corvette"}

ディクショナリ値は次のように繰り返し処理できます。

for key in car:
  print key + ": " + car[key]

# wheels: 4
# color: Red
# model: Corvette