Python
PR

Pythonの浅いコピーと深いコピー|copy・deepcopyの違いとよくある間違い

Pythonの浅いコピーと深いコピー|copy・deepcopyの違いとよくある間違い
hr
記事内に商品プロモーションを含む場合があります

Python で「リストをコピーして片方だけ書き換えたはずなのに、元のリストまで変わっていた」という経験はありませんか。原因はほとんどの場合、代入・浅いコピー・深いコピーの違いです。

この記事では、b = a がコピーにならない理由から、list.copy() や copy.copy() の浅いコピー、copy.deepcopy() の深いコピー、そして関数の引数・デフォルト引数・二次元リストで起きる「いつの間にか共有されていた」間違いまでを、実行結果つきで説明します。載せている出力は、Windows 11・Python 3.12.6 で実際に実行して確かめたものです。

コードは sample.py などの名前で保存し、PowerShell でそのフォルダーに移動してから次のコマンドで実行できます。

py sample.py

まず結論:3 つの違い

書き方新しく作られるものb の中身を変えたとき a は
b = a(代入)何も作られない(名前が増えるだけ)変わる
a.copy()・a[:]・list(a)・copy.copy(a)(浅いコピー)外側のリストだけ外側の操作(append など)なら変わらない。入れ子の中身を変えると変わる
copy.deepcopy(a)(深いコピー)外側も中身も、すべて変わらない

中身が数値や文字列だけの「平らな」リストなら浅いコピーで十分です。リストの中にリストや辞書が入っているときに、浅いコピーと深いコピーの差が出ます。以下、1 つずつ確かめていきます。

b = a はコピーではない(同じものに 2 つの名前)

Python の変数は、データそのものを入れる箱ではなく、データ(オブジェクト)に付けた名札のようなものです。公式ドキュメントの copy モジュールの説明も「Python の代入文はオブジェクトをコピーせず、名前とオブジェクトを結び付けるだけ」という文から始まります。

a = [1, 2, 3]
b = a
print(id(a) == id(b), a is b)
b.append(4)
print("a =", a)
print("b =", b)
True True
a = [1, 2, 3, 4]
b = [1, 2, 3, 4]

id() はオブジェクトごとに付く番号を返す関数で、is は「2 つが同じオブジェクトか」を調べる演算子です。どちらも「同じ」と答えているとおり、リストは 1 つしかなく、a と b はその同じリストを指しています。そのため b に append すると、a から見ても 4 が増えています。

なお == は「中身が等しいか」を比べるので、別々のリストでも中身が同じなら True になります。「同じものか」を確かめたいときは is を使います。

浅いコピー:外側だけ新しく、中身は共有

浅いコピーを作る 5 つの書き方

リストのコピーにはいくつかの書き方がありますが、次のものはどれも浅いコピー(shallow copy)です。

  • a.copy():リストの copy メソッド
  • a[:]:先頭から最後までのスライス
  • list(a):リストを作り直す
  • copy.copy(a):copy モジュールの関数(リスト以外のオブジェクトにも使える)
  • d.copy()・dict(d):辞書の場合。セットの s.copy() も同じ

公式ドキュメントでは、浅いコピーは「新しい複合オブジェクトを作り、元のオブジェクトに入っていたものへの参照を入れる」と説明されています。参照とは「そのオブジェクトを指している矢印」のことです。つまり、外側の入れ物は新しくなりますが、中に入っている要素は元と同じものを指したままです。4 つの書き方で確かめます。

import copy

a = [[1, 2], [3, 4]]
copies = {
    "a.copy()": a.copy(),
    "a[:]": a[:],
    "list(a)": list(a),
    "copy.copy(a)": copy.copy(a),
}
for name, c in copies.items():
    print(f"{name:13} 外側が同じ: {c is a}  中身が同じ: {c[0] is a[0]}")
a.copy()      外側が同じ: False  中身が同じ: True
a[:]          外側が同じ: False  中身が同じ: True
list(a)       外側が同じ: False  中身が同じ: True
copy.copy(a)  外側が同じ: False  中身が同じ: True

