Python辞書（dict）の使い方｜全メソッド一覧と実務パターンを実行結果で解説

Pythonの辞書（dict）とは、「キー」と「値」をペアで保存し、キーを使って値をすばやく取り出せるデータ型です。 {"pen": 120, "note": 45} のように波かっこで書き、stock["pen"] で 120 を取り出せます。

この記事では、辞書のすべてのメソッドと演算子を「コード→実行結果」の形で一覧にし、さらに実務でよく書く処理（KeyErrorの避け方、集計、グループ化、ソート、マージ、JSON変換、コピー）をコピペで使える形にまとめました。出力はすべて Python 3.14.7 で実際に実行した結果 です。dict.fromkeys の落とし穴や、ループ中に削除したときの RuntimeError など、つまずきやすい点も実際のエラー文で確認できます。

Python辞書の早見表

辞書の基本：作る・取り出す・追加・削除

stock = {"pen": 120, "note": 45}
print(stock["pen"])          # 取り出す
stock["clip"] = 300          # 追加
stock["note"] = 50           # 上書き
del stock["pen"]             # 削除
print(stock, len(stock), "note" in stock, "pen" in stock)

実行結果（Python 3.14.7）：

120
{'note': 50, 'clip': 300} 2 True False

追加と上書きは同じ書き方です。キーがなければ追加、あれば上書きになります。

辞書のいろいろな作り方

print(dict(pen=120, note=45))                 # キーワード引数（キーが文字列のとき）
print(dict([("pen", 120), ("note", 45)]))     # (キー, 値) のリスト
print(dict(zip(["pen", "note"], [120, 45])))  # 2つのリスト

{'pen': 120, 'note': 45}
{'pen': 120, 'note': 45}
{'pen': 120, 'note': 45}

ないキーを取り出すとKeyError

stock = {"pen": 120}
stock["eraser"]

KeyError: 'eraser'

避け方は後の「KeyErrorを避ける3つの方法」で比較します。

辞書のメソッド・演算子一覧（実行結果つき）

辞書のメソッドは11個、よく使う演算子・関数は |、|=、in、del、len です。 次のコードをまとめて実行した結果を、表に整理しました。

d = {"pen": 120, "note": 45}
print("get       :", d.get("pen"), d.get("clip"), d.get("clip", 0))
print("keys      :", d.keys())
print("values    :", d.values())
print("items     :", d.items())

d2 = d.copy(); d2.update({"note": 50, "clip": 300}); print("update    :", d2)
d2.update(tape=10); print("update(kw):", d2)

d3 = d.copy(); print("pop       :", d3.pop("pen"), d3)
print("pop既定値  :", d3.pop("xxx", None))
d4 = {"a": 1, "b": 2, "c": 3}; print("popitem   :", d4.popitem(), d4)

d5 = {"pen": 120}
print("setdefault:", d5.setdefault("pen", 0), d5.setdefault("clip", 0), d5)

d6 = d.copy(); d6.clear(); print("clear     :", d6)
print("fromkeys  :", dict.fromkeys(["a", "b", "c"], 0))
print("|         :", {"a": 1, "b": 2} | {"b": 20, "c": 3})
d7 = {"a": 1}; d7 |= {"b": 2}; print("|=        :", d7)
print("in        :", "pen" in d, 120 in d, 120 in d.values())
print("len       :", len(d))
print("list/sorted:", list(d), sorted(d))
print("reversed  :", list(reversed(d)))

get       : 120 None 0
keys      : dict_keys(['pen', 'note'])
values    : dict_values([120, 45])
items     : dict_items([('pen', 120), ('note', 45)])
update    : {'pen': 120, 'note': 50, 'clip': 300}
update(kw): {'pen': 120, 'note': 50, 'clip': 300, 'tape': 10}
pop       : 120 {'note': 45}
pop既定値  : None
popitem   : ('c', 3) {'a': 1, 'b': 2}
setdefault: 120 0 {'pen': 120, 'clip': 0}
clear     : {}
fromkeys  : {'a': 0, 'b': 0, 'c': 0}
|         : {'a': 1, 'b': 20, 'c': 3}
|=        : {'a': 1, 'b': 2}
in        : True False True
len       : 2
list/sorted: ['pen', 'note'] ['note', 'pen']
reversed  : ['note', 'pen']

in はキーだけを調べます。 上の例の 120 in d は False で、値を調べるには 120 in d.values() と書きます。

