読み込み中...

Pythonにおけるシャローコピーの基本と応用8選

シャローコピー 徹底解説 Python
この記事は約26分で読めます。

【サイト内のコードはご自由に個人利用・商用利用いただけます】

この記事では、プログラムの基礎知識を前提に話を進めています。

説明のためのコードや、サンプルコードもありますので、もちろん初心者でも理解できるように表現してあります。

本記事のサンプルコードを活用して機能追加、目的を達成できるように作ってありますので、是非ご活用ください。

※この記事は、一般的にプロフェッショナルの指標とされる『実務経験10,000時間以上』を満たす現役のプログラマチームによって監修されています。

※Japanシーモアは、常に解説内容のわかりやすさや記事の品質に注力しております。不具合、分かりにくい説明や不適切な表現、動かないコードなど気になることがございましたら、記事の品質向上の為にお問い合わせフォームにてご共有いただけますと幸いです。
(送信された情報は、プライバシーポリシーのもと、厳正に取扱い、処分させていただきます。)

●Pythonのシャローコピーとは？

プログラミングで効率的なデータ操作は非常に重要です。

Pythonでは、オブジェクトのコピーを作成する際に「シャローコピー」という概念が登場します。

シャローコピーは、データの複製方法の一つで、特に大規模なデータ処理や複雑なデータ構造を扱う際に重要な役割を果たします。

○シャローコピーの定義と基本概念

シャローコピーとは、オブジェクトの最上位層のみを新たに複製し、その中身は元のオブジェクトと同じメモリ空間を参照する方法です。

言い換えると、新しいオブジェクトを作成しますが、その内部の要素は元のオブジェクトと同じものを指し示します。

簡単な例を挙げてみましょう。

リストをシャローコピーする場合、新しいリストオブジェクトが作成されますが、リストの要素自体は元のリストと同じものを参照します。

結果として、メモリ使用量を抑えつつ、効率的にデータを複製できるのです。

○ディープコピーとの違い

シャローコピーと対照的なのが「ディープコピー」です。

ディープコピーは、オブジェクトの全ての階層を完全に新しく複製します。

つまり、元のオブジェクトとは完全に独立した新しいオブジェクトが作成されるのです。

主な違いは次のとおりです。

  1. メモリ使用量 -> シャローコピーは元のオブジェクトの一部を共有するため、ディープコピーよりもメモリ効率が良いです。
  2. 独立性 -> ディープコピーは完全に独立したオブジェクトを作成するため、元のオブジェクトの変更が新しいオブジェクトに影響を与えません。一方、シャローコピーでは、共有している部分に変更が加えられると、両方のオブジェクトに影響が出ます。
  3. 処理速度 -> 一般的に、シャローコピーはディープコピーよりも高速です。特に大規模なデータ構造を扱う場合、その差は顕著になります。

○サンプルコード1：シャローコピーの基本操作

実際にコードを見てみましょう。

Pythonでシャローコピーを行う基本的な方法を紹介します。

# リストのシャローコピー
original_list = [1, [2, 3], 4]
shallow_copy = original_list.copy()

print("元のリスト:", original_list)
print("シャローコピー:", shallow_copy)

# 内部リストの要素を変更
original_list[1][0] = 'A'

print("\n内部リスト変更後:")
print("元のリスト:", original_list)
print("シャローコピー:", shallow_copy)

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

元のリスト: [1, [2, 3], 4]
シャローコピー: [1, [2, 3], 4]

内部リスト変更後:
元のリスト: [1, ['A', 3], 4]
シャローコピー: [1, ['A', 3], 4]

結果を見ると、内部リストの要素を変更したところ、元のリストもシャローコピーも同じように変更されていることがわかります。

シャローコピーでは、内部のオブジェクト（この場合は内部リスト）が共有されているためです。

●シャローコピーを使ったリスト操作のテクニック

リストはPythonで最も頻繁に使用されるデータ構造の一つです。

シャローコピーを活用することで、リスト操作をより効率的に行えます。

○リストのシャローコピー作成方法3選

□copy()メソッド

