Python 04：データの入れ物 ― list・tuple・dict・set と「名前は札」

入れ物は4種類：list・tuple・dict・set

Python の標準の入れ物（コレクションとも呼びます）は、主に4つです。

JS では、配列とオブジェクトの2つでだいたいのことを済ませます。Python は目的ごとに入れ物を選ぶ文化です。

4つとも、中に入れられるのはどんなオブジェクトでもかまいません。数と文字列を混ぜても、list の中に dict を入れてもかまいません（dict のキーと set の要素だけは例外で、後で見ます）。

dict は、Python 3.7 から「入れた順番を必ず保つ」ことが言語の約束になりました。JS のオブジェクトもおおむね入れた順を保つので、感覚はほぼ同じです。

list：JS の配列とほぼ同じ

list は、JS の配列とほとんど同じ感覚で使えます。[ ] で作り、0 から数える番号で読み書きし、長さは自由に伸び縮みします。

違うのは、主にメソッドの名前です。図の表をまとめるとこうなります。

長さが a.length のような「持ち物」ではなく、len(a) という関数なのは、Python の設計の考え方によるものです。list にも文字列にも dict にも set にも、同じ len() が使えます。JS では配列は .length、Map は .size、オブジェクトは Object.keys(o).length とバラバラでしたが、Python は「数を知りたければ、何でも len()」で統一しています。

in も同じで、31 in temps（list）、"東京" in cities（set）、"temp" in w（dict のキー）、"晴" in "晴れ"（文字列）のように、入れ物の種類を問わず使えます。

JS の sort() は何も指定しないと文字列として並べる（[10, 9, 1].sort() が [1, 10, 9] になる）という落とし穴がありますが、Python の sort() は数なら数として並べます。

インデックスは後ろからも数えられる

list の要素には、JS と同じく 0 から始まる番号（インデックス） が付いています。temps[0] が最初の 28 です。

Python では、さらにマイナスの番号が使えます。図の下段の赤い数字のように、-1 が最後、-2 が最後から2番目です。

temps = [28, 31, 33, 25, 22]
temps[0]     # 28
temps[-1]    # 22（最後）
temps[-2]    # 25

JS で最後の要素を取るには temps[temps.length - 1] と書くか、比較的新しい temps.at(-1) を使います。Python では昔から temps[-1] で済みます。

もう1つの違いは、範囲の外を読んだときです。

JS は無い番号を読んでも undefined を返して処理を続けます。Python は第3章で見た考え方どおり、あいまいなまま続けずに止めます。undefined がどこか遠くで悪さをしてから気づくより、読んだその場で分かったほうが原因を探しやすいからです。

インデックスは、文字列や tuple にも同じように使えます。"東京都"[-1] は "都" です。

スライス：[始まり:終わり] で一部を切り出す

temps[1:3] のように、角かっこの中に : をはさんで2つの番号を書くと、list の一部を切り出した新しい list が返ってきます。これをスライスと呼びます。

「1 から 3 まで」なのに、結果は [31, 33] の2つです。3番目の 25 は入りません。終わりの番号は含まないのです。

これを覚えるコツは、図のように、番号を升ではなく「切れ目」に振ってあると考えることです。28 の左が切れ目0、28 と 31 の間が切れ目1、…と数えると、temps[1:3] は「切れ目1から切れ目3までの間」になり、中にある升はちょうど 31 と 33 です。この見方なら、temps[1:3] の長さが 3 - 1 = 2 になるのも自然です。

JS の temps.slice(1, 3) とまったく同じ意味で、「終わりを含まない」のも同じです。Python はそれを記号で短く書けるようにしたもの、と考えてください。

スライスは新しい list を作るので、切り出した結果を変えても、元の temps は変わりません。範囲の外を指定してもエラーにはならず、ある分だけが返ります（temps[3:100] は [25, 22]）。

tuple：変更できない list

tuple（タプル）は、( ) で作る、あとから中身を変えられない list です。

pos = (35.68, 139.76)   # 東京の緯度・経度
pos[0]                  # 35.68（読むのは list と同じ）
pos[0] = 0
# TypeError: 'tuple' object does not support item assignment

JS には、tuple にあたる入れ物はありません。配列を Object.freeze() で凍らせるのが近いですが、ふだんは使いません。

変えられない入れ物が何の役に立つのでしょうか。