pop と popitem の空振りは、それぞれ次のエラーになります。

KeyError: 'x'
KeyError: 'popitem(): dictionary is empty'

keys()・values()・items()は「ビュー」

keys() などが返すのはコピーではなく、元の辞書を映す「ビュー」です。 辞書を変更すると、先に取得したビューにも反映されます。

d = {"pen": 120}
keys = d.keys()
print(keys)
d["note"] = 45
print(keys)                          # 元の辞書の変更が反映される
print(d.keys() & {"note", "clip"})   # 集合演算もできる

dict_keys(['pen'])
dict_keys(['pen', 'note'])
{'note'}

リストとして固定したいときは list(d.keys())（または list(d)）にします。

dict.fromkeysにリストを渡すと全キーで共有される

d = dict.fromkeys(["a", "b"], [])
d["a"].append(1)
print(d)

d = {k: [] for k in ["a", "b"]}      # 内包表記ならキーごとに別のリスト
d["a"].append(1)
print(d)

{'a': [1], 'b': [1]}
{'a': [1], 'b': []}

fromkeys の値は全キーで同じオブジェクトです。数値や文字列なら問題ありませんが、リストや辞書を初期値にするときは内包表記か defaultdict を使います。

辞書をループで回す

prices = {"pen": 120, "note": 180}
for k in prices:                 # キー
    print(k)
for v in prices.values():        # 値
    print(v)
for k, v in prices.items():      # キーと値
    print(f"{k}: {v}円")
for i, (k, v) in enumerate(prices.items(), start=1):   # 番号つき
    print(i, k, v)

pen
note
120
180
pen: 120円
note: 180円
1 pen 120
2 note 180

キーと値の両方を使うなら items() が読みやすく、prices[k] と毎回引くより素直です。

KeyErrorを避ける3つの方法の比較

stock = {"pen": 120}
# 1. in で確認
print(stock["eraser"] if "eraser" in stock else 0)
# 2. get
print(stock.get("eraser", 0))
# 3. try/except
try:
    v = stock["eraser"]
except KeyError:
    v = 0
print(v)

0
0
0

迷ったら get が簡潔です。「キーがないのはおかしい」データなら、あえて d[k] で KeyError にして早く気づけるようにするのもよい選択です。

collectionsの便利な辞書：defaultdict・Counter・OrderedDict・ChainMap

from collections import defaultdict, Counter, OrderedDict, ChainMap

orders = [("東", "ペン"), ("西", "ノート"), ("東", "クリップ"), ("東", "ペン")]

g = defaultdict(list)            # ないキーは空リストで始まる
for area, item in orders:
    g[area].append(item)
print(g)
print(dict(g))

c = Counter(item for _, item in orders)   # 出現回数を数える
print(c)
print(c.most_common(1), c["消しゴム"])

od = OrderedDict(a=1, b=2, c=3)
od.move_to_end("a")
print(od, od.popitem(last=False))

defaults = {"theme": "light", "lang": "ja", "page_size": 20}
user = {"theme": "dark"}
cfg = ChainMap(user, defaults)             # 前から順に探す
print(cfg["theme"], cfg["lang"], dict(cfg))

defaultdict(<class 'list'>, {'東': ['ペン', 'クリップ', 'ペン'], '西': ['ノート']})
{'東': ['ペン', 'クリップ', 'ペン'], '西': ['ノート']}
Counter({'ペン': 2, 'ノート': 1, 'クリップ': 1})
[('ペン', 2)] 0
OrderedDict({'c': 3, 'a': 1}) ('b', 2)
dark ja {'theme': 'dark', 'lang': 'ja', 'page_size': 20}

通常の dict も3.7から挿入順を保つため、順番を保つだけなら OrderedDict は不要です。

辞書内包表記で辞書を作る・絞り込む

prices = {"pen": 120, "note": 180, "clip": 30}
print({k: round(v * 1.1) for k, v in prices.items()})    # 値を変換
print({k: v for k, v in prices.items() if v >= 100})     # 条件で絞り込み
print({name: len(name) for name in ["pen", "note"]})      # リストから作る

{'pen': 132, 'note': 198, 'clip': 33}
{'pen': 120, 'note': 180}
{'pen': 3, 'note': 4}

{キー: 値 for ... in ... if 条件} の形で、変換と絞り込みを1行で書けます。

キー・値で辞書をソートする

