読み込み中...

Pythonを使った重複チェックの基本と活用10選

重複チェック 徹底解説 Python
この記事は約29分で読めます。

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

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

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

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

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

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

●Pythonで重複チェックが必要な理由とは？

プログラミングで、データの重複チェックは非常に重要な作業です。

特にPythonを使用する場合、効率的な重複チェックは多くの場面で必要不可欠となります。

なぜ重複チェックが必要なのでしょうか？

その理由を詳しく見ていきましょう。

○データ整理の重要性

データ整理は、プログラミングにおいて基本中の基本です。

重複したデータが存在すると、様々な問題が発生する可能性があります。

例えば、顧客情報を管理するシステムで同じ顧客が複数回登録されていると、正確な分析や適切な対応が困難になります。

Pythonを使用してデータ整理を行う際、重複チェックは非常に有効です。

重複を除去することで、データの一貫性が保たれ、後続の処理がスムーズに進みます。

また、整理されたデータは、機械学習モデルの精度向上にも寄与します。

○パフォーマンス向上のカギ

重複チェックは、プログラムのパフォーマンス向上にも大きく貢献します。

不要なデータを除去することで、処理速度が向上し、メモリ使用量も削減できます。

特に大規模なデータセットを扱う場合、この効果は顕著です。

例えば、1000万件のレコードがあるデータベースで、そのうち10%が重複データだとします。

重複を除去することで、処理するデータ量が900万件に減り、処理時間が大幅に短縮されます。

○バグ防止と品質管理

重複データの存在は、予期せぬバグの原因となることがあります。

例えば、ユーザーIDが重複していると、誤ったユーザーに情報が紐付けられる可能性があります。

こうしたバグは、ユーザー体験を損なうだけでなく、セキュリティリスクにもつながります。

Pythonを使った重複チェックを実装することで、このようなリスクを最小限に抑えられます。

結果として、プログラムの品質が向上し、ユーザーの信頼を得ることができます。

●基本の重複チェックテクニック

Pythonには、重複チェックを行うための様々な方法があります。ここでは、基本的なテクニックを3つ紹介します。

それぞれの特徴を理解し、状況に応じて適切な方法を選択できるようになりましょう。

○サンプルコード1：リストを使った重複チェック

リストは、Pythonで最もよく使用されるデータ構造の1つです。

リストを使った重複チェックは、シンプルで理解しやすい方法です。

次のサンプルコードを見てみましょう。

def find_duplicates(data):
    seen = []
    duplicates = []
    for item in data:
        if item in seen:
            duplicates.append(item)
        else:
            seen.append(item)
    return duplicates

# 使用例
my_list = [1, 2, 3, 4, 2, 5, 6, 3, 7, 8]
result = find_duplicates(my_list)
print("重複要素:", result)

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

重複要素: [2, 3]

このメソッドは、リストを順番に走査しながら、既に見たことのある要素を別のリストに追加していきます。

シンプルですが、大規模なデータセットでは効率が悪くなる可能性があります。

○サンプルコード2：集合（set）を活用した高速な重複検出

Pythonの集合（set）を使うと、より効率的に重複を検出できます。

集合は重複を許さないデータ構造なので、重複チェックに適しています。

次のサンプルコードを見てみましょう。

def find_duplicates_set(data):
    seen = set()
    duplicates = set()
    for item in data:
        if item in seen:
            duplicates.add(item)
        else:
            seen.add(item)
    return list(duplicates)

# 使用例
my_list = [1, 2, 3, 4, 2, 5, 6, 3, 7, 8]
result = find_duplicates_set(my_list)
print("重複要素:", result)

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

重複要素: [2, 3]

集合を使用することで、要素の検索が高速化され、大規模なデータセットでも効率的に動作します。

ただし、元のリストの順序は保持されないことに注意が必要です。

○サンプルコード3：カウンターで重複回数を把握

時には、単に重複があるかどうかだけでなく、各要素が何回出現したかを知りたい場合があります。

そんなときは、PythonのcollectionsモジュールにあるCounterクラスが便利です。

次のサンプルコードを見てみましょう。