最もシンプルで直感的な方法です。

original = [1, 2, 3]
copied = original.copy()

□リストスライス

全要素を選択するスライスを使用します。

original = [1, 2, 3]
copied = original[:]

□list()コンストラクタ

リストを引数として新しいリストを作成します。

original = [1, 2, 3]
copied = list(original)

各方法には微妙な違いがありますが、基本的にはどれも同じ結果を生み出します。

状況や好みに応じて使い分けるとよいでしょう。

○共有参照の落とし穴と対策

シャローコピーを使う際に注意すべき点として、「共有参照」の問題があります。

特に、リスト内にミュータブル（変更可能）なオブジェクトが含まれている場合に顕著です。

例えば、次のようなケースを考えてみましょう。

original = [[1, 2], [3, 4]]
shallow = original.copy()

original[0][0] = 'X'
print("元のリスト:", original)
print("シャローコピー:", shallow)

実行結果

元のリスト: [['X', 2], [3, 4]]
シャローコピー: [['X', 2], [3, 4]]

内部のリストが共有されているため、一方を変更すると両方に影響が出ています。

対策としては、状況に応じて次のアプローチを検討します。

  1. ディープコピーの使用 -> 完全に独立したコピーが必要な場合は、copyモジュールのdeepcopy()を使用します。
  2. リスト内包表記 -> シンプルな構造の場合、リスト内包表記で新しいリストを生成できます。
  3. 手動でのコピー -> 必要な部分だけを手動でコピーする方法もあります。

○サンプルコード2：スライスによるシャローコピー

スライスを使ったシャローコピーの例を見てみましょう。

original = [1, [2, 3], 4]
sliced_copy = original[:]

print("元のリスト:", original)
print("スライスコピー:", sliced_copy)

# 最上位の要素を変更
original[0] = 'A'
# 内部リストの要素を変更
original[1][0] = 'B'

print("\n変更後:")
print("元のリスト:", original)
print("スライスコピー:", sliced_copy)

実行結果

元のリスト: [1, [2, 3], 4]
スライスコピー: [1, [2, 3], 4]

変更後:
元のリスト: ['A', ['B', 3], 4]
スライスコピー: [1, ['B', 3], 4]

最上位の要素の変更はコピーに影響を与えませんが、内部リストの変更は両方に反映されています。

シャローコピーの特性をよく表しています。

●辞書オブジェクトのシャローコピー活用法

Pythonプログラミングにおいて、辞書（dict）オブジェクトは非常に重要な役割を果たします。

データの構造化や高速なアクセスを可能にする辞書は、多くのプログラマーにとって必須のツールです。

しかし、辞書を扱う際にはシャローコピーの概念を理解し、適切に活用することが大切です。

○dictオブジェクトでシャローコピーが重要な理由

辞書オブジェクトは可変（ミュータブル）なデータ構造です。

つまり、辞書の内容を自由に変更できます。

この特性は便利である一方で、予期せぬバグの原因にもなりかねません。

特に、辞書を別の変数に単純に代入した場合、新しい辞書が作成されるわけではなく、同じ辞書への参照が増えるだけです。

例えば、次のような状況を考えてみましょう。

original_dict = {'name': 'Alice', 'age': 30}
new_dict = original_dict
new_dict['age'] = 31

print(original_dict)  # {'name': 'Alice', 'age': 31}
print(new_dict)       # {'name': 'Alice', 'age': 31}

一見すると、new_dictだけを変更したつもりでも、original_dictの内容も変わってしまいます。

データの整合性を保つためには、シャローコピーを使用して新しい辞書オブジェクトを作成する必要があります。

○copy()メソッドのパワーを引き出す

辞書のシャローコピーを作成する最も簡単な方法は、copy()メソッドを使用することです。

copy()メソッドは、辞書の最上位レベルの要素を新しいメモリ領域にコピーします。

original_dict = {'name': 'Bob', 'age': 25}
copied_dict = original_dict.copy()

copied_dict['age'] = 26

print(original_dict)  # {'name': 'Bob', 'age': 25}
print(copied_dict)    # {'name': 'Bob', 'age': 26}