prices = {"pen": 120, "note": 180, "clip": 30}
print(dict(sorted(prices.items())))                                      # キーで
print(dict(sorted(prices.items(), key=lambda kv: kv[1])))                # 値で
print(dict(sorted(prices.items(), key=lambda kv: kv[1], reverse=True)))  # 値の降順
print(max(prices, key=prices.get))                                       # 値が最大のキー

{'clip': 30, 'note': 180, 'pen': 120}
{'clip': 30, 'pen': 120, 'note': 180}
{'note': 180, 'pen': 120, 'clip': 30}
note

辞書そのものに sort() はないので、sorted(d.items()) で並べてから dict() に戻します。

辞書のリストを並べ替えるときは、key に取り出したいキーを指定します。

from operator import itemgetter
members = [{"name": "佐藤", "age": 31}, {"name": "鈴木", "age": 25}]
print(sorted(members, key=lambda m: m["age"]))
print(sorted(members, key=itemgetter("name")))

[{'name': '鈴木', 'age': 25}, {'name': '佐藤', 'age': 31}]
[{'name': '佐藤', 'age': 31}, {'name': '鈴木', 'age': 25}]

ネストした辞書から安全に値を取り出す

order = {"id": 1, "customer": {"name": "佐藤", "address": {"city": "千代田区"}}}
print(order["customer"]["address"]["city"])
print(order.get("customer", {}).get("address", {}).get("zip", "未登録"))

def dig(d, *keys, default=None):
    for k in keys:
        if not isinstance(d, dict) or k not in d:
            return default
        d = d[k]
    return d

print(dig(order, "customer", "address", "city"))
print(dig(order, "shipping", "date", default="未定"))

千代田区
未登録
千代田区
未定

get(k, {}) をつなげる方法は短く書けますが、途中の値が None だと AttributeError になります。 APIのレスポンスのように形が一定でないデータには、上の dig のような関数を用意すると安心です。

2つの辞書をマージする

a = {"x": 1, "y": 2}
b = {"y": 20, "z": 3}
print(a | b)          # 3.9+
print({**a, **b})     # 3.5+
c = a.copy(); c.update(b); print(c)
print(b | a)          # 後ろが優先

{'x': 1, 'y': 20, 'z': 3}
{'x': 1, 'y': 20, 'z': 3}
{'x': 1, 'y': 20, 'z': 3}
{'y': 2, 'z': 3, 'x': 1}

同じキーは「後ろ（右）の辞書」の値が残ります。 3.9以降なら a | b が一番読みやすい書き方です。

ネストした辞書のマージは上書きになる

| は1段目だけをマージするので、中の辞書は丸ごと置き換わります。設定ファイルの上書きなどで中身もマージしたい場合は、再帰で書きます。

print({"db": {"host": "localhost", "port": 5432}} | {"db": {"port": 15432}})

def deep_merge(base, over):
    out = base.copy()
    for k, v in over.items():
        out[k] = deep_merge(out[k], v) if isinstance(v, dict) and isinstance(out.get(k), dict) else v
    return out
print(deep_merge({"db": {"host": "localhost", "port": 5432}}, {"db": {"port": 15432}}))

{'db': {'port': 15432}}
{'db': {'host': 'localhost', 'port': 15432}}

よく使う変換パターン

2つのリストから辞書を作る（zip）

keys = ["id", "name", "qty"]
vals = [1, "ペン", 120]
print(dict(zip(keys, vals)))
print(dict(zip(["a", "b", "c"], [1, 2])))    # 短い方に合わせる
try:
    dict(zip(["a", "b", "c"], [1, 2], strict=True))   # 3.10+
except ValueError as e:
    print("ValueError:", e)
rows = [[1, "ペン", 120], [2, "ノート", 45]]
print([dict(zip(keys, r)) for r in rows])     # 行データを辞書のリストに

{'id': 1, 'name': 'ペン', 'qty': 120}
{'a': 1, 'b': 2}
ValueError: zip() argument 2 is shorter than argument 1
[{'id': 1, 'name': 'ペン', 'qty': 120}, {'id': 2, 'name': 'ノート', 'qty': 45}]

長さが違うと zip は黙って短い方に合わせます。 長さがそろっているはずのデータなら strict=True で確認できます。

キーと値を入れ替える

code = {"A": "出荷済", "B": "未出荷", "C": "出荷済"}
print({v: k for k, v in code.items()})       # 値が重複すると後勝ち