from collections import Counter

def count_duplicates(data):
    count = Counter(data)
    return {item: freq for item, freq in count.items() if freq > 1}

# 使用例
my_list = [1, 2, 3, 4, 2, 5, 6, 3, 7, 8, 2]
result = count_duplicates(my_list)
print("重複要素と出現回数:", result)

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

重複要素と出現回数: {2: 3, 3: 2}

Counterを使うことで、各要素の出現回数を簡単に把握できます。

この方法は、データの分布を理解したい場合や、特定の閾値以上出現する要素を見つけたい場合に特に有用です。

●応用的な重複チェック手法

Pythonの重複チェックスキルを磨くと、コーディングの効率が格段に上がります。

基本テクニックを押さえたら、次は応用編に挑戦しましょう。

より複雑なデータ構造や大規模なデータセットを扱う場面で役立つ手法を紹介します。

○サンプルコード4：辞書を使った複雑なデータの重複確認

実務では、単純なリストだけでなく、複雑な構造を持つデータを扱うことが多々あります。

辞書（dict）を活用すれば、複数の属性を持つオブジェクトの重複も効率的にチェックできます。

def find_duplicates_dict(data, key):
    seen = {}
    duplicates = []
    for item in data:
        item_key = item[key]
        if item_key in seen:
            duplicates.append(item)
        else:
            seen[item_key] = item
    return duplicates

# 使用例
users = [
    {"id": 1, "name": "Alice", "email": "alice@example.com"},
    {"id": 2, "name": "Bob", "email": "bob@example.com"},
    {"id": 3, "name": "Charlie", "email": "charlie@example.com"},
    {"id": 4, "name": "Alice", "email": "alice2@example.com"},
]

result = find_duplicates_dict(users, "name")
print("名前が重複しているユーザー:", result)

実行結果はこうなります。

名前が重複しているユーザー: [{'id': 4, 'name': 'Alice', 'email': 'alice2@example.com'}]

辞書を使うと、特定のキーに基づいて重複をチェックできます。

例えば、ユーザー情報の中で名前が重複している場合を検出できます。

実務では、顧客データベースの整理や、システムログの解析などで活用できるテクニックです。

○サンプルコード5：リスト内包表記で簡潔に重複を除去

Pythonの魅力の一つ、リスト内包表記を使えば、重複除去のコードをより簡潔に書けます。

短くて読みやすいコードは、チーム開発で重宝されます。

def remove_duplicates_concise(data):
    return list(dict.fromkeys(data))

# 使用例
original_list = [1, 2, 3, 2, 4, 3, 5]
unique_list = remove_duplicates_concise(original_list)
print("重複を除去したリスト:", unique_list)

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

重複を除去したリスト: [1, 2, 3, 4, 5]

リスト内包表記を使うと、コードがすっきりします。

重複除去だけでなく、データの変換や条件付きフィルタリングなど、様々な場面で活用できます。

コードの可読性が上がり、バグの混入リスクも減少します。

○サンプルコード6：Pandasを使った大規模データの重複処理

大規模なデータセットを扱う場合、Pandasライブラリが非常に便利です。

データフレームという構造を使って、効率的に重複をチェックし、処理できます。

import pandas as pd

def process_duplicates_pandas(data):
    df = pd.DataFrame(data)
    duplicates = df[df.duplicated()]
    df_no_duplicates = df.drop_duplicates()
    return duplicates, df_no_duplicates

# 使用例
data = [
    {"id": 1, "name": "Alice", "age": 30},
    {"id": 2, "name": "Bob", "age": 25},
    {"id": 3, "name": "Charlie", "age": 35},
    {"id": 4, "name": "Alice", "age": 30},
]

duplicates, unique_data = process_duplicates_pandas(data)
print("重複データ:\n", duplicates)
print("\n重複を除去したデータ:\n", unique_data)

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

重複データ:
    id   name  age
3   4  Alice   30

重複を除去したデータ:
    id     name  age
0   1    Alice   30
1   2      Bob   25
2   3  Charlie   35

Pandasを使うと、大量のデータでも高速に重複チェックができます。