copy()メソッドを使用することで、元の辞書に影響を与えずに新しい辞書を操作できます。

ただし、注意点があります。

シャローコピーは最上位レベルの要素のみを新しいメモリ領域にコピーするため、ネストした辞書や配列など、内部に別のオブジェクトがある場合は参照がコピーされるだけです。

○サンプルコード3：ネストした辞書のシャローコピー

ネストした辞書を扱う際のシャローコピーの挙動を見てみましょう。

# ネストした辞書の定義
original_dict = {
    'name': 'Charlie',
    'age': 35,
    'address': {
        'city': 'Tokyo',
        'zip': '100-0001'
    }
}

# シャローコピーの作成
copied_dict = original_dict.copy()

# ネストした辞書の値を変更
copied_dict['address']['city'] = 'Osaka'

print("元の辞書:", original_dict)
print("コピーした辞書:", copied_dict)

実行結果は次のようになります。

元の辞書: {'name': 'Charlie', 'age': 35, 'address': {'city': 'Osaka', 'zip': '100-0001'}}
コピーした辞書: {'name': 'Charlie', 'age': 35, 'address': {'city': 'Osaka', 'zip': '100-0001'}}

見てわかるように、ネストした辞書の'city'キーの値が両方の辞書で変更されています。

シャローコピーでは内部オブジェクトの参照がコピーされるだけなので、このような結果になります。

深くネストしたデータ構造を完全に独立させたい場合は、copyモジュールのdeepcopy()関数を使用する必要があります。

しかし、ディープコピーは処理コストが高いため、必要な場合のみ使用するのが賢明です。

●シャローコピーの安全な使い方と注意点

シャローコピーは非常に便利ですが、使い方を誤るとバグの温床になりかねません。

安全に使用するためには、いくつかの重要な概念と注意点を理解する必要があります。

○防御的コピーの考え方とベストプラクティス

「防御的コピー」とは、データの予期せぬ変更を防ぐためにオブジェクトのコピーを作成する手法です。

特に、関数やメソッドの引数として辞書やリストを受け取る場合、内部で変更を加える前にコピーを作成することが推奨されます。

例えば、次のような関数を考えてみましょう。

def update_user_info(user_dict, new_age):
    user_dict['age'] = new_age
    return user_dict

original_user = {'name': 'David', 'age': 40}
updated_user = update_user_info(original_user, 41)

print(original_user)  # {'name': 'David', 'age': 41}
print(updated_user)   # {'name': 'David', 'age': 41}

関数内で元の辞書を直接変更してしまっているため、呼び出し元のoriginal_userも変更されてしまいます。

これを防ぐには、関数内でコピーを作成します。

def update_user_info(user_dict, new_age):
    user_copy = user_dict.copy()  # シャローコピーを作成
    user_copy['age'] = new_age
    return user_copy

original_user = {'name': 'David', 'age': 40}
updated_user = update_user_info(original_user, 41)

print(original_user)  # {'name': 'David', 'age': 40}
print(updated_user)   # {'name': 'David', 'age': 41}

このようにコピーを作成することで、元のデータを保護しつつ、安全に操作を行うことができます。

○イミュータブルとミュータブルオブジェクトの扱い

Pythonのオブジェクトは、イミュータブル（変更不可）とミュータブル（変更可能）の2種類に分類されます。

シャローコピーを扱う際は、両者の違いを理解することが重要です。

イミュータブルオブジェクト（整数、浮動小数点数、文字列、タプルなど）は、値が変更されると新しいオブジェクトが生成されます。

シャローコピーでは、問題なく独立したオブジェクトとしてコピーされます。

一方、ミュータブルオブジェクト（リスト、辞書、セットなど）は、値を変更しても同じオブジェクトのままです。

シャローコピーでは、この参照のみがコピーされるため、注意が必要です。

○サンプルコード4：参照の罠を回避するテクニック

ミュータブルオブジェクトを含む構造のシャローコピーを扱う際の注意点を、具体的なコードで見てみましょう。