from collections import defaultdict
inv = defaultdict(list)
for k, v in code.items():
    inv[v].append(k)
print(dict(inv))

{'出荷済': 'C', '未出荷': 'B'}
{'出荷済': ['A', 'C'], '未出荷': ['B']}

値に重複があると入れ替えで情報が減ります。 重複の可能性があるならリストにまとめます。

グループ化・合計（標準のdictだけで）

tasks = [
    {"title": "見積作成", "status": "todo"},
    {"title": "議事録", "status": "done"},
    {"title": "設計書レビュー", "status": "todo"},
]
groups = {}
for t in tasks:
    groups.setdefault(t["status"], []).append(t["title"])
print(groups)

total = {}
for item, qty in [("ペン", 3), ("ノート", 2), ("ペン", 5)]:
    total[item] = total.get(item, 0) + qty
print(total)

{'todo': ['見積作成', '設計書レビュー'], 'done': ['議事録']}
{'ペン': 8, 'ノート': 2}

グループ化は setdefault(k, []).append()、合計は get(k, 0) + 値 が定番の形です。

辞書とJSONを相互変換する

import json
member = {"name": "佐藤", "skills": ["Python", "SQL"], "active": True, "note": None}
print(json.dumps(member))
s = json.dumps(member, ensure_ascii=False)
print(s)
print(json.loads(s))

{"name": "佐藤", "skills": ["Python", "SQL"], "active": true, "note": null}
{"name": "佐藤", "skills": ["Python", "SQL"], "active": true, "note": null}
{'name': '佐藤', 'skills': ['Python', 'SQL'], 'active': True, 'note': None}

ensure_ascii=False を付けると日本語がそのまま出力されます。 付けないと、日本語は \u から始まるエスケープ表記になります（データとしては同じ意味です）。indent=2 を付けると改行・字下げされて読みやすくなります。

ファイルに保存・読み込みするときは dump / load（sなし）を使い、encoding="utf-8" を指定します。

with open("member.json", "w", encoding="utf-8") as f:
    json.dump(member, f, ensure_ascii=False, indent=2)
with open("member.json", encoding="utf-8") as f:
    print(json.load(f))

JSON変換で変わるもの・エラーになるもの

import json, datetime
print(json.loads('{"1": "a"}'), json.dumps({1: "a"}))
json.dumps({"when": datetime.date(2026, 9, 28)})

{'1': 'a'} {"1": "a"}
TypeError: Object of type date is not JSON serializable
when serializing dict item 'when'

日付を含むときは json.dumps(d, default=str) で文字列にできます（実行結果：{"when": "2026-09-28"}）。なお、エラー文の2行目 when serializing dict item 'when' は、Python 3.14 で追加された「どこで失敗したか」を示す注記です（3.13では1行目だけでした）。

浅いコピーと深いコピーの違い

import copy
src = {"name": "佐藤", "skills": ["Python"]}

alias = src                 # 代入（同じもの）
shallow = src.copy()        # 浅いコピー
deep = copy.deepcopy(src)   # 深いコピー

src["name"] = "鈴木"
src["skills"].append("SQL")

print("alias  :", alias)
print("shallow:", shallow)
print("deep   :", deep)
print(shallow["skills"] is src["skills"], deep["skills"] is src["skills"])

alias  : {'name': '鈴木', 'skills': ['Python', 'SQL']}
shallow: {'name': '佐藤', 'skills': ['Python', 'SQL']}
deep   : {'name': '佐藤', 'skills': ['Python']}
True False

浅いコピーは「中のリストや辞書」を共有します。 中身まで変更する可能性があるなら copy.deepcopy() を使います。

辞書のキーに使える型・使えない型

d = {}
d[(35.68, 139.76)] = "地点A"     # タプルはOK
d[frozenset({"a", "b"})] = 1     # frozensetもOK
for key in [["a", "b"], {"a": 1}, {"a"}]:
    try:
        d[key] = 1
    except TypeError as e:
        print("TypeError:", e)
print({1: "int", 1.0: "float", True: "bool"})

実行結果（Python 3.14.7）：

TypeError: cannot use 'list' as a dict key (unhashable type: 'list')
TypeError: cannot use 'dict' as a dict key (unhashable type: 'dict')
TypeError: cannot use 'set' as a dict key (unhashable type: 'set')
{1: 'bool'}