また、重複の条件を細かく指定したり、重複を除去した後のデータ操作も簡単です。

データ分析や機械学習の前処理で重宝するテクニックです。

●特殊なケースでの重複チェック

単純な完全一致だけでなく、より複雑な条件での重複チェックが必要になることもあります。

ここでは、特殊なケースでの重複チェック方法を紹介します。

○サンプルコード7：部分一致による重複検出

テキストデータを扱う際、完全一致ではなく部分一致で重複を検出したい場合があります。

例えば、住所データの重複チェックなどで役立ちます。

def find_partial_duplicates(data, threshold=0.8):
    from difflib import SequenceMatcher

    duplicates = []
    for i, item1 in enumerate(data):
        for j, item2 in enumerate(data[i+1:], start=i+1):
            similarity = SequenceMatcher(None, item1, item2).ratio()
            if similarity >= threshold:
                duplicates.append((item1, item2, similarity))
    return duplicates

# 使用例
addresses = [
    "123 Main St, Anytown, USA",
    "456 Elm St, Somewhere, USA",
    "123 Main Street, Anytown, USA",
    "789 Oak Ave, Nowhere, USA"
]

partial_duplicates = find_partial_duplicates(addresses)
for dup in partial_duplicates:
    print(f"類似度 {dup[2]:.2f}: '{dup[0]}' と '{dup[1]}'")

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

類似度 0.89: '123 Main St, Anytown, USA' と '123 Main Street, Anytown, USA'

部分一致による重複検出は、データクレンジングで非常に重要です。

例えば、顧客データベースで、同じ人物が微妙に異なる住所で登録されているケースを見つけ出せます。

○サンプルコード8：大文字小文字を区別しない重複チェック

テキストデータの重複チェックでは、大文字小文字の違いを無視したい場合があります。

例えば、メールアドレスの重複チェックなどで使えます。

def case_insensitive_duplicates(data):
    seen = set()
    duplicates = []
    for item in data:
        lower_item = item.lower()
        if lower_item in seen:
            duplicates.append(item)
        else:
            seen.add(lower_item)
    return duplicates

# 使用例
emails = [
    "user@example.com",
    "admin@example.com",
    "User@Example.com",
    "support@example.com"
]

case_insensitive_dups = case_insensitive_duplicates(emails)
print("大文字小文字を区別しない重複:", case_insensitive_dups)

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

大文字小文字を区別しない重複: ['User@Example.com']

大文字小文字を区別しない重複チェックは、ユーザー名やメールアドレスの重複を防ぐのに役立ちます。

データベースの整合性を保つ上で、非常に重要なテクニックです。

○サンプルコード9：正規表現を用いた高度な重複パターン検索

より複雑なパターンの重複を検出したい場合、正規表現が強力な武器となります。

例えば、電話番号の形式が統一されていない場合の重複チェックなどに使えます。

import re

def regex_duplicate_check(data, pattern):
    seen = set()
    duplicates = []
    for item in data:
        match = re.search(pattern, item)
        if match:
            key = match.group()
            if key in seen:
                duplicates.append(item)
            else:
                seen.add(key)
    return duplicates

# 使用例
phone_numbers = [
    "+1 (123) 456-7890",
    "123-456-7890",
    "+1 123.456.7890",
    "(987) 654-3210",
    "1234567890"
]

pattern = r'\d{3}[\s.-]?\d{3}[\s.-]?\d{4}'
regex_dups = regex_duplicate_check(phone_numbers, pattern)
print("正規表現で検出した重複:", regex_dups)

実行結果はこうなります。

正規表現で検出した重複: ['+1 123.456.7890', '1234567890']

正規表現を使った重複チェックは、形式が統一されていないデータの中から本質的な重複を見つけ出すのに役立ちます。

例えば、異なる国際電話の形式で入力された同じ電話番号を特定できます。

●パフォーマンス最適化テクニック

Pythonで重複チェックを行う際、効率性は非常に重要です。

特に大規模なデータセットを扱う場合、パフォーマンスの最適化が不可欠になります。