どの書き方でも、外側のリストは別物(False)ですが、中の [1, 2] は元と同じもの(True)でした。

入れ子のリストで中を変えると元も変わる

中身が共有されていると、何が起きるかを見てみます。

a = [[1, 2], [3, 4]]
b = a.copy()
b.append([5, 6])
print("a =", a)
b[0].append(99)
print("a =", a)
print("b =", b)
a = [[1, 2], [3, 4]]
a = [[1, 2, 99], [3, 4]]
b = [[1, 2, 99], [3, 4], [5, 6]]

b.append([5, 6]) は外側のリスト(b だけのもの)を変える操作なので、a は変わりません。一方、b[0].append(99) は「b の 0 番目が指しているリスト」を変える操作です。そのリストは a の 0 番目と同じものなので、a にも 99 が増えました。浅いコピーは「1 段目だけのコピー」と覚えておくと間違えません。

辞書の copy() も浅いコピー

辞書も同じです。値が文字列のキーを書き換えても元は変わりませんが、値がリストのキーに append すると元にも反映されます。

user = {"name": "田中", "tags": ["python"]}
u2 = user.copy()
u2["name"] = "鈴木"
u2["tags"].append("git")
print(user)
print(u2)
{'name': '田中', 'tags': ['python', 'git']}
{'name': '鈴木', 'tags': ['python', 'git']}

u2["name"] = "鈴木" は u2 の「name の矢印」を新しい文字列に付け替えるだけなので、user の name は田中のままです。u2["tags"].append("git") は共有しているリストそのものを変えるため、user の tags にも git が入りました。「付け替え(=)は相手に影響しない、中身の変更(append・要素への代入など)は共有先に影響する」と区別するのがコツです。

深いコピー:copy.deepcopy で中まで複製する

中身まで別々にしたいときは、標準ライブラリの copy モジュールの deepcopy() を使います。公式ドキュメントでは「新しい複合オブジェクトを作り、元に入っていたオブジェクトのコピーを再帰的に入れる」と説明されています。入れ子が何段あっても、たどれるところまで全部複製します。

import copy

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)
print(b is a, b[0] is a[0])
b[0].append(99)
print("a =", a)
print("b =", b)
False False
a = [[1, 2], [3, 4]]
b = [[1, 2, 99], [3, 4]]

今度は中の [1, 2] も別物(False)になり、b に 99 を足しても a は元のままです。ここまでの 3 つの違いを図にすると、次のようになります。

代入・浅いコピー・深いコピーの比較図。代入では変数 a と b が同じ外側のリストを指す。浅いコピーでは外側のリストが 2 つになるが、どちらも同じ [1, 2] と [3, 4] を指す。深いコピーでは外側のリストも [1, 2] と [3, 4] も a 用と b 用に別々にある。
図 1:代入・浅いコピー・深いコピーで、箱(オブジェクト)と矢印(参照)がどうなるか

実例:設定のひな形をコピーして使う

実際の開発でよくあるのが、既定の設定(ひな形)をコピーして、利用者ごとに一部を変える場面です。浅いコピーだと、ひな形そのものが壊れます。

import copy

DEFAULT = {"theme": "light", "plugins": ["git"]}

conf_a = DEFAULT.copy()
conf_a["plugins"].append("docker")
print(DEFAULT)

DEFAULT = {"theme": "light", "plugins": ["git"]}
conf_b = copy.deepcopy(DEFAULT)
conf_b["plugins"].append("docker")
print(DEFAULT)
print(conf_b)
{'theme': 'light', 'plugins': ['git', 'docker']}
{'theme': 'light', 'plugins': ['git']}
{'theme': 'light', 'plugins': ['git', 'docker']}

浅いコピーの conf_a に docker を足すと、ひな形の DEFAULT にも docker が入ってしまいました。次に設定を作る人には、最初から docker が入った状態で渡ってしまいます。deepcopy した conf_b では、DEFAULT は ['git'] のままです。JSON から読み込んだデータのように、辞書とリストが何段も入れ子になったものをコピーするときは deepcopy を使うのが安全です。