tuple でよく使うのが、分けて受け取る書き方（アンパック）です。lat, lon = pos と書くと、1つ目が lat、2つ目が lon に入ります。JS の分割代入 const [lat, lon] = pos と同じです。first, *rest = temps と書けば、JS の const [first, ...rest] = temps と同じく、残りを list で受け取れます。

tuple を作っているのは、実は ( ) ではなくカンマです。pos = 35.68, 139.76 でも tuple になります。逆に、要素が1つの tuple は (21,) とカンマが必要です。(21) はただのかっこに入った数の 21 です。

dict：キーで値を引く。JS のオブジェクトの役

dict（ディクト、辞書）は、キーと値の組を集めた入れ物です。JS のオブジェクトや Map にあたります。図の右側は、dict の中身をキーと値の表として描いたものです。

w = {
    "city": "東京",
    "temp": 31,
}
w["temp"]        # 31
"city" in w      # True（キーがあるか）

JS との違いは2つあります。

Python の dict では、キーはただの値です。{city: "東京"} と書くと、Python は city という名前の変数を探しに行き、無ければ NameError になります。キーが文字列なら、必ず引用符で囲みます。

なぜ w.temp と書けないのでしょうか。JS のオブジェクトは「データの入れ物」と「メソッドを持つ物（obj.method()）」の2役を兼ねています。そのため、{ toString: 1 } のようにキーとメソッドの名前がぶつかる、といった混乱が起きます。

Python はこの2役を分けました。データの入れ物は dict で w["キー"]、ドット . で名前を引くのはオブジェクトの属性（メソッドなど。第7章のクラス）です。dict のメソッド（.get()、.items() など）とデータのキーが、決してぶつかりません。

ドットで読みたいデータの形があるなら、第7章の dataclass で「天気」というクラスを作るのが Python らしいやり方です。

足すのは代入、無いキーを読むと KeyError

dict に組を足すのは、JS と同じく代入です。図の右に "rain" の行が増えました。

w["rain"] = 10          # 組を足す（あれば上書き）
del w["rain"]           # 組を消す（JS の delete w.rain）

無いキーを読んだときの動きが、JS と大きく違います。

これも list の範囲外と同じ考え方です。w["tmep"] と打ち間違えたとき、JS は黙って undefined を返し、ずっと後で NaN や表示の崩れとして現れます。Python はその場で KeyError: 'tmep' と、間違えたキーの名前付きで教えてくれます。

「無いこともある」と分かっているときは、.get(キー, 既定値) で明示して読みます。

dict を回すときは、.items() でキーと値の組を取り出すのが定番です。

for k, v in w.items():
    print(k, v)
# city 東京
# temp 31
# rain 10

JS の for (const [k, v] of Object.entries(w)) にあたります。for k in w: と書くと、キーだけが順に出てきます。

set：重複しない集まり。和・積・差が記号で書ける

set（セット、集合）は、同じ値を2つ持たない入れ物です。JS の Set にあたります。

s = {"晴れ", "雨", "晴れ"}
print(s)        # {'晴れ', '雨'}（順番は決まっていない）
len(s)          # 2

{ } にキーと値の組ではなく値だけを並べると set になります。ただし、空の set は `set()` と書きます。{} は空の dict です（dict のほうが先に {} を使っていたため）。

JS の Set と違うのは、図のような集合の計算を記号で書けることです。

和は a | b と書きます（縦棒1本）。

set の強みは in の速さです。list の in は先頭から1つずつ見比べるので、要素が多いほど遅くなります。set は、後で見るハッシュという仕組みで置き場所を直接計算するので、100万個入っていても一瞬で答えが出ます。

set には順番がありません。表示の順番は入れた順とは限らないので、順番が大事なら list を使います。重複を消してから順に並べたいときは sorted(set(temps)) のように書きます。

内包表記：filter と map を1行で

JS では、配列から条件に合うものを選び（filter）、それぞれを変換する（map）とき、メソッドをつなげて書きます。

temps.filter(t => t >= 30).map(t => Math.round(t * 1.8 + 32))
// → [88, 91]（30度以上の日を華氏に）

Python では、同じことを 内包表記（リスト内包表記、list comprehension）という1つの式で書きます。

[round(t * 1.8 + 32) for t in temps if t >= 30]
# → [88, 91]

図の札の番号どおり、3つの部分に分けて読みます。