ここでは、メモリ使用量を抑えつつ高速に動作する重複チェックの方法を紹介します。

○サンプルコード10：ジェネレータを使った省メモリ重複チェック

大量のデータを一度にメモリに読み込むと、システムに負荷がかかり、処理速度が低下する可能性があります。

ジェネレータを使用すると、データを一つずつ処理できるため、メモリ使用量を大幅に削減できます。

def memory_efficient_duplicates(file_path):
    seen = set()
    duplicates = set()

    def line_generator():
        with open(file_path, 'r') as file:
            for line in file:
                yield line.strip()

    for line in line_generator():
        if line in seen:
            duplicates.add(line)
        else:
            seen.add(line)

    return duplicates

# 使用例
file_path = 'large_data.txt'
result = memory_efficient_duplicates(file_path)
print("重複行:", result)

このコードは、大きなテキストファイルから重複する行を見つけ出すのに適しています。

ファイルを一行ずつ読み込むため、メモリ使用量を最小限に抑えられます。

実行結果は、ファイルの内容によって変わりますが、例えば次のようになるでしょう。

重複行: {'repeat line 1', 'repeat line 2', 'repeat line 3'}

ジェネレータを使用することで、数ギガバイトの大きなファイルでも効率的に処理できます。

メモリ使用量を抑えながら重複チェックを行えるため、システムリソースに制限がある環境でも活用できます。

●重複チェックにおける注意点

重複チェックは一見単純に見えますが、実際には様々な落とし穴が潜んでいます。

効果的な重複チェックを行うためには、いくつかの重要な点に注意を払う必要があります。

○データ型による挙動の違い

Pythonでは、データ型によって重複チェックの挙動が異なることがあります。

例えば、リストと辞書では重複の扱いが違います。

# リストの場合
list_example = [1, 2, 2, 3, 3, 3]
print("リストの重複除去:", list(set(list_example)))

# 辞書の場合
dict_example = {'a': 1, 'b': 2, 'c': 2, 'd': 3}
print("辞書のキーの重複除去:", list(dict_example.keys()))
print("辞書の値の重複除去:", list(set(dict_example.values())))

実行結果はこうなります。

リストの重複除去: [1, 2, 3]
辞書のキーの重複除去: ['a', 'b', 'c', 'd']
辞書の値の重複除去: [1, 2, 3]

リストでは重複する要素が簡単に除去できますが、辞書ではキーが一意であるため、キーの重複は自動的に排除されます。

値の重複は別途チェックする必要があります。

データ型の特性を理解し、適切な方法で重複チェックを行うことが大切です。

○大規模データ処理時の考慮事項

大規模なデータセットを扱う際は、メモリ使用量と処理速度のバランスを取ることが重要です。

全てのデータをメモリに読み込むのではなく、チャンク（一定量のデータ）ごとに処理する方法が効果的です。

def process_large_data(file_path, chunk_size=1000):
    seen = set()
    duplicates = set()

    with open(file_path, 'r') as file:
        while True:
            chunk = file.readlines(chunk_size)
            if not chunk:
                break
            for line in chunk:
                line = line.strip()
                if line in seen:
                    duplicates.add(line)
                else:
                    seen.add(line)

    return duplicates

# 使用例
file_path = 'very_large_data.txt'
result = process_large_data(file_path)
print("重複行の数:", len(result))

チャンク単位で処理することで、メモリ使用量を制御しながら大規模なデータを効率的に処理できます。

実行結果は、ファイルの内容に応じて変わりますが、例えば次のようになるでしょう。

重複行の数: 1234

大規模データを扱う際は、処理時間とメモリ使用量のトレードオフを考慮し、適切なチャンクサイズを選択することが重要です。

○重複の定義と業務要件の整合性

重複チェックを行う際、「何をもって重複とするか」という定義が非常に重要です。

業務要件に応じて、完全一致だけでなく、部分一致や類似度による重複判定が必要になる場合もあります。

from difflib import SequenceMatcher

def check_similarity(str1, str2, threshold=0.8):
    return SequenceMatcher(None, str1, str2).ratio() >= threshold