自作クラスのインスタンスも同じ

copy.copy() と copy.deepcopy() は、リストや辞書だけでなく自作クラスのインスタンスにも使えます。属性にリストを持っていると、浅いコピーではそのリストが共有されます。

import copy

class Team:
    def __init__(self, name, members):
        self.name = name
        self.members = members

t1 = Team("A", ["佐藤", "鈴木"])
t2 = copy.copy(t1)
t2.name = "B"
t2.members.append("高橋")
print(t1.name, t1.members)

t3 = copy.deepcopy(t1)
t3.members.append("田中")
print(t1.members, t3.members)
A ['佐藤', '鈴木', '高橋']
['佐藤', '鈴木', '高橋'] ['佐藤', '鈴木', '高橋', '田中']

t2 の name を変えても t1 は A のままですが、members への追加は t1 にも反映されました。deepcopy した t3 なら、t1 の members は変わりません。dataclass で作ったクラスも同じように扱えます。

deepcopy の注意点:遅い・コピーしすぎることがある

deepcopy は中身を 1 つずつたどって複製するため、浅いコピーよりずっと時間がかかります。3 つの数値が入ったリストを 1 万個持つリストで、timeit を使って 1 回あたりの時間を測りました。

import copy
import timeit

data = [[i, i + 1, i + 2] for i in range(10_000)]
n = 20
t1 = timeit.timeit(lambda: data.copy(), number=n) / n
t2 = timeit.timeit(lambda: copy.deepcopy(data), number=n) / n
print(f"copy():     {t1 * 1000:.3f} ms")
print(f"deepcopy(): {t2 * 1000:.3f} ms")
copy():     0.018 ms
deepcopy(): 7.694 ms

この PC では、3 回測って copy() が 0.018〜0.021 ミリ秒、deepcopy() が 7.7〜8.4 ミリ秒で、数百倍の差がありました(数値は PC やデータで変わります)。1 回なら気になりませんが、ループの中で大きなデータを毎回 deepcopy すると目に見えて遅くなります。「本当に中まで別にする必要があるか」を考えてから使いましょう。

また、公式ドキュメントでは深いコピーの問題として、次の 2 つが挙げられています。

  • 自分自身を(直接または間接に)含むオブジェクト(再帰的なオブジェクト)は、無限ループになるおそれがある
  • すべてをコピーするため、コピー同士で共有するつもりのデータまでコピーしすぎることがある

1 つ目について、deepcopy は「このコピー中にすでにコピーしたオブジェクト」を memo という辞書に覚えておくことで避けています。自分自身を要素に持つリストで試すと、無限ループにならずにコピーできました([...] は「自分自身」を表す print の表示です)。

import copy

a = [1, 2]
a.append(a)
print(a)
b = copy.deepcopy(a)
print(b)
print(b[2] is b, b[2] is a)
[1, 2, [...]]
[1, 2, [...]]
True False

コピーした b の 2 番目は、元の a ではなく新しい b 自身を指しています。同じ仕組みで、1 つのオブジェクトを複数の場所から指している形も保たれます。次の例では、2 つの注文が同じ設定の辞書 shared を指しています。

import copy

shared = {"rate": 0.1}
orders = [{"id": 1, "conf": shared}, {"id": 2, "conf": shared}]
d = copy.deepcopy(orders)
print(d[0]["conf"] is d[1]["conf"], d[0]["conf"] is shared)
True False

コピー後も 2 つの注文は同じ設定(True)を共有していますが、それは元の shared とは別の新しい辞書(False)です。元の shared をコピー間で共有し続けたい場合は、deepcopy ではなく、必要な部分だけを自分でコピーします。なお、自作クラスでコピーのしかたを変えたいときは __copy__()・__deepcopy__() という特別なメソッドを定義できます(公式ドキュメントの copy モジュールのページに説明があります)。