英語で読むと「round(t × 1.8 + 32) を、temps の中の各 t について、t が30以上なら」になり、数学の集合の書き方 {2x | x ∈ A} に似せてあります。

[ ] を { } にすると、dict や set も作れます。{c: len(c) for c in cities} は「都市名 → 文字数」の dict、{t % 10 for t in temps} は set です。

Python にも map() と filter() という関数はありますが、ふつうは内包表記のほうが読みやすいとされています。ただし、条件が2つも3つも重なって1行が長くなるなら、無理をせず for 文（第6章）で書いたほうが読みやすくなります。

名前は札：変数は「箱」ではない

ここからが、この章の山場です。第3章で「変数は値を入れる箱ではなく、オブジェクトに付ける名前の札」と書きました。list のような変更できる入れ物を扱うとき、この見方が本当に効いてきます。

図の舞台は、左が名前（札）、右がオブジェクト（メモリ上の実体）です。

a = [21, 23]

この1行で起きることは、

です。

「箱」のたとえで考えると、「a という箱に [21, 23] が入っている」になります。一見同じことのようですが、次の1行 b = a で、2つのたとえは違う答えを出します。

Python で実際に起きるのは、札のほうです。

b = a はコピーではない。札が2枚になるだけ

b = a

図のように、札 b は、a と同じ1つの list に付きます。list のオブジェクトは1つのままで、新しい list は作られていません。

Python の公式ドキュメントも、代入を「名前をオブジェクトに束縛する（bind）」と説明しています。= がするのは札を付けること（束縛）だけで、値のコピーは一度もしません。

確かめる方法は、第3章で見た is です。

a is b     # True（同じ物に付いている）

JS から来た人にとって、これは実は見慣れた動きです。JS でも、const b = a とした配列やオブジェクトは同じ物を指します。

違いは表の2行目です。JS の入門書は「数や文字列はコピー、オブジェクトは参照」と2通りに説明しがちですが、Python は何でも同じルール（札を付けるだけ）です。それでも数や文字列で困らないのは、後で見るように「変更できない」からです。

b.append(25) で、a から見ても変わる

b.append(25)
print(a)     # [21, 23, 25]

b にしか append していないのに、a を表示すると 25 が増えています。

図を見れば当たり前です。append は、札の付いている list そのものを書き換えます。札 a も札 b も、その同じ1つの list に付いているので、どちらの札から見ても変わっています。

これらはすべて「物を変える」操作です。同じ物に札が何枚付いていても、全員から変わって見えます。

JS でも const b = a; b.push(25) とすれば a も変わるので、ここまでは JS と同じです。大事なのは、Python ではこれを「名前は札」という1つのルールで説明しきれることです。この先の「関数に list を渡すと、中で変えたものが外にも見える」（第5章）も、「デフォルト引数に [] を書くと、呼ぶたびに増えていく」（第5章）も、すべてこの絵で説明がつきます。

b = [0] は札の付け替え。a は無事

では、次はどうでしょう。

b = [0]
print(a, b)   # [21, 23, 25] [0]

今度は a は変わりません。図のように、[0] という新しい list が作られ、札 b がそちらへ付け替えられただけだからです。元の list には札 a だけが残り、中身は何も変わっていません。

ここで、2種類の操作をはっきり分けておきます。

見分け方は簡単で、`名前 = …` の形（名前そのものへの代入）は付け替え、それ以外（メソッドを呼ぶ、名前[…] = … に代入する）は物を変える操作です。

b[0] = 1 は = を使っていますが、左辺が名前そのものではなく「b が付いている物の0番目」なので、物を変える操作です。

「a の値を変えたつもりが変わらない」「変えるつもりが無かったのに変わった」というバグは、たいていこの2つの取り違えです。迷ったら、札とオブジェクトの絵を描いてみてください。

変更できるもの・できないもの

Python のオブジェクトは、中身を変更できるかどうかで2つに分かれます。

文字列の1文字を書き換えようとすると、エラーになります。

s = "晴れ"
s[0] = "曇"
# TypeError: 'str' object does not support item assignment

JS も実は同じで、文字列は変更できません（s[0] = "曇" は、厳格モードでなければ黙って無視され、厳格モードなら TypeError になります）。Python はそれをエラーで知らせてくれます。

"晴れ".upper() や "晴れ".replace("晴", "曇") のような文字列のメソッドは、元を変えずに新しい文字列を作って返します。JS の文字列のメソッドと同じです。

