【Python】浅いコピー(copy)と深いコピー(deepcopy)の違いについて解説

Pythonプログラミングを学ぶ中で、「浅いコピー」と「深いコピー」という言葉を耳にしたことがあるかもしれません。

これらは、オブジェクトをコピーする際に非常に重要な概念です。

この記事では、浅いコピーと深いコピーの違い、具体的な作成方法、そしてそれぞれの動作例をわかりやすく解説します。

目次から探す

浅いコピー (shallow copy)

浅いコピーの定義

浅いコピー(shallow copy)とは、オブジェクトのコピーを作成する際に、元のオブジェクトの最上位レベルの要素だけをコピーする方法です。

つまり、コピーされたオブジェクトの中に含まれる参照は元のオブジェクトと同じものを指します。

これにより、元のオブジェクトとコピーされたオブジェクトの間で、ネストされたオブジェクトの変更が共有されることになります。

浅いコピーの作成方法

浅いコピーを作成する方法はいくつかあります。

以下に代表的な方法を紹介します。

copyモジュールを使った浅いコピー

Pythonの標準ライブラリであるcopyモジュールを使用して浅いコピーを作成することができます。

以下はその例です。

import copy
original_list = [1, 2, [3, 4]]
shallow_copied_list = copy.copy(original_list)

スライスを使った浅いコピー

リストの場合、スライスを使って浅いコピーを作成することもできます。

以下はその例です。

original_list = [1, 2, [3, 4]]
shallow_copied_list = original_list[:]

list.copy()メソッドを使った浅いコピー

Python 3.3以降では、リストのcopy()メソッドを使って浅いコピーを作成することができます。

以下はその例です。

original_list = [1, 2, [3, 4]]
shallow_copied_list = original_list.copy()

浅いコピーの動作例

浅いコピーがどのように動作するかを具体的な例で見てみましょう。

リストの浅いコピー

以下のコードは、リストの浅いコピーを作成し、元のリストとコピーされたリストの間でネストされたオブジェクトが共有されることを示しています。

import copy
original_list = [1, 2, [3, 4]]
shallow_copied_list = copy.copy(original_list)
# ネストされたリストの要素を変更
shallow_copied_list[2][0] = 99
print("元のリスト:", original_list)  # 出力: 元のリスト: [1, 2, [99, 4]]
print("浅いコピーされたリスト:", shallow_copied_list)  # 出力: 浅いコピーされたリスト: [1, 2, [99, 4]]

この例では、shallow_copied_listのネストされたリストの要素を変更すると、original_listのネストされたリストの要素も変更されていることがわかります。

辞書の浅いコピー

辞書の場合も同様に浅いコピーを作成することができます。

以下はその例です。

import copy
original_dict = {'a': 1, 'b': {'c': 2}}
shallow_copied_dict = copy.copy(original_dict)
# ネストされた辞書の要素を変更
shallow_copied_dict['b']['c'] = 99
print("元の辞書:", original_dict)  # 出力: 元の辞書: {'a': 1, 'b': {'c': 99}}
print("浅いコピーされた辞書:", shallow_copied_dict)  # 出力: 浅いコピーされた辞書: {'a': 1, 'b': {'c': 99}}

この例でも、shallow_copied_dictのネストされた辞書の要素を変更すると、original_dictのネストされた辞書の要素も変更されていることがわかります。

浅いコピーの注意点

浅いコピーを使用する際にはいくつかの注意点があります。

ネストされたオブジェクトの扱い

浅いコピーは最上位レベルの要素だけをコピーするため、ネストされたオブジェクト(リストや辞書など)は元のオブジェクトと共有されます。

これにより、ネストされたオブジェクトの変更が元のオブジェクトとコピーされたオブジェクトの両方に影響を与える可能性があります。

例えば、以下のような場合です。

original_list = [1, 2, [3, 4]]
shallow_copied_list = original_list[:]
# ネストされたリストの要素を変更
shallow_copied_list[2][0] = 99
print("元のリスト:", original_list)  # 出力: 元のリスト: [1, 2, [99, 4]]
print("浅いコピーされたリスト:", shallow_copied_list)  # 出力: 浅いコピーされたリスト: [1, 2, [99, 4]]

このように、ネストされたオブジェクトの変更が元のオブジェクトにも影響を与えることを理解しておくことが重要です。

浅いコピーを使用する際には、この点を考慮して適切に使用する必要があります。

深いコピー (deep copy)

深いコピーの定義

深いコピー(deep copy)は、オブジェクトとその中に含まれるすべてのオブジェクトを再帰的にコピーする方法です。

これにより、元のオブジェクトとコピーされたオブジェクトは完全に独立した存在となります。

つまり、コピーされたオブジェクトを変更しても、元のオブジェクトには影響を与えません。

深いコピーの作成方法

深いコピーを作成するためには、Pythonの標準ライブラリであるcopyモジュールを使用します。

このモジュールにはdeepcopyという関数が用意されており、これを使って深いコピーを作成します。

copyモジュールを使った深いコピー

以下に、copyモジュールを使って深いコピーを作成する方法を示します。