def find_similar_items(data, threshold=0.8):
    similar_pairs = []
    for i, item1 in enumerate(data):
        for j, item2 in enumerate(data[i+1:], start=i+1):
            if check_similarity(item1, item2, threshold):
                similar_pairs.append((item1, item2))
    return similar_pairs

# 使用例
items = [
    "Python programming",
    "Python coding",
    "Java development",
    "JavaScript coding"
]

similar = find_similar_items(items)
for pair in similar:
    print(f"類似項目: '{pair[0]}' と '{pair[1]}'")

このコードは、文字列の類似度に基づいて重複（類似）項目を検出します。

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

類似項目: 'Python programming' と 'Python coding'

業務要件に応じて、重複の定義を柔軟に調整することが大切です。

完全一致だけでなく、類似度や部分一致なども考慮に入れることで、より効果的な重複チェックが可能になります。

●よくあるエラーと対処法

Pythonで重複チェックを行う際、様々なエラーに遭遇することがあります。

エラーに適切に対処できれば、コードの品質と信頼性が向上します。

ここでは、重複チェック時によく発生するエラーとその解決策を詳しく解説します。

○KeyErrorの回避策

辞書を使って重複チェックを行う際、存在しないキーにアクセスしようとするとKeyErrorが発生します。

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

def check_duplicates(data):
    count = {}
    for item in data:
        if count[item] > 0:  # KeyErrorが発生する可能性がある
            print(f"{item}は重複しています")
        count[item] = count[item] + 1  # KeyErrorが発生する可能性がある

# 使用例
my_list = [1, 2, 3, 2, 4, 1]
check_duplicates(my_list)

このコードを実行すると、KeyErrorが発生してしまいます。

KeyErrorを回避するには、get()メソッドやdefaultdictを使用する方法があります。

from collections import defaultdict

def check_duplicates_safe(data):
    count = defaultdict(int)
    for item in data:
        count[item] += 1
        if count[item] > 1:
            print(f"{item}は重複しています")

# 使用例
my_list = [1, 2, 3, 2, 4, 1]
check_duplicates_safe(my_list)

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

2は重複しています
1は重複しています

defaultdict(int)を使用することで、新しいキーが追加されるたびに自動的に0が初期値として設定されます。

KeyErrorを回避しつつ、コードがシンプルになります。

○メモリ不足の解決方法

大規模なデータセットで重複チェックを行う際、メモリ不足に陥ることがあります。

全てのデータをメモリに読み込むのではなく、ストリーミング処理を行うことで解決できます。

メモリ効率の良いコード例を見てみましょう。

def memory_efficient_duplicates(filename):
    seen = set()
    duplicates = set()
    with open(filename, 'r') as file:
        for line in file:
            line = line.strip()
            if line in seen:
                duplicates.add(line)
            else:
                seen.add(line)
    return duplicates

# 使用例
filename = 'large_data.txt'
result = memory_efficient_duplicates(filename)
print("重複行:", result)

このコードは、ファイルを一行ずつ読み込みながら処理を行います。

大規模なファイルでも、メモリ使用量を最小限に抑えられます。

実行結果は、ファイルの内容に応じて変わりますが、例えば次のようになるでしょう。

重複行: {'repeated line 1', 'repeated line 2', 'repeated line 3'}

ストリーミング処理を採用することで、メモリ効率が大幅に向上し、大規模データセットでも問題なく重複チェックを行えます。

○無限ループに陥らないためのコツ

重複チェックのアルゴリズムを実装する際、意図せず無限ループに陥ってしまうことがあります。

特に、再帰的なアプローチを取る場合に注意が必要です。

無限ループを防ぐには、適切な終了条件を設定することが重要です。

def find_duplicates_recursive(data, start=0, seen=None, duplicates=None):
    if seen is None:
        seen = set()
    if duplicates is None:
        duplicates = set()

    if start >= len(data):
        return duplicates

    item = data[start]
    if item in seen:
        duplicates.add(item)
    else:
        seen.add(item)

    return find_duplicates_recursive(data, start + 1, seen, duplicates)