この区別は、前の「名前は札」と組み合わせると威力を発揮します。

数や文字列を代入しても「コピーのように」振る舞うのは、コピーしているからではなく、そもそも変えられないからです。

変更できない物を「変える」と、どうなる？

では、変更できない文字列に += を使うと何が起きるのでしょうか。

s = "晴れ"
t = s

ここまでは list のときと同じです。図のように、札 s と札 t が、同じ1つの str のオブジェクト "晴れ" に付いています（s is t は True）。

list のとき、b.append(25) で a まで変わりました。では、ここで

s += "時々雨"

とすると、t も "晴れ時々雨" になるでしょうか？

「変更できない」という性質を思い出すと、答えが予想できます。"晴れ" というオブジェクトは、誰にも書き換えられないはずです。では、s が "晴れ時々雨" になるには、何が起きればいいでしょうか。

新しい物が作られ、札が付け替わる

答えは図のとおりです。

元の "晴れ" は書き換えられていないので、そこに付いたままの t は "晴れ" のままです。

print(s)      # 晴れ時々雨
print(t)      # 晴れ
s is t        # False

つまり、変更できない物に対する s += … は、実質的に s = s + …（新しい物を作って付け替え）になります。数でも同じで、n += 1 は「n + 1 という新しい int を作り、n を付け替える」です。

こうして、変更できない物は、札が何枚付いていても安心して配れます。関数に文字列を渡しても、関数の中で書き換えられて呼んだ側が困ることはありません。逆に、変更できる list や dict を渡すときは、「中で変えられるかもしれない」と意識しておく必要があります（第5章）。

同じ += でも、list は物を変え、str は付け替える

ここで、JS から来た人がまず予想しない動きをまとめておきます。同じ `+=` なのに、型によって結果が違うのです。

x = [1]
y = x
x += [2]
print(y)      # [1, 2]  ← y も変わる

s = "晴れ"
t = s
s += "時々雨"
print(t)      # 晴れ    ← t は変わらない

理由は、変更できる型は += で「自分自身を変える」ように作られていて、変更できない型にはそれができないからです。

ここで覚えておきたいのは、個別の規則ではなく考え方の順番です。「その型は変更できるか？」を先に考えれば、「できるなら物が変わる（他の札にも見える）」「できないなら新しい物ができる（他の札は無事）」と、答えが自然に出てきます。

浅いコピー：外側だけが新しくなる

札を増やすのではなく、本当に別の物が欲しいときは、コピーを頼みます。list なら a.copy()（または a[:]、list(a)）です。

ところが、入れ子になった list では注意が要ります。

nested = [[21, 23], [18, 19]]
sh = nested.copy()
sh[0].append(99)
print(nested)     # [[21, 23, 99], [18, 19]]  ← 元も変わった！

図を見てください。nested.copy() が新しく作るのは、外側の list だけです。外側の list の0番目・1番目の升には「中の list への札」が入っていて、コピーはその札を写すだけです。だから、コピーした外側（赤い矢印）も、元の外側（灰色の矢印）も、同じ中の list を指しています。

sh[0].append(99) は、sh の0番目が指している中の list（＝nested の0番目と同じ物）を変えるので、nested から見ても変わります。

このように、いちばん外側だけを作り直すコピーを浅いコピー（shallow copy）と呼びます。a.copy()、a[:]、list(a)、dict.copy() はどれも浅いコピーです。

中が数や文字列だけの list なら、浅いコピーで何の問題もありません。中身は変更できない物なので、共有していても誰にも書き換えられないからです。問題になるのは、中に変更できる物（list や dict）が入っているときだけです。

深いコピー：中の中まで新しく作る

中まで全部を別物にしたいときは、標準ライブラリの copy モジュールにある `copy.deepcopy()` を使います。

import copy
nested = [[21, 23], [18, 19]]
dp = copy.deepcopy(nested)
dp[0].append(99)
print(nested)     # [[21, 23], [18, 19]]  ← 無事

図の緑の矢印のように、深いコピーは外側だけでなく、中の list もたどって1つずつ作り直します。コピー側の外側は、新しく作られた中の list を指すので、どこをどう変えても元の nested には影響しません。

import copy は、Python に最初から付いてくる標準ライブラリの copy モジュールを読み込む文です。この1行で何が起きているのか（どこのファイルを読んでいるのか）は、第8章でじっくり分解します。