import copy
# 元のリスト
original_list = [[1, 2, 3], [4, 5, 6]]
# 深いコピーを作成
deep_copied_list = copy.deepcopy(original_list)
# コピーされたリストを変更
deep_copied_list[0][0] = 99
# 結果を表示
print("元のリスト:", original_list)
print("深いコピーされたリスト:", deep_copied_list)

このコードを実行すると、以下のような結果が得られます。

元のリスト: [[1, 2, 3], [4, 5, 6]]
深いコピーされたリスト: [[99, 2, 3], [4, 5, 6]]

このように、深いコピーを行うことで、元のリストとコピーされたリストが完全に独立したものとなります。

深いコピーの動作例

リストの深いコピー

リストの深いコピーの例をもう少し詳しく見てみましょう。

以下のコードでは、ネストされたリストを深いコピーしています。

import copy
# 元のリスト
original_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 深いコピーを作成
deep_copied_list = copy.deepcopy(original_list)
# コピーされたリストを変更
deep_copied_list[1][1] = 99
# 結果を表示
print("元のリスト:", original_list)
print("深いコピーされたリスト:", deep_copied_list)

このコードを実行すると、以下のような結果が得られます。

元のリスト: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
深いコピーされたリスト: [[1, 2, 3], [4, 99, 6], [7, 8, 9]]

この例でも、元のリストとコピーされたリストが独立していることが確認できます。

辞書の深いコピー

次に、辞書の深いコピーの例を見てみましょう。

以下のコードでは、ネストされた辞書を深いコピーしています。

import copy
# 元の辞書
original_dict = {'a': 1, 'b': {'c': 2, 'd': 3}}
# 深いコピーを作成
deep_copied_dict = copy.deepcopy(original_dict)
# コピーされた辞書を変更
deep_copied_dict['b']['c'] = 99
# 結果を表示
print("元の辞書:", original_dict)
print("深いコピーされた辞書:", deep_copied_dict)

このコードを実行すると、以下のような結果が得られます。

元の辞書: {'a': 1, 'b': {'c': 2, 'd': 3}}
深いコピーされた辞書: {'a': 1, 'b': {'c': 99, 'd': 3}}

この例でも、元の辞書とコピーされた辞書が独立していることが確認できます。

深いコピーの注意点

再帰的なオブジェクトの扱い

深いコピーを行う際には、再帰的なオブジェクト(自己参照を含むオブジェクト)に注意が必要です。

再帰的なオブジェクトを深いコピーしようとすると、無限ループに陥る可能性があります。

copy.deepcopyはこの問題を回避するために、内部で再帰的なオブジェクトを検出し、適切に処理します。

以下に、再帰的なオブジェクトの例を示します。

import copy
# 再帰的なリスト
recursive_list = []
recursive_list.append(recursive_list)
# 深いコピーを作成
deep_copied_list = copy.deepcopy(recursive_list)
# 結果を表示
print("元のリスト:", recursive_list)
print("深いコピーされたリスト:", deep_copied_list)

このコードを実行すると、以下のような結果が得られます。

元のリスト: [[...]]
深いコピーされたリスト: [[...]]

このように、copy.deepcopyは再帰的なオブジェクトを適切に処理し、無限ループに陥ることなく深いコピーを作成します。

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

浅いコピーと深いコピーの違いを理解することは、Pythonプログラミングにおいて非常に重要です。

これらの違いを理解することで、適切なコピー方法を選択し、効率的なコードを書くことができます。

ここでは、メモリの使用量、パフォーマンスの違い、そして実際の使用例について詳しく解説します。

メモリの使用量

浅いコピーと深いコピーでは、メモリの使用量に大きな違いがあります。

  • 浅いコピー: 浅いコピーは、元のオブジェクトの参照をコピーするため、メモリの使用量は比較的少ないです。

元のオブジェクトとコピーされたオブジェクトは、同じネストされたオブジェクトを共有します。

  • 深いコピー: 深いコピーは、元のオブジェクトとそのすべてのネストされたオブジェクトを再帰的にコピーするため、メモリの使用量が増加します。

元のオブジェクトとコピーされたオブジェクトは、完全に独立したオブジェクトになります。

パフォーマンスの違い

パフォーマンスの観点からも、浅いコピーと深いコピーには違いがあります。

  • 浅いコピー: 浅いコピーは、元のオブジェクトの参照をコピーするだけなので、非常に高速です。

特に大きなデータ構造を扱う場合、浅いコピーは効率的です。

  • 深いコピー: 深いコピーは、元のオブジェクトとそのすべてのネストされたオブジェクトを再帰的にコピーするため、時間がかかります。

特にネストが深いデータ構造を扱う場合、深いコピーはパフォーマンスに影響を与える可能性があります。

実際の使用例

浅いコピーと深いコピーの違いを理解した上で、実際の使用例を見てみましょう。

浅いコピーが適している場合

浅いコピーが適しているのは、以下のような場合です。

  • ネストされたオブジェクトを変更しない場合: 元のオブジェクトとコピーされたオブジェクトが同じネストされたオブジェクトを共有しても問題ない場合、浅いコピーが適しています。
  • パフォーマンスが重要な場合: 大きなデータ構造を高速にコピーする必要がある場合、浅いコピーが適しています。