Python 3.13 では同じコードが TypeError: unhashable type: 'list' という短い文でした。3.14 でエラー文がわかりやすくなっています。

ハッシュ可能とは、中身を変更できず、固定の番号（ハッシュ値）を計算できることです。 複数の値を組み合わせたキーにしたいときは、リストではなくタプルを使います。また 1、1.0、True は等しいとみなされ同じキーになるため、最後の例は1件になりました（キーは最初の 1、値は最後の 'bool'）。

挿入順は保証される（Python 3.7以降）

d = {}
d["c"] = 1; d["a"] = 2; d["b"] = 3
print(list(d))
d["a"] = 99              # 上書きしても位置は変わらない
print(list(d))
del d["c"]; d["c"] = 1   # 削除して入れ直すと末尾へ
print(list(d))
print({"a": 1, "b": 2} == {"b": 2, "a": 1})

['c', 'a', 'b']
['c', 'a', 'b']
['a', 'b', 'c']
True

Python 3.7 から、辞書は追加した順番を保つことが言語仕様になりました。 ただし == の比較では順番は無視されます。

ループ中に辞書を変更するとRuntimeError

stock = {"pen": 0, "note": 45, "clip": 0}
for k in stock:
    if stock[k] == 0:
        del stock[k]

RuntimeError: dictionary changed size during iteration

ループ中に件数（キー）を増減するとエラーになります。 次のどちらかで書き直します。

stock = {"pen": 0, "note": 45, "clip": 0}
for k in list(stock):          # キーのリストのコピーを回す
    if stock[k] == 0:
        del stock[k]
print(stock)

stock = {"pen": 0, "note": 45, "clip": 0}
stock = {k: v for k, v in stock.items() if v != 0}   # 内包表記で作り直す
print(stock)

stock = {"pen": 0, "note": 45}
for k in stock:
    stock[k] += 1            # 値の変更だけならOK
print(stock)

{'note': 45}
{'note': 45}
{'pen': 1, 'note': 46}

値を変えるだけならループ中でも問題ありません。 削除・追加が必要なときは list(d) で回すか、内包表記で新しい辞書を作ります。

型ヒントでキーを決めたいとき：TypedDict

決まったキーを持つ辞書に型ヒントを付けたいときは TypedDict が使えます。実行時はふつうの dict のままで、mypyなどの型チェッカーがキーの間違いを検出してくれます。

from typing import TypedDict, NotRequired

class Member(TypedDict):
    name: str
    age: int
    email: NotRequired[str]   # 省略可能なキー（3.11+）

m: Member = {"name": "佐藤", "age": 31}
print(m, type(m))

{'name': '佐藤', 'age': 31} <class 'dict'>

よくある質問

Q. 辞書とリストはどう使い分けますか？ A. 順番（位置）で取り出すならリスト、名前（キー）で取り出すなら辞書です。辞書のキー検索は件数が増えても速いので、「IDから会員を探す」ような処理は辞書が向いています。

Q. 値からキーを探すには？ A. [k for k, v in d.items() if v == 探す値] で一致するキーをすべて取れます。何度も探すなら、キーと値を入れ替えた辞書を作っておくと速くなります。

Q. 辞書が空かどうかはどう判定しますか？ A. if not d: で判定できます。空の辞書は False として扱われます。

Q. d.get(k) と d[k] はどちらを使えばよいですか？ A. キーが必ずあるはずなら d[k]、なくてもよいなら d.get(k, 既定値) です。d[k] ならデータの不備に KeyError ですぐ気づけます。

まとめ

• 辞書はキーと値のペア。追加と上書きは d[k] = v、ないキーの取り出しは KeyError
• 安全な取り出しは get(k, 既定値)、削除して取り出すのは pop、なければ追加は setdefault
• 集計は Counter、グループ化は defaultdict(list)、マージは3.9以降なら a | b（右が優先）
• ソートは dict(sorted(d.items(), key=...))、日本語をJSONにするときは ensure_ascii=False
• copy() は浅いコピーで中のリストは共有される。中まで分けるなら deepcopy
• キーにリストは使えない（タプルにする）。3.14ではエラー文がより具体的になった
• ループ中の削除は list(d) で回すか内包表記で作り直す

株式会社RJCでは、辞書のような毎日使う基本も、実際に動かして挙動を確かめながら仲間と学び合っています。こうした知識を共有しながら、日々技術を磨いています。

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。