重要度：★★★★★
シリーズ「Pythonプログラミングの始め方」ではPythonの基礎文法を図を用いて分かりやすく解説していきます。
今回は、この「辞書(Dictionary)」について「データ構造の基本」から「作り方(定義方法)」「要素へのアクセス(参照・取得・更新)」「辞書型の関数」について基礎から丁寧に図解で解説をします。
この記事を読むことで次のことが「できる・わかる」ようになりますので最後までお付き合い下さい。
本サイトでの紹介内容例は一例です。また、関数などの省略可能なオプション引数などについては割愛していますので、詳細や不明点などは必要に応じて公式サイトなどを参照してください。
【Python公式ドキュメント】https://docs.python.org/ja/3/library/stdtypes.html#mapping-types-dict
1. 辞書型(Dictionary)とは
Pythonのデータ型である「辞書型」(dictionary)は「リスト」や「タプル」と同じように複数の値を要素として管理するデータ構造の一つです。
「リスト」や「タプル」は、個々の要素を並び順（インデックス）で管理していますが、辞書の場合は「キー(Key)」と呼ばれる識別子(ラベル)が割り振られ、個々の要素を管理します。
辞書の書式は、以下のように｛｝の中に「キー(Key)：値(Value)」を組合せた要素をもつ構造をとります。要素(値)へのアクセスは、キーを使って参照するので一つの辞書の中に同じキーを重複して持たせることはできません。よって、リストやタプルのように要素の位置を意識することはありません。
また「キー(Key)」は後から変更できない性質上、イミュータブルな型をもつデータを採ります。「文字列」や「数値」「タプル」などのデータがキーになり得ます。一方、値については、イミュータブルなデータ型の他、リストや辞書といったミュータブルなデータ型を採ることができます。(図3)
1.1. 辞書の基本操作について
辞書型のデータ構造を実際にコードで確認してみましょう。次の<List1>は基本的な辞書の作成例として、「キー」にイミュータブルなオブジェクトである「文字列(➀)」「数値(➁)」「タプル(➂)」を指定しています。問題なく辞書が作成できています。
dict1 = {'a':1, 'b':2, 'c':3} # キーに文字列を指定
dict2 = {10:'apple', 20:'orange', 30:'pine'} # キーに数字を指定
dict3 = {(1, 2, 3):'apple'} # キーにタプル（イミュータブル）を指定
# キーには、イミュータブルなオブジェクトを指定する
print(dict1) # ➀>> {'a': 1, 'b': 2, 'c': 3}
print(type(dict1)) # >> <class 'dict'>
print(dict2) # ➁>> {10: 'apple', 20: 'orange', 30: 'pine'}
print(type(dict2)) # >> <class 'dict'>
print(dict3) # ➂>> {(1, 2, 3): 'apple'}
print(type(dict3)) # >> <class 'dict'>
「キー」にはイミュータブルなオブジェクトを指定する
➀ 》{‘a‘: 1, ‘b‘: 2, ‘c‘: 3} # 文字(列)
➁ 》{10: ‘apple’, 20: ‘orange’, 30: ‘pine’} # 数値
➂ 》{(1, 2, 3): ‘apple’} # タプル
今度は「キー」にミュータブルなオブジェクトである「リスト」を指定した場合の例を示します。(➃)<List2>「キー」はイミュータブルなオブジェクトしか指定できませんので次のように「TypeError」が発生して辞書を作成することはできません。
dict4 = {[1,2,3]:'apple'} # キーがリスト(ミュータブル)
# キーは、ミュータブルなオブジェクトを採ることができない
print(dict4) # ➃>> TypeError: unhashable type: 'list'「キー」にはミュータブルなオブジェクトは指定できない
➃ 》TypeError: unhashable type: ‘list’
「キー」の値が重複することは許することは許されません。例えば、次のように同じ「キー」をもつ辞書を定義しようとするとエラーになることはありませんが、最後に指定した「キー」の値が最終的にその辞書の要素となります。(➄)
dict6 = {'a':1, 'a':2, 'b':3, 'b':4} # キーを重複してオブジェクトをつくる
# キーを重複指定した場合は、最後に指定した値が反映される
print(dict6) # ➄>> {'a': 2, 'b': 4}
print(type(dict6)) # >> <class 'dict'>キーを重複指定した場合は、最後に指定した値が反映される
➄ 》{‘a’: 2, ‘b’: 4}
また、辞書の要素にアクセスする(値を取得する)には、“[キー]”のようにキーをインデックスにして対となる値にアクセスします。存在しないキーに対してアクセスを試みた場合は、「KeyError」が発生します。
dict7 = { 'key1' : 1, 'key2' : 2, 'key3' : 3 }
# 値にアクセスするには、キーをインデックス指定する
print(dict7['key1']) # ➅>> 1
print(dict7['key2']) # ➆>> 2
# 存在しないキーに対してアクセスを試みるとエラーが発生する
print(dict7['key4']) # ➇>> KeyError値にアクセスするには、キーをインデックス指定する
➅ 》1
➆ 》2
存在しないキーに対してアクセスを試みるとエラーが発生する
➇ 》KeyError
1.2 辞書の要素の更新と追加について
辞書は、ミュータブルなオブジェクトですので、後から要素を「更新」したり「追加」することができます。
書式は次のように「辞書オブジェクト」に”キー(key)”をインデックス指定して、”新しい値(value)”を設定することで対応します。
指定した“キー”が既に存在していれば、“新しい値”で書き換えられます。(更新)
存在していなければ、新しい要素として「“キー”：“新しい値”」が追加されることになります。
辞書オブジェクト[ キー ] = 新しい値
- 指定した「キー」が既に存在していれば、新しい値で書き換える(更新)
- 指定した「キー」が存在していなければ、新しい要素(キー：値)として(追加)する
辞書の「更新」「追加」について具体例で確認します。
例１．既存の辞書オブジェクトに対して要素を更新します。<List5>
更新したい「キー」をインデックス指定して、新たな値で書き換えます。(➁’key1’を1→10へ更新, ➂’key3’を3→30へ更新しています。)
dict1 = { 'key1' : 1, 'key2' : 2, 'key3' : 3 }
print(dict1) # ➀>> {'key1': 1, 'key2': 2, 'key3': 3}
# キー(key1)の値を10に更新する
dict1['key1'] = 10
print(dict1) # ➁>> {'key1': 10, 'key2': 2, 'key3': 3}
# キー(key3)の値を30に更新する
dict1['key3'] = 30
print(dict1) # ➂>> {'key1': 10, 'key2': 2, 'key3': 30}➀ 》{‘key1’: 1, ‘key2’: 2, ‘key3’: 3}
キー(key1)の値を10に更新された
➁ 》{‘key1’: 10, ‘key2’: 2, ‘key3’: 3}
キー(key3)の値を30に更新された
➂ 》{‘key1’: 10, ‘key2’: 2, ‘key3’: 30}
例2. 既存の辞書オブジェクトに対して要素を追加します。<List6>
追加したい、新規「キー」をインデックスに指定して、新たな値とともに新要素として追加します。
(➃新要素 「’key4’:40」 を追加しています。)
# キー(key4)の要素を追加する
dict1['key4'] = 40
print(dict1) # ➃ {'key1': 10, 'key2': 2, 'key3': 30, 'key4': 40}キー(key4)の要素を末尾に追加する
➃ 》{‘key1’: 10, ‘key2’: 2, ‘key3’: 30, ‘key4’: 40}
1.2.1 辞書の追加・更新に関するメソッド
追加と更新に関して、辞書オブジェクトには２つの関数が用意されています。
１つは setdefault()メソッド で、辞書オブジェクトに「キー」で指定した要素が存在しなければその要素を追加しますが、すでに存在した場合は置き換えません。つまり、値の上書きを防ぐことができます。
そして2つ目は update()メソッド で2つの辞書をマージし、既存の要素を更新します。書式は次のとおりです。図4 辞書の更新と追加に関するメソッド
辞書オブジェクト.setdefault(key, value)
引数: key:追加したい「キー」を指定する
引数: value:追加したい「値」を指定する 省略可能(省略した場合は値が‘None’の要素となる)
戻り値: 現在のキーの値
辞書オブジェクト.update(dict)
引数: dict:更新用の辞書
戻り値: なし (元の辞書オブジェクト自体を更新)
例1. setdefault()メソッド の使用例を示します。<List7>
次の例では、既存のキー(‘key1’)に対しては、値を更新しません (上書きしない)(➀)が、辞書に存在しないキー(‘key4’)の場合は、新規要素が追加されます。(➁)
また、setdefault()メソッドの第2引数を省略した場合は、値が’None’として要素が追加されます。(➂)
# setdefault()メソッドの使い方
dict1 = { 'key1' : 1, 'key2' : 2, 'key3' : 3 }
print(dict1) # {'key1': 1, 'key2': 2, 'key3': 3}
#------------------------------------------------------------
# 既に存在しているキーに対しては、更新させない
dict1.setdefault('key1', 10)
print(dict1) # ➀>> {'key1': 1, 'key2': 2, 'key3': 3}
# 存在していないキーに対しては、新規要素が追加される
dict1.setdefault('key4', 40)
print(dict1) # ➁>> {'key1': 1, 'key2': 2, 'key3': 3, 'key4': 40}
# 第2引数(value)を省略した場合は、値には'None'が入る
dict1.setdefault('key5')
print(dict1) # ➂>> {'key1': 1, 'key2': 2, 'key3': 3, 'key4': 40, 'key5': None}
setdefault()メソッドの使い方
既に存在しているキーに対しては、更新させない
➀ 》{‘key1’: 1, ‘key2’: 2, ‘key3’: 3}
存在していないキーに対しては、新規要素が追加される
➁ 》{‘key1’: 1, ‘key2’: 2, ‘key3’: 3, ‘key4’: 40}
第2引数(value)を省略した場合は、値には’None’が入る
➂ 》{‘key1’: 1, ‘key2’: 2, ‘key3’: 3, ‘key4’: 40, ‘key5’: None}
例2. update()メソッド の使用例を示します。<List8>
次の例では、辞書(dict1(➃))を辞書(dict2(➄))でアップデート(更新)します。既存のキーの値を更新し、キーが存在しない場合は要素ごと追加します。
結果は、’key1’の要素が1→10へ更新され、’key4’の要素が追加されました。(➅)
# update()メソッドの使い方
dict1 = { 'key1' : 1, 'key2' : 2, 'key3' : 3 }
print(dict1) # ➃>> {'key1': 1, 'key2': 2, 'key3': 3}
dict2 = { 'key1' : 10, 'key4' : 40 }
print(dict2) # ➄>> {'key1': 10, 'key4': 40}
#------------------------------------------------------------
# update()メソッドで、dict1 を dict2 でアップデート(更新)する
dict1.update(dict2)
print(dict1) # ➅>> {'key1': 10, 'key2': 2, 'key3': 3, 'key4': 40}
# update()メソッドは戻り値は返しません(dict1そのものを更新します)
result = dict1.update(dict2)
print(result) # ➆>> None
update()メソッドの使い方
➄ 》{‘key1’: 1, ‘key2’: 2, ‘key3’: 3}
➅ 》{‘key1’: 10, ‘key4’: 40}
update()メソッドで、dict1をdict2 でアップデート(更新)する
➆ 》{‘key1’: 10, ‘key2’: 2, ‘key3’: 3, ‘key4’: 40}
update()メソッドは戻り値は返しません(dict1そのものを更新します)
➇ 》None
なお、update()メソッド は戻り値を返さず、元の辞書そのものを更新します。よって、➇のように変数resultは‘None’となります。
1.3 辞書の要素を削除する
辞書は不要になった要素を削除することができます。要素を指定して削除する「delステートメント」と一度にすべての要素を削除できる「clear()メソッド」があります。書式は以下の通りです。
<指定した要素を削除する>
del 辞書オブジェクト[key]
インデクス: key: 削除する要素のキーを指定
<すべての要素を削除する>
辞書オブジェクト.clear()
引数: なし
辞書の要素を削除する具体例を紹介します。
例1. delステートメントで特定の要素を削除する。<List9>
次の例では、キー(‘key1’)とキー(’key2’)をインデックス指定して delステートメント で該当する要素を削除しています。(➁,➂)
# delステートメント
dict1 = { 'key1' : 1, 'key2' : 2, 'key3' : 3 }
print(dict1) # ➀>> {'key1': 1, 'key2': 2, 'key3': 3}
# キー(key1)に対応する要素を削除する
del dict1['key1']
print(dict1) # ➁>> {'key2': 2, 'key3': 3}
# キー(key2)に対応する要素を削除する
del dict1['key2']
print(dict1) # ➂>> {'key3': 3}delステートメントの使い方
➀ 》{‘key1’: 1, ‘key2’: 2, ‘key3’: 3}
キー(key1)に対応する要素を削除する
➁ 》{‘key2’: 2, ‘key3’: 3}
キー(key2)に対応する要素を削除する
➂ 》{‘key3’: 3}
また、存在しない「キー」に対して削除を行おうとするとエラーが発生します。次の例では削除済みのキー(‘key1’)を指定してdelステートメントを実行していますが、“KeyError”が発生しています。(➃)
# 存在しない、キーを指定して削除しようとした場合はエラーとなる
del dict1['key1'] # ➃>> KeyError: 'key1'存在しない、キーを指定して削除しようとした場合はエラーとなる
➃ 》KeyError
例2. 辞書オブジェクトの「clear()メソッド」を使うことで、すべての要素を一度に削除することも可能です。(➅)
# clearメソッドの使い方
dict2 = { 'key1' : 1, 'key2' : 2, 'key3' : 3 }
print(dict2) # ➄>> {'key1': 1, 'key2': 2, 'key3': 3}
# clear()メソッドで、全ての要素を削除する
dict2.clear()
print(dict2) # ➅>> {} 空の辞書が残るclearメソッドの使い方
全ての要素を削除する(空の辞書となる)
➅ 》{}
以上が、辞書の基本操作(新規作成・要素の追加/更新)についての解説となります。次節からは、より効率的に辞書を作成することができる「dict()クラス」について解説してきます。
2. 辞書をつくるdictクラス
<1節>では、辞書オブジェクトは｛キー(Key)：値(Value)｝の形式で作成することができると解説しました。Pythonには辞書を作成するための組込みクラスとして「dictクラス」が関連メソッドとともに用意されており、効率的に辞書を作成することもできます。
本節では、dictクラスの活用方法について解説します。
2.1 dictクラスの基本操作
dictクラス の 引数:**kwargには任意の数の引数を指定することができます。引数の書式は次の書式のように、イテラブルなオブジェクト(タプル、リスト、辞書※)やキーワード引数を指定して使います。「イテラブルなオブジェクト」と「キーワード引数」は組み合わせることも可能です。
それぞれの書式について、具体例で確認します。
例1. タプル(キー, 値)を要素とするリストを引数に指定するパターンです。<List12>
タプルのリストを返す、標準関数 zip() を活用すれば、2つのリストから効率的に辞書を生成することができます。(➂)
# dictクラスの使い方
# 引数に「タプルを要素とするリスト」を設定した場合
dict1 = dict( [ ('key1', 111), ('key2', 222), ('key3', 333) ] )
print(dict1) # ➀>> {{'key1': 111, 'key2': 222, 'key3': 333}
print(type(dict1)) # ➁>>> <class 'dict'>
# zip関数で「タプルを要素とするリスト」を生成した場合
keys = ['Key1', 'Key2', 'Key3']
vals = [111, 222, 333]
dict2 = dict(zip(keys, vals))
print(dict2) # ➂>> {'Key1': 111, 'Key2': 222, 'Key3': 333}
print(type(dict2)) # ➃>> <class 'dict'>dictクラスの使い方(1)
引数に「タプルを要素とするリスト」を設定した場合
➀ 》{‘key1’: 111, ‘key2’: 222, ‘key3’: 333}
➁ 》＜class ‘dict＞
zip関数 で「タプルを要素とするリスト」を生成した場合
➂ 》{‘key1’: 111, ‘key2’: 222, ‘key3’: 333}
➃ 》＜class ‘dict＞
例２.リスト[キー, 値]を要素とするタプルを引数に指定するパターンです。<List13>
# dictクラスの使い方(2)
# 引数に「リストを要素とするタプルを設定した場合
dict3 = dict( ( ['key1', 111], ['key2', 222], ['key3', 333] ) )
print(dict3) # ➄>> {'key1': 111, 'key2': 222, 'key3': 333}
print(type(result)) # ➅>> <class 'dict'>dictクラスの使い方(2)
引数に「リストを要素とするタプルを設定した場合
➄ 》{‘key1’: 111, ‘key2’: 222, ‘key3’: 333}
➅ 》＜class ‘dict＞
例3. キーワード引数で指定するパターンです。<List14>
キーワードは、文字列で指定してはいけません。辞書を生成する際に、キーワードが文字列として「キー」に登録されます。なお、キーワードを文字列で指定した場合は「SyntaxError」が発生します。(➈)
# dictクラスの使い方(3)
# 引数にキーワード引数(キー = 値)を設定した場合
dict4 = dict( key1 = 111, key2 = 222, key3 = 333 )
print(dict4) # ➆>> {'key1': 111, 'key2': 222, 'key3': 333}
print(type(dict4)) # ➇>> <class 'dict'>
# キーワード引数のキーに文字列("")を設定した場合
dict5 = dict( 'key1' = 111, 'key2' = 222, 'key3' = 333 )
# ➈>> SyntaxError: keyword can't be an expressiondictクラスの使い方(3)
引数にキーワード引数(キー = 値)を設定した場合
➆ 》{‘key1’: 111, ‘key2’: 222, ‘key3’: 333}
➇ 》＜class ‘dict＞
キーワード引数のキーに文字列(“”)を設定した場合
➈ 》SyntaxError: keyword can’t be an expression
例4. 引数にはイテラブルなオブジェクトとキーワード引数による指定を混在させることができます。
(➈,➉)ただし、キーワード引数はを先頭に置くことはできず、「SyntaxError」が発生します。(⑪)
# dictクラスの使い方(4)
# イテラブルなオブジェクトとキーワード引数を混在させた場合
dict6 = dict( [('key1', 111), ('key2', 222)], key3 = 333 )
print(dict6) # ➈>> {'key1': 111, 'key2': 222, 'key3': 333}
dict7 = dict( (['key1', 111], ['key2', 222]), key3 = 333 )
print(dict6) # ➉>> {'key1': 111, 'key2': 222, 'key3': 333}
# キーワード引数は、先頭に配置できないので、エラーが発生する
dict8 = dict( key3 = 333, [('key1', 111), ('key2', 222)] )
print(dict8) # ⑪>> SyntaxError: positional argument follows keyword argumentdictクラスの使い方(4)
イテラブルなオブジェクトとキーワード引数を混在させた場合
➈ 》{‘key1’: 111, ‘key2’: 222, ‘key3’: 333}
➉ 》{‘key1’: 111, ‘key2’: 222, ‘key3’: 333}
キーワード引数は、先頭に配置できないので、エラーが発生する
⑪ 》SyntaxError: positional argument follows keyword argument
2.2 dictクラスの「fromkeysメソッド」
dictクラス は、引数に「キー」と「値」の組合せを指定して辞書オブジェクトを生成するのでした。「dictクラス」には「キー」のみを指定して効率的に辞書を生成できる「fromkeysメソッド」というものもあります。(値もデフォルト(初期値)値として設定できます)
「fromkeysメソッド」の書式は次の通りです。
dict.fromkeys(iterable, value)
引数: iterable:「キー」とするイテラブルなオブジェクト(リストやタプルなど)
引数: value:「値」の初期値を指定する ※省略可能(省略した場合は’Nane’が設定される)
戻り値: 辞書オブジェクト
dictクラスの「fromkeysメソッド」の使用例を紹介します。
第1引数: iterable に「リスト」と「タプル」を指定して辞書の「キー」とする例です。第2引数: value には、初期値を設定します。
各オブジェクトの要素が展開されそれぞれを「キー」とし、123を初期値とする辞書が生成されました。(➀,➁)
# fromkeys()メソッドの使い方(1)
# 引数:iterableに"リスト"を指定して、「キー」として展開した場合
dict1 = dict.fromkeys( ['key1', 'key2', 'key3'], 123 )
print(dict1) # ➀>> {'key1': 123, 'key2': 123, 'key3': 123}
# 引数:iterableに"タプル"を指定して、「キー」として展開した場合
dict2 = dict.fromkeys( ('key1', 'key2', 'key3'), 123 )
print(dict2) # ➁>> {'key1': 123, 'key2': 123, 'key3': 123}fromkeys()メソッドの使い方(1)
引数:iterable に”リスト”を指定して、「キー」として展開した場合
➀ 》{‘key1’: 123, ‘key2’: 123, ‘key3’: 123}
引数:iterable に“タプル”を指定して、「キー」として展開した場合
➁ 》{‘key1’: 123, ‘key2’: 123, ‘key3’: 123}
引数:iterable には「文字列」を指定することもできます。文字列が各文字に展開されて「キー」となります。次は、“ABCD”の各文字を「キー」とする、初期値なし(‘None’)とした場合の例です。(➂)
# fromkeys()メソッドの使い方(2)
# 引数:iterableに"文字列"を指定して、各文字を「キー」として展開する
# 引数:valueを省略した場合
dict3 = dict.fromkeys( 'ABCD' )
print(dict3) # ➂>> {'A': None, 'B': None, 'C': None, 'D': None}fromkeys()メソッドの使い方(2)
引数:iterable に”文字列”を指定して、各文字を「キー」として展開する
引数:value を省略した場合は値がNoneとなる
➂ 》{‘A’: None, ‘B’: None, ‘C’: None, ‘D’: None}
3. 辞書オブジェクトの関連メソッド
辞書オブジェクトには、要素(キーや値)を「取得する」ものであったり、「複製」や「抜き取る」といった関連メソッドがあります。本節では、辞書を使いこなす上で知っておきたい必須メソッドの活用事例を示しています。
3.1 要素(キー, 値)を取得する「keys/values/itemsメソッド」
辞書の要素を取得するメソッドに「keys()メソッド」「values()メソッド」「items()メソッド」があります。それぞれ、辞書オブジェクト内のすべての「キー」「値」「要素(キー, 値)」を取得することができます。ただし、図〇のようにこれらのメソッドの戻り値は「dict_keys型」「dict_value型」「dict_item型」とやや特殊なオブジェクト型となります。
いずれもイテラブルなオブジェクトなので、これらを単独で利用するというよりかは、通常「For文句」や「内包表記」とともに使われることが多い印象です。
<List18>の➆では、「For文句」で各要素に展開していますし、➇➈では内包表記により、リスト(List)に変換しています。
# keys,values,itemsメソッドの使い方
dict1 = {'key1':1,'key2':2,'key3':3}
# 辞書オブジェクトの「keys()メソッド」による「キー」の取得
print(dict1.keys()) # ➀>> dict_keys(['key1', 'key2', 'key3'])
print(type(dict1.keys())) # ➁>> <class 'dict_keys'>
# 辞書オブジェクトの「values()メソッド」による「値」の取得
print(dict1.values()) # ➂>> dict_values([1, 2, 3])
print(type(dict1.values())) # ➃>> <class 'dict_values'>
# 辞書オブジェクトの「values()メソッド」による「値」の取得
print(dict1.items()) # ➄>> dict_items([('key1', 1), ('key2', 2), ('key3', 3)])
print(type(dict1.items())) # ➅>> <class 'dict_items'>
# For文句による展開
for key, item in dict1.items():
print(f"key: {key}, item: {item}")
# ➆_1>> key: key1, item: 1
# ➆_2>> key: key2, item: 2
# ➆_3>> key: key3, item: 3
# 内包表記による展開
print([key for key, item in dict1.items() ]) # ➇>> ['key1', 'key2', 'key3']
print([[key, item * 2] for key, item in dict1.items()]) # ➈>> [['key1', 2], ['key2', 4], ['key3', 6]]keys,values,itemsメソッドの使い方
➀ 》dict_keys([‘key1’, ‘key2’, ‘key3’])
➂ 》dict_values([1, 2, 3])
➄ 》dict_items([(‘key1’, 1), (‘key2’, 2), (‘key3’, 3)])
For文句による展開
➆_1》key: key1, item: 1
➆_2》key: key2, item: 2
➆_3》key: key3, item: 3
内包表記による展開
➇ 》[‘key1’, ‘key2’, ‘key3’]
➈ 》[[‘key1’, 2], [‘key2’, 4], [‘key3’, 6]]
なお「dict_keys型」「dict_value型」「dict_item型」は、Pythonの標準関数である「list()」や「len()」で処理することもできます。特に「dict_value型」は「max()/min()/sum()」などといった演算処理も可能です。
内包表記については、こちらの記事も参考にして下さい。
3.2 複製と要素の抜き取り(copy/pop/popitem)
辞書オブジェクトの複製(コピー)は「copy()メソッド」を使います。この複製は複製はいわゆる「深いコピー」のことで、メモリ上の実体(オブジェクト)ごとコピーすることを指します。このことは、複製元と複製先の辞書とは互いに干渉し合うことはありません。
図8の左図のように単なる「ラベル」の差し替えではないことに注意しましょう。
複製を行う copy()メソッド は次の書式のとおりで、引数はありません。
copy()メソッド の具体例を<List19>に示します。ポイントは「オブジェクト(➁)」自体の複製であること「複製元と複製先とは互いに干渉しないこと(➂➃)」です。
# copyメソッドの使い方
dict1 = {'key1':1,'key2':2,'key3':3}
# 辞書オブジェクトの copy()メソッドで「深いコピー」を行う
dict2 = dict1.copy()
print(dict2) # ➀>> {'key1': 1, 'key2': 2, 'key3': 3}
# dict1 と dict2 は別のオブジェクト
print(dict1 is dict2) # ➁>> False
# 複製先の要素を変更しても、複製元の要素に影響しない。
dict2['key2'] = 10
print(dict1) # ➂>> {'key1': 1, 'key2': 2, 'key3': 3}
print(dict2) # ➃>> {'key1': 1, 'key2': 10, 'key3': 3}copyメソッドの使い方
辞書オブジェクトの copy()メソッド で「深いコピー」を行う
➀ 》{‘key1’: 1, ‘key2’: 2, ‘key3’: 3}
dict1 と dict2 は別のオブジェクト
➁ 》False
複製先の要素を変更しても、複製元の要素に影響しない
➂ 》{‘key1’: 1, ‘key2’: 2, ‘key3’: 3}
➃ 》{‘key1’: 1, ‘key2’: 10, ‘key3’: 3}
辞書オブジェクトから特定の要素を抜き取るには、「pop()メソッド」とpopitem()メソッド」にて行います。抜き取りは、対象要素(値)の「取得」と「削除(1.3項)」を同時に行うことを指します。
図9のように「pop()メソッド」は、抜き取る要素の「キー」を引数で指定することができます。一方「popitem()メソッド」は、つねに末尾の要素を対象に抜き取る(LIFO[Last In First Out])といった違いがあります。
両メソッドの書式は以下の通りです。「pop()メソッド」について 引数:value は 引数:key の要素が存在しないときに戻す値を指定することができます。
もし、指定した要素がなく 引数:value を設定していない場合は、エラー(‘KeyError’)が発生します。
「pop()メソッド」の具体例を<List21>に示します。pop()を繰り返すごとに値を取得した後に、対象の要素がオブジェクトが削除されます。(➄~➇)また 引数:key を省略することはできません。(➉)
dict1 = {'key1':1,'key2':2,'key3':3,'key4':4 }
# 辞書オブジェクトのpop()メソッドで特定の要素を抜き取る
dict1.pop('key2') # ➄ 2
print(dict1) # ➅ {'key1': 1, 'key3': 3, 'key4': 4}
dict1.pop('key3') # ➆ 3
print(dict1) # ➇ {'key1': 1, 'key4': 4}
# 存在しない、要素を抜き取ろうとするとエラーが発生する
dict1.pop('key3') # ➈ KeyError
# 引数を省略することはできない
dict1.pop() # ➉ TypeError: pop expected at least 1 arguments, got 0次に、「popitem()メソッド」の具体例を<List22>に示します。popitem()を繰り返すごとに、末尾の要素の値を戻し、オブジェクトから要素をさ削除となり＜FILO型のスタック＞動作となります。よって、⑭のように引数を指定するとエラーが発呼されます。
dict1 = {'key1':1,'key2':2,'key3':3,'key4':4 }
# 辞書オブジェクトのpopitem()メソッドで特定の要素を抜き取る
dict1.popitem() # ⑪ ('key4', 4)
dict1.popitem() # ⑫ ('key3', 3)
print(dict1) # ⑬ {'key1': 1, 'key2': 2}
# 引数を指定することはできない
dict1.popitem('key1') # ⑭ TypeError: popitem() takes no arguments (1 given)以上、辞書オブジェクトの関連メソッドとして、よく使われるものを厳選して紹介しました。これ以外にも「get()メソッド」や「reversed()関数」などの機能が提供されていますので確認してみてください。
4. まとめ
いかがでしたでしょうか。
今回は、Pythonのデータ構造の一つである「辞書(dict)」について、「基本操作」から「各種メソッド(関数)の使い方」について解説をしてきました。最後に記事内容を整理しておきたいと思います。
辞書は「リスト」とともにPythonではよく使われるデータ構図ですが、リストとは次の点で違いや特徴があります。
- キーと値の組合わせ({キー：値, …})で一つの要素を形成する
- 要素の並び順を意識することはない(キーを識別子として各要素にアクセスする)
- 同じキーを重複してもたせることはできない(値は重複できる)
このことは、他言語(特にC言語)で強く意識する必要がある「アドレス空間(ポインタ)」をもたないPythonにとって「キー」の指定により、配列要素(※)にアクセスできる「辞書(連想配列)」はその代用となり得えます。※厳密には、配列ではありません。
また、機械学習で使われることが多いPythonにとって学習(教師)データを、正解ラベルとともに管理できる「辞書」のようなデータ構造はよく使われます。
是非、今回の記事をお役立てくださいますと幸いです。
最後までお読みいただきありがとうございました。