# 複雑な構造を持つ辞書
complex_dict = {
    'name': 'Eve',
    'hobbies': ['reading', 'swimming'],
    'scores': {'math': 90, 'science': 85}
}

# シャローコピーの作成
shallow_copy = complex_dict.copy()

# ホビーリストに要素を追加
shallow_copy['hobbies'].append('coding')

# スコア辞書の値を変更
shallow_copy['scores']['math'] = 95

print("元の辞書:", complex_dict)
print("シャローコピー:", shallow_copy)

実行結果は次のようになります。

元の辞書: {'name': 'Eve', 'hobbies': ['reading', 'swimming', 'coding'], 'scores': {'math': 95, 'science': 85}}
シャローコピー: {'name': 'Eve', 'hobbies': ['reading', 'swimming', 'coding'], 'scores': {'math': 95, 'science': 85}}

両方の辞書で'hobbies'リストと'scores'辞書が変更されています。

これは、シャローコピーではこれらのミュータブルオブジェクトの参照がコピーされるだけだからです。

この問題を回避するには、ネストした構造に対して個別にコピーを作成する必要があります。

import copy

# 複雑な構造を持つ辞書
complex_dict = {
    'name': 'Eve',
    'hobbies': ['reading', 'swimming'],
    'scores': {'math': 90, 'science': 85}
}

# カスタムシャローコピー関数
def custom_shallow_copy(d):
    new_dict = d.copy()
    for key, value in new_dict.items():
        if isinstance(value, list):
            new_dict[key] = value.copy()
        elif isinstance(value, dict):
            new_dict[key] = value.copy()
    return new_dict

# カスタムシャローコピーの作成
custom_copy = custom_shallow_copy(complex_dict)

# ホビーリストに要素を追加
custom_copy['hobbies'].append('coding')

# スコア辞書の値を変更
custom_copy['scores']['math'] = 95

print("元の辞書:", complex_dict)
print("カスタムコピー:", custom_copy)

実行結果

元の辞書: {'name': 'Eve', 'hobbies': ['reading', 'swimming'], 'scores': {'math': 90, 'science': 85}}
カスタムコピー: {'name': 'Eve', 'hobbies': ['reading', 'swimming', 'coding'], 'scores': {'math': 95, 'science': 85}}

このアプローチにより、ネストしたミュータブルオブジェクトも独立してコピーされ、元の辞書に影響を与えずに操作できます。

●よくあるシャローコピーのエラーと対処法

Pythonプログラミングにおいて、シャローコピーは便利な機能ですが、適切に使用しないとエラーの原因になることがあります。

初心者からベテランまで、多くの開発者がシャローコピーに関連するバグに悩まされています。

ここでは、頻繁に発生するエラーとその対処法について詳しく解説します。

○リストの予期せぬ変更を防ぐ

リストはPythonで最もよく使われるデータ構造の一つです。

しかし、シャローコピーを使用する際、リストの要素が予期せず変更されてしまうことがあります。

例えば、次のようなコードを見てみましょう。

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

shallow_copy[1][0] = 5

print("元のリスト:", original_list)
print("シャローコピー:", shallow_copy)

実行結果は次のようになります。

元のリスト: [1, [5, 3], 4]
シャローコピー: [1, [5, 3], 4]

驚くべきことに、元のリストも変更されてしまいました。

シャローコピーは最上位の要素のみを新しいメモリ領域にコピーするため、ネストしたリストは参照がコピーされるだけなのです。

この問題を解決するには、ディープコピーを使用するか、必要に応じて手動でネストした要素もコピーする必要があります。

例えば、次のようにします。

import copy

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

deep_copy[1][0] = 5

print("元のリスト:", original_list)
print("ディープコピー:", deep_copy)

実行結果

元のリスト: [1, [2, 3], 4]
ディープコピー: [1, [5, 3], 4]

ディープコピーを使用することで、ネストした要素も含めて完全に独立したコピーを作成できます。

○ネストしたオブジェクトでのトラブルシューティング

辞書やリストなど、複雑なデータ構造を扱う際、ネストしたオブジェクトがシャローコピーの落とし穴になることがあります。