コピーを気にしなくてよい場合(タプル・数値・文字列)

数値(int・float)・文字列(str)・タプル(tuple)などは、作ったあとに中身を変えられないイミュータブル(変更不可)な型です。中身を変えられないので、共有していても困ることがありません。

import copy

t = (1, "abc", (2, 3))
print(copy.copy(t) is t, copy.deepcopy(t) is t)

t2 = (1, [2, 3])
d = copy.deepcopy(t2)
print(d is t2, d[1] is t2[1])

x = 5
y = x
x += 1
print(x, y)
True True
False False
6 5
  • 1 行目:数値・文字列・タプルだけでできたタプルは、copy でも deepcopy でも元と同じものが返りました。コピーする必要がないためです。
  • 2 行目:タプルでも、中にリストが入っていると deepcopy は新しいタプルを作り、リストも複製しました。タプル自体は変えられなくても、中のリストは変えられるからです。
  • 3 行目:x += 1 は 5 を書き換えるのではなく、新しい 6 を作って x に付け替えます。y は 5 のままです(公式 FAQ の例と同じ動きです)。

まとめると、中身が数値・文字列だけのリストなら浅いコピーで十分、リストや辞書が入れ子になっていたら deepcopy を検討、という判断になります。

よくある間違いと直し方

1. [[0] * 3] * 3 で 1 か所変えると 3 行とも変わる

3×3 のマス目(二次元リスト)を作るつもりで [[0] * 3] * 3 と書くと、次のようになります。

grid = [[0] * 3] * 3
grid[0][0] = 1
print(grid)
print(grid[0] is grid[1] is grid[2])

grid = [[0] * 3 for _ in range(3)]
grid[0][0] = 1
print(grid)
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]
True
[[1, 0, 0], [0, 0, 0], [0, 0, 0]]

1 か所だけ変えたのに、3 行すべての先頭が 1 になりました。公式 FAQ(How do I create a multidimensional list?)にあるとおり、* でリストを繰り返してもコピーは作られず、同じ行のリストへの参照が 3 つ並ぶだけだからです。grid[0] is grid[1] is grid[2] が True になっていることからも分かります。

直し方は、内包表記 [[0] * 3 for _ in range(3)] で行ごとに新しいリストを作ることです。内側の [0] * 3 は中身が数値なので、* を使っても問題ありません。

2. 関数に渡したリストを中で変えると、呼び出し元も変わる

公式 FAQ には「Python の引数は代入によって渡される」とあります。関数に a を渡すことは、関数の中で prices = items と代入するのと同じで、コピーは作られません。

def add_tax(prices):
    for i in range(len(prices)):
        prices[i] = prices[i] * 110 // 100
    return prices

items = [100, 250]
result = add_tax(items)
print("items  =", items)
print("result =", result)
items  = [110, 275]
result = [110, 275]

税込み価格の新しいリストを作るつもりが、元の items まで税込みに書き換わっています。このあと items をもう一度 add_tax に渡すと、税が二重にかかってしまいます。元のデータを変えたくない関数は、新しいリストを作って返すように書きます。