import copy
# 元のリスト
original_list = [1, 2, [3, 4]]
# 浅いコピー
shallow_copied_list = copy.copy(original_list)
# ネストされたリストを変更
shallow_copied_list[2][0] = 99
print("元のリスト:", original_list)  # 元のリスト: [1, 2, [99, 4]]
print("浅いコピーされたリスト:", shallow_copied_list)  # 浅いコピーされたリスト: [1, 2, [99, 4]]

深いコピーが適している場合

深いコピーが適しているのは、以下のような場合です。

  • ネストされたオブジェクトを変更する場合: 元のオブジェクトとコピーされたオブジェクトが独立している必要がある場合、深いコピーが適しています。
  • データの完全な独立性が必要な場合: 元のオブジェクトとコピーされたオブジェクトが完全に独立している必要がある場合、深いコピーが適しています。
import copy
# 元のリスト
original_list = [1, 2, [3, 4]]
# 深いコピー
deep_copied_list = copy.deepcopy(original_list)
# ネストされたリストを変更
deep_copied_list[2][0] = 99
print("元のリスト:", original_list)  # 元のリスト: [1, 2, [3, 4]]
print("深いコピーされたリスト:", deep_copied_list)  # 深いコピーされたリスト: [1, 2, [99, 4]]

以上のように、浅いコピーと深いコピーにはそれぞれの適用場面があります。

具体的な状況に応じて、適切なコピー方法を選択することが重要です。

実践例

ここでは、浅いコピーと深いコピーの具体的な使用例を見ていきます。

実際のコードを通じて、どのように動作するのかを確認しましょう。

浅いコピーと深いコピーの比較コード

まずは、浅いコピーと深いコピーの違いを示すコードを見てみましょう。

import copy
# 元のリストを作成
original_list = [[1, 2, 3], [4, 5, 6]]
# 浅いコピーを作成
shallow_copied_list = copy.copy(original_list)
# 深いコピーを作成
deep_copied_list = copy.deepcopy(original_list)
# 元のリストとコピーのリストを表示
print("元のリスト:", original_list)
print("浅いコピー:", shallow_copied_list)
print("深いコピー:", deep_copied_list)
# 元のリストのネストされたリストを変更
original_list[0][0] = 99
# 変更後のリストを表示
print("\n変更後の元のリスト:", original_list)
print("変更後の浅いコピー:", shallow_copied_list)
print("変更後の深いコピー:", deep_copied_list)

このコードを実行すると、以下のような結果が得られます。

元のリスト: [[1, 2, 3], [4, 5, 6]]
浅いコピー: [[1, 2, 3], [4, 5, 6]]
深いコピー: [[1, 2, 3], [4, 5, 6]]

変更後の元のリスト: [[99, 2, 3], [4, 5, 6]]
変更後の浅いコピー: [[99, 2, 3], [4, 5, 6]]
変更後の深いコピー: [[1, 2, 3], [4, 5, 6]]

この結果からわかるように、浅いコピーでは元のリストのネストされたリストの変更が反映されますが、深いコピーでは反映されません。

実際のプロジェクトでの応用例

実際のプロジェクトでは、浅いコピーと深いコピーをどのように使い分けるかが重要です。

以下にいくつかの応用例を示します。

浅いコピーの応用例

浅いコピーは、ネストされていないオブジェクトや、ネストされたオブジェクトの変更が不要な場合に適しています。

# 浅いコピーの応用例
original_list = [1, 2, 3]
shallow_copied_list = original_list.copy()
# 元のリストを変更
original_list[0] = 99
print("元のリスト:", original_list)
print("浅いコピー:", shallow_copied_list)

この場合、浅いコピーで十分です。

深いコピーの応用例

深いコピーは、ネストされたオブジェクトが多く、元のオブジェクトの変更がコピーに影響を与えないようにしたい場合に適しています。

import copy
# 深いコピーの応用例
original_dict = {'a': [1, 2, 3], 'b': [4, 5, 6]}
deep_copied_dict = copy.deepcopy(original_dict)
# 元の辞書を変更
original_dict['a'][0] = 99
print("元の辞書:", original_dict)
print("深いコピー:", deep_copied_dict)

この場合、深いコピーを使うことで、元の辞書の変更がコピーに影響を与えません。

浅いコピーと深いコピーの選び方

浅いコピーと深いコピーの選び方は、以下のポイントを考慮すると良いでしょう。

  1. ネストされたオブジェクトの有無: ネストされたオブジェクトが存在しない場合は、浅いコピーで十分です。
  2. パフォーマンス: 深いコピーは浅いコピーに比べてメモリと時間を多く消費します。

必要な場合にのみ深いコピーを使用しましょう。

  1. 変更の影響: 元のオブジェクトの変更がコピーに影響を与えないようにしたい場合は、深いコピーを選びます。

これらのポイントを考慮して、適切なコピー方法を選択することが重要です。

目次から探す