# 使用例
my_list = [1, 2, 3, 2, 4, 1, 5, 6, 3]
result = find_duplicates_recursive(my_list)
print("重複要素:", result)

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

重複要素: {1, 2, 3}

この再帰的アプローチでは、start引数を使って処理の進行状況を追跡し、リストの終端に達したら再帰を終了します。

また、デフォルト引数を使用することで、関数の呼び出しを簡潔に保ちつつ、必要な状態を維持しています。

●Pythonの重複チェック機能の今後

Pythonの重複チェック機能は、データ処理や解析の基本的かつ重要な要素です。

技術の進歩に伴い、より高度で効率的な重複チェック手法が登場しつつあります。

ここでは、将来的な展望について考えてみましょう。

○機械学習を活用した重複検出の可能性

機械学習技術の発展により、より柔軟で高度な重複検出が可能になりつつあります。

例えば、自然言語処理を用いて、意味的に類似したテキストを重複として検出する方法が考えられます。

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

def ml_based_duplicate_detection(texts, threshold=0.8):
    vectorizer = TfidfVectorizer()
    tfidf_matrix = vectorizer.fit_transform(texts)

    similarity_matrix = cosine_similarity(tfidf_matrix)

    duplicates = []
    for i in range(len(texts)):
        for j in range(i + 1, len(texts)):
            if similarity_matrix[i][j] > threshold:
                duplicates.append((texts[i], texts[j]))

    return duplicates

# 使用例
texts = [
    "Python is a great programming language",
    "Python is an awesome coding language",
    "Java is also a popular programming language",
    "Machine learning is revolutionizing technology"
]

result = ml_based_duplicate_detection(texts)
for pair in result:
    print(f"類似テキスト: '{pair[0]}' と '{pair[1]}'")

このコードは、TF-IDFとコサイン類似度を使用して、テキスト間の類似性を計算します。

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

類似テキスト: 'Python is a great programming language' と 'Python is an awesome coding language'

機械学習を活用することで、単純な文字列比較では検出できない、意味的な重複も見つけることができます。

今後、より高度な自然言語処理技術や深層学習モデルを組み込むことで、さらに精度の高い重複検出が可能になるでしょう。

○ビッグデータ時代における重複チェックの重要性

ビッグデータの時代において、効率的な重複チェックはますます重要になっています。

大量のデータを高速かつ正確に処理するためには、分散処理技術との組み合わせが必要になるかもしれません。

from pyspark.sql import SparkSession
from pyspark.sql.functions import count

def big_data_duplicate_check(file_path):
    spark = SparkSession.builder.appName("DuplicateCheck").getOrCreate()

    df = spark.read.csv(file_path, header=True)
    duplicates = df.groupBy(df.columns).agg(count("*").alias("count")).filter("count > 1")

    return duplicates

# 使用例（実際の環境でSparkが設定されている必要があります）
file_path = "hdfs://your_hdfs_path/big_data.csv"
result = big_data_duplicate_check(file_path)
result.show()

このコードは、Apache Sparkを使用して大規模データの重複チェックを行います。

実際の出力は、データの内容によって異なりますが、例えば次のようになるでしょう。

+----+-----+-----+
| id | name| count|
+----+-----+-----+
|  1 |Alice|    2|
|  3 |  Bob|    3|
+----+-----+-----+

ビッグデータ技術を活用することで、テラバイト級のデータセットでも効率的に重複チェックを行えます。

今後、クラウドコンピューティングや量子コンピューティングなどの新技術との統合により、さらなる処理能力の向上が期待されます。

まとめ

Pythonを使った重複チェックは、データ処理における基本的かつ重要なスキルです。

本記事では、基本的なテクニックから高度な応用まで、幅広い重複チェック手法を紹介しました。

Pythonの重複チェックスキルを磨くことで、データ処理の効率が大幅に向上し、より価値の高い分析や開発が可能になります。

本記事で紹介した技術を実践し、さらに深く探求することで、データ処理のエキスパートとして成長できるでしょう。

重複チェックは、単なるタスクではなく、データの本質を理解し、価値を最大化するための重要なステップです。