def add_tax(prices):
    return [p * 110 // 100 for p in prices]

items = [100, 250]
result = add_tax(items)
print("items  =", items)
print("result =", result)
items  = [100, 250]
result = [110, 275]

関数の最初で prices = prices.copy()(入れ子なら copy.deepcopy(prices))としてから変更する方法もあります。逆に、関数の中で引数に = で別のリストを代入しても、呼び出し元には影響しません。

def rebind(nums):
    nums = [0, 0]
    print("中:", nums)

items = [1, 2]
rebind(items)
print("外:", items)
中: [0, 0]
外: [1, 2]

nums = [0, 0] は関数の中の名札 nums を新しいリストに付け替えるだけで、items が指しているリストには触れていないためです。「中身の変更は伝わる、付け替えは伝わらない」という、辞書の copy() のところと同じ考え方です。

3. デフォルト引数に [] を書くと、呼ぶたびに増える

def add_tag(tag, tags=[]):
    tags.append(tag)
    return tags

print(add_tag("python"))
print(add_tag("git"))
print(add_tag.__defaults__)
['python']
['python', 'git']
(['python', 'git'],)

2 回目の呼び出しは ['git'] になるはずが、前回の python が残っています。公式 FAQ(Why are default values shared between objects?)によると、デフォルト値は関数を定義したときに 1 回だけ作られ、呼び出すたびに作り直されるわけではありません。関数のデフォルト値が入っている __defaults__ を表示すると、そのリスト自体に python と git が溜まっていることが分かります。辞書 {} や自作クラスのインスタンスでも同じことが起きます。

FAQ が勧める直し方は、デフォルト値を None にして、関数の中で新しいリストを作ることです。

def add_tag(tag, tags=None):
    if tags is None:
        tags = []
    tags.append(tag)
    return tags

print(add_tag("python"))
print(add_tag("git"))
['python']
['git']

数値・文字列・タプル・None はイミュータブルなので、デフォルト値に使っても問題ありません(FAQ にも「定義上、変更から安全」とあります)。

4. += はリストでは「中身の変更」になる

x += 1 が新しい値への付け替えだったのに対し、リストの += は元のリストに要素を足す操作(extend と同じ)です。公式 FAQ でも、+= は型によって動きが違うと注意されています。

a = [1, 2]
b = a
b += [3]
print(a)

t = (1, 2)
u = t
u += (3,)
print(t, u)
[1, 2, 3]
(1, 2) (1, 2, 3)

リストでは b に足した 3 が a にも入りましたが、タプルでは u だけが新しいタプルになり、t は変わりません。b = b + [3] と書けば、リストでも新しいリストが作られ、a は変わりません。

よくある質問

list.copy() と copy.copy() はどう違いますか?

リストに使う限り、どちらも浅いコピーで結果は同じです。違いは、copy.copy() がリスト以外(自作クラスのインスタンスなど)にも使えることです。また公式ドキュメントによると、list を継承した自作クラスを .copy() やスライスでコピーすると元の list 型になることがあり、copy.copy() は通常、同じ型のまま返します。

いつも deepcopy を使っておけば安全ですか?

間違いは減りますが、おすすめしません。上で測ったように遅く、共有したいデータまで複製してしまうことがあります。中身が数値・文字列だけなら浅いコピー、入れ子のデータを丸ごと独立させたいときだけ deepcopy、と使い分けます。また、ファイルやソケット(通信の出入り口)などはコピーできない型として公式ドキュメントに挙げられています。

2 つの変数が同じものを指しているか、どう確かめますか?

a is b が True なら同じオブジェクトです。id(a) == id(b) でも確かめられます。入れ子の中まで調べたいときは a[0] is b[0] のように中の要素どうしを比べます。おかしな書き換えが起きたときは、まず is で共有されていないかを確認すると原因が早く見つかります。

JavaScript でも同じことが起きますか?

似たことが起きます。たとえば JavaScript の配列の filter が返す配列は、MDN で「浅いコピー」と説明されていて、取り出した中のオブジェクトを書き換えると元の配列から見ても変わります(関連記事「JavaScriptの配列メソッド入門」で実例を紹介しています)。ここで覚えた「外側だけのコピーか、中までのコピーか」という考え方は、ほかの言語でも役に立ちます。

まとめ

  • b = a はコピーではなく、同じオブジェクトに名前が増えるだけ。is で確かめられる
  • copy()・[:]・list()・copy.copy() は浅いコピー。入れ子の中身は共有される
  • 中まで別にしたいときは copy.deepcopy()。遅いので必要なときだけ使う
  • 二次元リストは内包表記で作る。デフォルト引数は None にする。引数のリストを変えない関数は新しいリストを返す

関連する記事・ツール

ABOUT ME
hr
hr
エンジニアとして働いている hr です。仕事や資格勉強で「こんなツールがあれば」と感じたものを、無料Webツールと解説記事にして発信しています。
記事URLをコピーしました