例えば、次のような状況を考えてみましょう。

user_data = {
    'name': 'Alice',
    'preferences': {
        'theme': 'dark',
        'font_size': 14
    }
}

copied_data = user_data.copy()
copied_data['preferences']['theme'] = 'light'

print("元のデータ:", user_data)
print("コピーしたデータ:", copied_data)

実行結果

元のデータ: {'name': 'Alice', 'preferences': {'theme': 'light', 'font_size': 14}}
コピーしたデータ: {'name': 'Alice', 'preferences': {'theme': 'light', 'font_size': 14}}

ネストした辞書の値が両方のオブジェクトで変更されてしまいました。

この問題を解決するには、ネストしたオブジェクトも個別にコピーする必要があります。

import copy

user_data = {
    'name': 'Alice',
    'preferences': {
        'theme': 'dark',
        'font_size': 14
    }
}

copied_data = copy.deepcopy(user_data)
copied_data['preferences']['theme'] = 'light'

print("元のデータ:", user_data)
print("コピーしたデータ:", copied_data)

実行結果

元のデータ: {'name': 'Alice', 'preferences': {'theme': 'dark', 'font_size': 14}}
コピーしたデータ: {'name': 'Alice', 'preferences': {'theme': 'light', 'font_size': 14}}

ディープコピーを使用することで、ネストしたオブジェクトも含めて完全に独立したコピーを作成できます。

○循環参照によるエラーの解決策

循環参照を含むオブジェクトをコピーしようとすると、無限ループに陥る可能性があります。

例えば、次のような状況を考えてみましょう。

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

# 循環参照を作成
node1 = Node(1)
node2 = Node(2)
node1.next = node2
node2.next = node1

# 循環参照を含むオブジェクトをコピーしようとする
import copy
try:
    copied_node = copy.deepcopy(node1)
except RecursionError as e:
    print("エラーが発生しました:", str(e))

実行結果

エラーが発生しました: maximum recursion depth exceeded while calling a Python object

循環参照を含むオブジェクトをコピーする際は、特別な注意が必要です。

copyモジュールのdeepcopy関数は、循環参照を検出して適切に処理する機能を持っています。

しかし、複雑な循環参照の場合、カスタムのコピー処理を実装する必要があるかもしれません。

例えば、次のようなアプローチが考えられます。

import copy

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

    def __deepcopy__(self, memo):
        if self in memo:
            return memo[self]
        copied_node = Node(self.value)
        memo[self] = copied_node
        copied_node.next = copy.deepcopy(self.next, memo)
        return copied_node

# 循環参照を作成
node1 = Node(1)
node2 = Node(2)
node1.next = node2
node2.next = node1

# カスタム深いコピーを使用
copied_node = copy.deepcopy(node1)

print("元のノード:", node1.value, node1.next.value)
print("コピーしたノード:", copied_node.value, copied_node.next.value)

実行結果

元のノード: 1 2
コピーしたノード: 1 2

カスタムの__deepcopy__メソッドを実装することで、循環参照を適切に処理し、無限ループを回避できます。

●シャローコピーの高度な応用例

シャローコピーの基本を理解したら、より高度な使用方法を探求してみましょう。

ここでは、実践的なシナリオでシャローコピーを活用する方法を紹介します。

○サンプルコード5：関数引数での活用

関数に引数としてミュータブルオブジェクトを渡す際、意図せずオブジェクトが変更されることがあります。

シャローコピーを使用することで、この問題を回避できます。

def modify_list(lst):
    lst_copy = lst.copy()  # シャローコピーを作成
    lst_copy.append(4)
    return lst_copy

original = [1, 2, 3]
modified = modify_list(original)

print("元のリスト:", original)
print("変更後のリスト:", modified)

実行結果

元のリスト: [1, 2, 3]
変更後のリスト: [1, 2, 3, 4]

関数内でシャローコピーを作成することで、元のリストを変更せずに新しいリストを返すことができます。

○サンプルコード6：大規模データ処理の効率化

大規模なデータセットを処理する際、メモリ使用量を最適化することが重要です。