コピーは必ず自分で頼む

Python の = は決してコピーをしません。コピーが要るときは、必ず自分で頼みます。

JS と考え方はまったく同じです。JS の [...a] やスプレッド { ...d } も浅いコピーで、入れ子の配列やオブジェクトは共有されます。JS で「スプレッドでコピーしたのに元が変わった」経験があれば、それとまったく同じことが Python でも起きる、と思ってください。

{**d} は、dict を中身ごと展開して新しい dict を作る書き方です。JS の { ...d } にあたります。** の意味は、第5章の関数の引数でも出てきます。

dict のキーと set には、変更できない物だけ入る

dict のキーと set の要素には、変更できない物しか入れられません。list をキーにしようとすると、エラーになります。

{[35.68, 139.76]: "東京"}
# TypeError: unhashable type: 'list'

理由は、dict がキーを探す仕組みにあります。

1つずつ見比べずに、番号で直接取りに行くので、dict はどれだけ大きくても一瞬で値を引けます（set の in が速いのも同じ理由です）。

ところが、もしキーが list で、あとから中身が変わったらどうなるでしょう。計算し直した番号が変わってしまい、しまった場所と違う場所を探しに行って、見つけられなくなります。それを防ぐために、Python は変更できる物（list・dict・set）をキーにすることを最初から禁止しています。エラーの unhashable（ハッシュできない）はその意味です。

座標のような「組」をキーにしたいときは、tuple を使います。

where = {(35.68, 139.76): "東京"}
where[(35.68, 139.76)]     # "東京"

JS のオブジェクトのキーは文字列だけなので、{[1, 2]: "x"} と書くとキーが文字列の "1,2" に変換されます。Python では tuple がそのままキーになります。

JS と並べて：よく使う操作

入れ物まわりで、JS からの書き換えによく使う操作を並べておきます。

dict どうしを d1 | d2 のように縦棒1本でくっつける書き方は Python 3.9 から使えます。後ろの dict の値が優先されるのは、JS のスプレッドと同じです。

迷ったときは、3つだけ思い出してください。どの入れ物か（list・tuple・dict・set）、変更できるか（札の付いた物が変わるのか、新しい物ができるのか）、無いものを読んだらエラーか（Python は基本的にエラーにする）。

tenki：天気のデータを dict と list で持つ

第3章の tenki は、1日分の天気を city・temp・rain という別々の変数で持っていました。何日分もの天気を扱うなら、入れ物を使います。1日分を dict、何日分かを list にするのが定番の形です。

# tenki.py ― 第4章の版
forecast = [
    {"day": "月", "temp": 31, "rain": 10},
    {"day": "火", "temp": 27, "rain": 60},
    {"day": "水", "temp": 33, "rain": 0},
]
for f in forecast:
    umbrella = "傘" if f["rain"] >= 50 else "-"
    print(f"{f['day']}: {f['temp']}度 {umbrella}")

hot = [f["day"] for f in forecast if f["temp"] >= 30]
print("暑い日:", hot)

$ python3 tenki.py
月: 31度 -
火: 27度 傘
水: 33度 -
暑い日: ['月', '水']

f-string の中で f['day'] と単引用符を使っているのは、外側の " と区別するためです（Python 3.12 からは同じ引用符も使えるようになりましたが、どの版でも動く書き方にしてあります）。

この「dict の list」の形は、Web の API から返ってくる JSON と同じ形です。JSON の配列は list に、オブジェクトは dict に、null は None に、true は True にそのまま対応します。第11章で本物の天気予報を API から取ってくるとき、受け取ったデータはこの形になって出てきます。

よくある間違いと、出るエラー

入れ物で出るエラーは、だいたい次の6つです。どれも python3 3.13 で実際に確かめたものです。

最後の行は、エラーが出ないぶん気づきにくい罠です。[[]] * 3 の * 3 は、中の空の list をコピーせず、同じ1つの list への参照を3つ並べます。札の絵でいえば、1つの list に3枚の札が付いている状態です。だから1つに append すると、3つとも変わって見えます。

Python の公式ドキュメントにも、この例がそのまま「新しく Python を書く人がよくはまる」と載っています。直し方は、内包表記で毎回新しい list を作ることです。内包表記の [] は1周ごとに評価されるので、3つの別々の list ができます。