もうハマらない! list.copyとcopy.deepcopyの正しい使い分け

# 代入はコピーではなく、同じオブジェクトを指す参照共有です
a = [1, 2, 3]
b = a          # b は a と同じリストを参照

b[0] = 99      # b からの変更が a にも見える
print("a:", a)
print("b:", b)
print("同じオブジェクトか:", a is b)  # True なら同一オブジェクト

# イミュータブル(int)の変更は新しいオブジェクトの再代入になる
nums = [1, 2, 3]
copy_nums = nums.copy()  # シャローコピー
copy_nums[0] += 10       # イミュータブルなので新しい int を作って代入
print("nums:", nums)
print("copy_nums:", copy_nums)

# ミュータブル(リスト)はその場で変更される
nested = [[1, 2], [3, 4]]
copy_nested = nested.copy()  # シャローコピー
copy_nested[0][0] = 99       # ネスト内(ミュータブル)をその場で変更
print("nested:", nested)
print("copy_nested:", copy_nested)

# 上位だけコピーしても、内側は共有される典型例
config = [{"retry": 3}, {"timeout": 5}]
shallow = config.copy()  # シャローコピー

# 内側の辞書を書き換えると、両方に反映される
shallow[0]["retry"] = 10
print("config:", config)
print("shallow:", shallow)

# list.copy は最上位のリストを新規に作るが、要素参照は共有
a = [[0], [1], [2]]
b = a.copy()

print("a is b:", a is b)                       # 別オブジェクト
print("a[0] is b[0]:", a[0] is b[0])           # 内側は同じ参照

b.append([3])                                  # 上位リストの変更は独立
b[0].append(99)                                # ただし内側の要素は共有のため伝播
print("a:", a)
print("b:", b)

import copy

a = [1, 2, 3]
b = a[:]           # スライスでシャローコピー
c = a.copy()       # メソッドでシャローコピー
d = copy.copy(a)   # copy.copy でもシャローコピー

print(a is b, a is c, a is d)  # いずれも別オブジェクト
print(a == b == c == d)

import copy

a = [{"users": ["alice", "bob"]}]
b = copy.copy(a)    # または a[:] や a.copy()

b[0]["users"].append("carol")  # ネスト内を変更
print("a:", a)
print("b:", b)

import copy

a = [{"users": ["alice", "bob"]}]
d = copy.deepcopy(a)           # すべての階層を複製

d[0]["users"].append("carol")  # 変更は a に伝播しない
print("a:", a)
print("d:", d)

import copy

x = []
x.append(x)                  # 自分自身を参照する循環構造
y = copy.deepcopy(x)

print("x は自分自身を指すか:", x[0] is x)
print("y も自分自身を指すか:", y[0] is y)
print("x と y は別物か:", x is not y)

# 注意: 実行環境で時間は変わります。相対比較の目安です。
import copy, time

data = [{"vals": [i for i in range(1000)]} for _ in range(1000)]

t0 = time.perf_counter()
_ = data.copy()          # シャローコピー
t1 = time.perf_counter()
_ = copy.deepcopy(data)  # ディープコピー
t2 = time.perf_counter()

print("shallow:", format(t1 - t0, ".7f"), "seconds")
print("deep   :", format(t2 - t1, ".7f"), "seconds")

import copy

class Node:
    def __init__(self, name, children=None, cache=None):
        self.name = name
        self.children = list(children or [])
        self.cache = cache  # 例: 重いキャッシュは共有したいとする

    def __copy__(self):
        # シャローコピー: 子は同じ参照を共有、cache も共有
        new_obj = type(self)(self.name, self.children, self.cache)
        return new_obj

    def __deepcopy__(self, memo):
        # ディープコピー: 子は再帰的にコピー、cache は共有のままにする(方針の例)
        if id(self) in memo:
            return memo[id(self)]
        new_obj = type(self)(self.name, cache=self.cache)
        memo[id(self)] = new_obj
        new_obj.children = [copy.deepcopy(c, memo) for c in self.children]
        return new_obj

    def __repr__(self):
        return f"Node({self.name!r}, children={self.children}, cache={self.cache!r})"

root = Node("root", [Node("a"), Node("b")], cache={"heavy": True})
shallow = copy.copy(root)
deep = copy.deepcopy(root)

# 変更の影響範囲を確認
shallow.children[0].name = "A*"
deep.children[1].name = "B*"

print("root:", root)
print("shallow:", shallow)
print("deep:", deep)
print("cache 共有確認:", root.cache is shallow.cache, root.cache is deep.cache)

# トップレベルだけ独立していればよいケース
records = [3, 1, 2]
work = records.copy()  # または records[:] / copy.copy(records)
work.sort()
print("records:", records)  # 元は不変
print("work:", work)

import copy

grid = [[0, 0], [0, 0]]
unsafe = grid.copy()              # シャローコピー。内側が共有される
safe = copy.deepcopy(grid)        # ディープコピー。完全に独立

unsafe[0][0] = 1
safe[1][1] = 2

print("grid:", grid)              # unsafe の変更が grid に伝播
print("unsafe:", unsafe)
print("safe:", safe)

import copy

users = [{"id": 1, "tags": []}, {"id": 2, "tags": []}]
shallow = users.copy()
deep = copy.deepcopy(users)

shallow[0]["tags"].append("trial")  # 共有されているため元にも反映
deep[1]["tags"].append("pro")       # 完全に独立

print("users:", users)
print("shallow:", shallow)
print("deep:", deep)

import copy

a = [{"k": [1]}]
b = a.copy()               # シャロー
c = copy.deepcopy(a)       # ディープ

# 最上位リストは常に別物であるべき
assert a is not b and a is not c

# シャローコピーではネスト要素が共有される
assert a[0] is b[0]
assert a[0]["k"] is b[0]["k"]

# ディープコピーではネスト要素も別物
assert a[0] is not c[0]
assert a[0]["k"] is not c[0]["k"]

# 変更の独立性を確認
b[0]["k"].append(2)
assert a[0]["k"] == [1, 2]  # 共有されているため a にも影響

c[0]["k"].append(3)
assert a[0]["k"] == [1, 2]  # ディープコピーは影響しない

print("All tests passed.")