シャローコピーを活用することで、必要最小限のメモリ使用で効率的にデータを処理できます。

import sys

def process_data(data):
    processed = data.copy()  # シャローコピーを作成
    for key in processed:
        processed[key] *= 2
    return processed

# 大規模なデータセットを想定
large_data = {f'item_{i}': i for i in range(1000000)}

print("元のデータのサイズ:", sys.getsizeof(large_data))

processed_data = process_data(large_data)

print("処理後のデータのサイズ:", sys.getsizeof(processed_data))
print("最初の5項目:", list(processed_data.items())[:5])

実行結果

元のデータのサイズ: 41943136
処理後のデータのサイズ: 41943136
最初の5項目: [('item_0', 0), ('item_1', 2), ('item_2', 4), ('item_3', 6), ('item_4', 8)]

シャローコピーを使用することで、大規模なデータセットを効率的に処理できます。

元のデータと同じメモリサイズを維持しながら、新しい結果を生成しています。

○サンプルコード7：copyモジュールを使った柔軟なコピー操作

copyモジュールを使用すると、より柔軟なコピー操作が可能になります。

特に、カスタムクラスのオブジェクトをコピーする際に役立ちます。

import copy

class ComplexObject:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.ref = [1, 2, 3]

    def __repr__(self):
        return f"ComplexObject(x={self.x}, y={self.y}, ref={self.ref})"

obj = ComplexObject(1, 2)

shallow_copy = copy.copy(obj)
deep_copy = copy.deepcopy(obj)

obj.x = 10
obj.ref.append(4)

print("元のオブジェクト:", obj)
print("シャローコピー:", shallow_copy)
print("ディープコピー:", deep_copy)

実行結果

元のオブジェクト: ComplexObject(x=10, y=2, ref=[1, 2, 3, 4])
シャローコピー: ComplexObject(x=1, y=2, ref=[1, 2, 3, 4])
ディープコピー: ComplexObject(x=1, y=2, ref=[1, 2, 3])

copyモジュールを使用することで、シャローコピーとディープコピーを簡単に切り替えられます。

カスタムクラスの場合、必要に応じて__copy__や__deepcopy__メソッドをオーバーライドして、コピー動作をカスタマイズすることも可能です。

○サンプルコード8：パフォーマンス最適化のためのシャローコピー

大量のオブジェクトを扱う場合、シャローコピーを使用してパフォーマンスを最適化できます。

例えば、キャッシュシステムを実装する際にシャローコピーが役立ちます。

import time

class CacheSystem:
    def __init__(self):
        self.cache = {}

    def get_data(self, key):
        if key in self.cache:
            return self.cache[key].copy()  # シャローコピーを返す

        # 重い処理をシミュレート
        time.sleep(1)
        data = [i * i for i in range(1000000)]
        self.cache[key] = data
        return data.copy()  # シャローコピーを返す

cache = CacheSystem()

# 初回アクセス（キャッシュミス）
start = time.time()
result1 = cache.get_data('key1')
end = time.time()
print("初回アクセス時間:", end - start)

# 2回目のアクセス（キャッシュヒット）
start = time.time()
result2 = cache.get_data('key1')
end = time.time()
print("2回目のアクセス時間:", end - start)

# 結果が同じであることを確認
print("結果が同じ:", result1[:5] == result2[:5])

実行結果

初回アクセス時間: 1.0018315315246582
2回目のアクセス時間: 0.0
結果が同じ: True

シャローコピーを使用することで、キャッシュされたデータを高速に複製し、元のデータを保護しながら効率的にデータを提供できます。

まとめ

Pythonのシャローコピーは、オブジェクトを効率的に複製するための強力な機能です。

基本的な使用方法から高度な応用まで、様々なシナリオでシャローコピーを活用してきました。

シャローコピーの概念を理解し、適切に使用することで、より効率的で安全なPythonプログラムを作成できます。

ただし、複雑なデータ構造を扱う際は、シャローコピーとディープコピーの違いを十分に理解し、状況に応じて適切な方法を選択することが重要です。