Pythonの正規表現による文字列置換完全ガイド｜re.sub・複数条件・部分一致を例付き解説

Pythonでテキスト処理を行う際、正規表現は非常に強力なツールです。簡単な文字列の検索から複雑なパターンマッチングまで、正規表現は幅広い用途で使われます。この記事では、Pythonにおける正規表現を使った置換操作の基本から、より進んだテクニックまでを解説します。

この記事でわかること

• re.sub() の基本構文とパラメータの意味
• 部分一致・先頭末尾・単語境界など条件別の置換パターン
• 複数の文字列を一括で置換する効率的な方法（辞書・関数・パイプ記号）
• グループ化・後方参照（\1, \2）を使った高度な置換テクニック
• Pandasでの正規表現置換（regex=True / str.replace()）の使い方
• 処理が終わらない・重くなるトラブルの原因と解決策

対象読者: Pythonの基礎文法を理解しており、テキスト処理の自動化や文字列の柔軟な置換を実装したい方

Python正規表現による置換の基本構文【re.sub使用例】

Pythonで文字列の置換を行う際、単純な文字列の置き換えならstr.replace()で十分ですが、より柔軟なパターンマッチングによる置換には正規表現を使用します。Python標準ライブラリのreモジュールが提供するsub()関数を使うことで、複雑な条件での文字列置換が可能になります。

re.sub()の基本構文

import re

re.sub(pattern, repl, string, count=0, flags=0)

各パラメータの説明：

• pattern: 置換対象を検索する正規表現パターン（文字列）
• repl: 置換後の文字列、または置換処理を行う関数
• string: 置換処理を行う対象の文字列
• count: 置換する回数の上限（0は全て置換、デフォルト）
• flags: 正規表現の動作を制御するオプション（省略可能）

基本的な使用例

最もシンプルな置換例から見ていきましょう。

import re

# 置換前のテキスト
text = "Pythonは楽しい。Pythonを学ぼう。"
print(f"置換前: {text}")

# 基本的な置換
pattern = "Python"
repl = "プログラミング"
result = re.sub(pattern, repl, text)
print(f"置換後: {result}")

置換前: Pythonは楽しい。Pythonを学ぼう。
置換後: プログラミングは楽しい。プログラミングを学ぼう。

countパラメータを使った置換回数の制限

import re

text = "apple apple apple"
print(f"置換前: {text}")

# 最初の2つだけ置換
result = re.sub("apple", "orange", text, count=2)
print(f"count=2: {result}")

# 全て置換（デフォルト）
result = re.sub("apple", "orange", text)
print(f"全置換: {result}")

置換前: apple apple apple
count=2: orange orange apple
全置換: orange orange orange

str.replace()との使い分け

# 単純な置換：str.replace()が適している
text = "Hello World Hello"
result1 = text.replace("Hello", "Hi")  # 推奨
result2 = re.sub("Hello", "Hi", text)   # オーバースペック

print(f"str.replace(): {result1}")
print(f"re.sub(): {result2}")

# パターン検索：re.sub()が必要
text = "電話: 03-1234-5678, FAX: 03-8765-4321"
# 電話番号のパターンをマスク
result = re.sub(r"\d{2}-\d{4}-\d{4}", "XX-XXXX-XXXX", text)
print(f"パターン置換: {result}")

str.replace(): Hi World Hi
re.sub(): Hi World Hi
パターン置換: 電話: XX-XXXX-XXXX, FAX: XX-XXXX-XXXX

このように、re.sub()は基本構文を理解すれば、単純な文字列置換から複雑なパターンマッチングまで幅広く対応できる強力な関数です。次のセクションでは、より実践的な置換方法について解説していきます。

re.sub() 実用パターン クイックリファレンス

この一覧は各セクションで詳しく解説します。不明な構文は該当セクションを参照してください。

文字列の部分一致による置換方法【初心者向け】

基本的な部分一致置換

まずは先ほどの基本例をもう一度確認しましょう。

import re

# 置換前のテキスト
text = "Pythonは楽しい。Pythonを学ぼう。"
print(f"置換前: {text}")

# 置換するパターンと置換後の文字列
pattern = "Python"
repl = "プログラミング"

# 置換実行
new_text = re.sub(pattern, repl, text)
print(f"置換後: {new_text}")

置換前: Pythonは楽しい。Pythonを学ぼう。 
置換後: プログラミングは楽しい。プログラミングを学ぼう。

文字列の先頭・末尾での部分一致

import re

# 先頭一致の例
text = "Pythonプログラミング、Python学習、プログラミング言語Python"
print(f"元のテキスト: {text}")

# 行の先頭の"Python"のみ置換
pattern = r"^Python"  # ^は行の始まりを表す
result = re.sub(pattern, "言語", text)
print(f"先頭一致: {result}")

# 行の末尾の"Python"のみ置換
pattern = r"Python$"  # $は行の終わりを表す
result = re.sub(pattern, "言語", text)
print(f"末尾一致: {result}")

元のテキスト: Pythonプログラミング、Python学習、プログラミング言語Python
先頭一致: 言語プログラミング、Python学習、プログラミング言語Python
末尾一致: Pythonプログラミング、Python学習、プログラミング言語言語

単語境界を使った部分一致

import re

text = "Pythonist loves Python programming"
print(f"元のテキスト: {text}")

# 単語境界なし：部分文字列も置換してしまう
result1 = re.sub("Python", "Java", text)
print(f"境界なし: {result1}")

# 単語境界あり：完全な単語のみ置換
pattern = r"\bPython\b"  # \bは単語境界を表す
result2 = re.sub(pattern, "Java", text)
print(f"単語境界: {result2}")

元のテキスト: Pythonist loves Python programming
境界なし: Javaist loves Java programming
単語境界: Pythonist loves Java programming

大文字・小文字を無視した部分一致

import re

text = "python PYTHON Python PyThOn"
print(f"元のテキスト: {text}")

# 大文字・小文字を区別する（デフォルト）
result1 = re.sub("python", "言語", text)
print(f"区別あり: {result1}")

# 大文字・小文字を無視
result2 = re.sub("python", "言語", text, flags=re.IGNORECASE)
print(f"区別なし: {result2}")

元のテキスト: python PYTHON Python PyThOn
区別あり: 言語 PYTHON Python PyThOn
区別なし: 言語 言語 言語 言語

数字を含む部分一致

import re

text = "商品コード: ABC123, DEF456, GHI789"
print(f"元のテキスト: {text}")

# 数字部分のみ置換
pattern = r"\d+"  # \d+は1つ以上の数字
result = re.sub(pattern, "XXX", text)
print(f"数字置換: {result}")

# アルファベット部分のみ置換
pattern = r"[A-Z]+"  # [A-Z]+は1つ以上の大文字
result = re.sub(pattern, "CODE", text)
print(f"文字置換: {result}")

元のテキスト: 商品コード: ABC123, DEF456, GHI789
数字置換: 商品コード: ABCXXX, DEFXXX, GHIXXX
文字置換: 商品コード: CODE123, CODE456, CODE789

特定の文字を含む文字列の置換

import re

text = "メール: user@example.com, admin@test.org, info@company.co.jp"
print(f"元のテキスト: {text}")

# @を含む文字列（メールアドレス）をマスク
pattern = r"\S+@\S+"  # \S+は空白以外の文字1つ以上
result = re.sub(pattern, "[メールアドレス]", text)
print(f"メール置換: {result}")

元のテキスト: メール: user@example.com, admin@test.org, info@company.co.jp
メール置換: メール: [メールアドレス] [メールアドレス] [メールアドレス]

実践的な応用例：個人情報のマスキング

import re

# 個人情報を含むテキスト
text = """
顧客情報:
名前: 田中太郎
電話: 090-1234-5678
郵便番号: 123-4567
"""
print(f"元のテキスト:{text}")

# 電話番号をマスク
text = re.sub(r"\d{3}-\d{4}-\d{4}", "XXX-XXXX-XXXX", text)
# 郵便番号をマスク
text = re.sub(r"\d{3}-\d{4}", "XXX-XXXX", text)

print(f"マスク後:{text}")

元のテキスト:
顧客情報:
名前: 田中太郎
電話: 090-1234-5678
郵便番号: 123-4567

マスク後:
顧客情報:
名前: 田中太郎
電話: XXX-XXXX-XXXX
郵便番号: XXX-XXXX

よく使われる部分一致パターン一覧

部分一致による置換をマスターすることで、データクリーニングや文書処理など、実務でよく使われる文字列操作が効率的に行えるようになります。

部分一致パターンの動作確認ユーティリティ

部分一致のパターンを書くとき、意図通りにマッチしているか確認するのは重要です。以下のコードを使うと、マッチ箇所と置換結果を同時に確認できます。

import re

def test_pattern(pattern, text, replacement='[置換済]', flags=0):
    """正規表現パターンの動作を確認するユーティリティ関数"""
    matches = re.findall(pattern, text, flags=flags)
    result = re.sub(pattern, replacement, text, flags=flags)
    print(f"パターン : {pattern}")
    print(f"マッチ数 : {len(matches)}件 → {matches}")
    print(f"置換結果 : {result}")
    print("-" * 40)
    return result

# 使用例①：数字パターン
test_pattern(r'\b\d{3}-\d{4}\b', '連絡先: 090-1234、FAX: 03-5678')
# マッチ数 : 2件 → ['090-1234', '03-5678']

# 使用例②：大文字小文字無視
test_pattern(r'python', 'I use Python and python3', flags=re.IGNORECASE)
# マッチ数 : 2件 → ['Python', 'python3']

このユーティリティを活用することで、複数条件の置換に進む前に各パターンの動作を確実に把握できます。

複数条件での一括置換テクニック【コード例付き】

実際の業務では、複数の異なる文字列を一度に置換したい場面が頻繁にあります。複数の条件を効率的に処理する方法を、基本から応用まで段階的に解説します。

基本的な複数パターン置換

パイプ記号（|）を使って複数のパターンを同時に指定できます。

import re

text = "猫はかわいい。犬もかわいい。鳥も美しい。"
print(f"置換前: {text}")

# 複数パターンを|で区切って指定
pattern = "猫|犬|鳥"
result = re.sub(pattern, "動物", text)
print(f"一律置換: {result}")

置換前: 猫はかわいい。犬もかわいい。鳥も美しい。
一律置換: 動物はかわいい。動物もかわいい。動物も美しい。
​

関数を使った条件別置換

パターンごとに異なる置換を行いたい場合は、置換関数を定義します。

import re

text = "猫はかわいい。犬もかわいい。鳥も美しい。"
print(f"置換前: {text}")

# パターンごに異なる置換を行う関数
def repl_func(match):
    matched_text = match.group(0)
    if matched_text == "猫":
        return "ネコ科動物"
    elif matched_text == "犬":
        return "イヌ科動物"
    elif matched_text == "鳥":
        return "鳥類"
    return matched_text

pattern = "猫|犬|鳥"
result = re.sub(pattern, repl_func, text)
print(f"条件別置換: {result}")

置換前: 猫はかわいい。犬もかわいい。鳥も美しい。
条件別置換: ネコ科動物はかわいい。イヌ科動物もかわいい。鳥類も美しい。

辞書を活用した複数置換

置換パターンが多い場合は、辞書を使ってより読みやすくできます。

import re

text = "赤い車と青い車と緑の車が駐車場にある。"
print(f"置換前: {text}")

# 置換辞書を定義
color_dict = {
    "赤い": "レッド",
    "青い": "ブルー", 
    "緑の": "グリーン"
}

# 辞書のキーからパターンを作成
pattern = "|".join(color_dict.keys())
print(f"パターン: {pattern}")

def dict_replacer(match):
    return color_dict[match.group(0)]

result = re.sub(pattern, dict_replacer, text)
print(f"辞書置換: {result}")

置換前: 赤い車と青い車と緑の車が駐車場にある。
パターン: 赤い|青い|緑の
辞書置換: レッド車とブルー車とグリーン車が駐車場にある。

数値の形式統一

import re

text = "価格は1000円、1,500円、￥2000、3,000yen"
print(f"置換前: {text}")

# 複数の数値パターンを統一形式に置換
def price_normalizer(match):
    # マッチした文字列から数字のみ抽出
    numbers = re.findall(r'\d+', match.group(0))
    if numbers:
        # カンマを除去して数値に変換
        price = int(''.join(numbers))
        return f"¥{price:,}"
    return match.group(0)

# 複数の価格パターンにマッチ
pattern = r"(?:￥|¥)?\d+(?:,\d+)*(?:円|yen)?"
result = re.sub(pattern, price_normalizer, text)
print(f"価格統一: {result}")

置換前: 価格は1000円、1,500円、￥2000、3,000yen
価格統一: 価格は¥1,000、¥1,500、¥2,000、¥3,000

複数行にわたる複雑な置換

import re

text = """
山田太郎 (090-1234-5678)
佐藤花子 tel:03-5678-9012
田中次郎 電話番号:080-9876-5432
"""
print(f"置換前:{text}")

# 複数の電話番号パターンを統一
def phone_replacer(match):
    # 電話番号部分を抽出
    phone = re.search(r'[\d-]+', match.group(0))
    if phone:
        return f"TEL: {phone.group(0)}"
    return match.group(0)

# 複数の電話番号表記パターン
pattern = r"(?:\(|tel:|電話番号:)[\d-]+(?:\))?|[\d-]{11,13}"
result = re.sub(pattern, phone_replacer, text)
print(f"電話統一:{result}")

置換前:
山田太郎 (090-1234-5678)
佐藤花子 tel:03-5678-9012
田中次郎 電話番号:080-9876-5432

電話統一:
山田太郎 TEL: 090-1234-5678
佐藤花子 TEL: 03-5678-9012
田中次郎 TEL: 080-9876-5432

文書の敬語統一

import re

text = "こんにちは。お疲れさまです。ありがとうございます。すみません。"
print(f"置換前: {text}")

# 敬語の統一辞書
keigo_dict = {
    "こんにちは": "お疲れ様でございます",
    "お疲れさまです": "お疲れ様でございます",
    "ありがとうございます": "ありがとうございました",
    "すみません": "申し訳ございません"
}

# 辞書キーを長い順にソート（部分一致を避けるため）
sorted_keys = sorted(keigo_dict.keys(), key=len, reverse=True)
pattern = "|".join(re.escape(key) for key in sorted_keys)

def keigo_replacer(match):
    return keigo_dict[match.group(0)]

result = re.sub(pattern, keigo_replacer, text)
print(f"敬語統一: {result}")

置換前: こんにちは。お疲れさまです。ありがとうございます。すみません。
敬語統一: お疲れ様でございます。お疲れ様でございます。ありがとうございました。申し訳ございません。

効率的な複数置換のコツ

import re

# ❌ 非効率な方法：複数回re.subを実行
def inefficient_replace(text):
    text = re.sub("Python", "パイソン", text)
    text = re.sub("Java", "ジャバ", text)  
    text = re.sub("JavaScript", "ジャバスクリプト", text)
    return text

# ✅ 効率的な方法：一度の処理で完了
def efficient_replace(text):
    replacements = {
        "JavaScript": "ジャバスクリプト",  # 長いパターンを先に
        "Java": "ジャバ",
        "Python": "パイソン"
    }
    
    # 長い順にソートして部分一致を防ぐ
    pattern = "|".join(re.escape(key) for key in sorted(replacements.keys(), key=len, reverse=True))
    
    def replacer(match):
        return replacements[match.group(0)]
    
    return re.sub(pattern, replacer, text)

# 実行例
text = "PythonとJavaとJavaScriptを学習中"
print(f"元のテキスト: {text}")
result = efficient_replace(text)
print(f"効率置換: {result}")

元のテキスト: PythonとJavaとJavaScriptを学習中
効率置換: パイソンとジャバとジャバスクリプトを学習中

置換パフォーマンスの比較

複数条件での置換をマスターすることで、大量のテキストデータを効率的に処理できるようになり、データクリーニングや文書の標準化作業が格段に楽になります。

複数置換の選び方フローチャートと辞書置換テンプレート

どの手法を選ぶか：判断基準

置換パターンは何個？
├─ 1〜2個  → パイプ記号（|）: re.sub(r'A|B', repl, text)
├─ 3〜10個
│   ├─ 置換結果がすべて同じ → パイプ記号
│   └─ 置換結果が異なる    → 辞書置換 または 関数置換
└─ 10個以上 → 辞書置換（保守性・可読性が最も高い）

置換ロジックに条件分岐が必要？
├─ Yes → 関数置換（lambda / def）
└─ No  → 辞書置換

辞書置換の汎用テンプレート（コピペで使えます）:

import re

def multi_replace(text: str, replace_dict: dict) -> str:
    """
    辞書を使った複数パターン一括置換。
    replace_dictのキーを正規表現パターンとして一度のre.subで処理するため高速。
    """
    # re.escapeでキーの特殊文字をエスケープしてからパターンに結合
    pattern = re.compile('|'.join(map(re.escape, replace_dict.keys())))
    return pattern.sub(lambda m: replace_dict[m.group()], text)

# 使用例：英国英語→米国英語の統一
replace_map = {
    'colour': 'color',
    'favourite': 'favorite',
    'centre': 'center'
}
result = multi_replace('My favourite colour is at the centre.', replace_map)
print(result)  # My favorite color is at the center.

注意: re.escape() を使わないとキーに含まれる . や * などが正規表現メタ文字として解釈されるため、必ず使用してください。

グループと後方参照を使った高度な置換

正規表現のグループ化(())を使用すると、マッチした部分文字列を後で再利用（後方参照）できます。これは特に、置換の際にマッチした部分を新しい文脈で使用したい場合に便利です。

# 置換対象のテキストを定義
text = "2023/02/20"

# 正規表現パターンを定義。年、月、日をそれぞれグループ化
pattern = "(\d{4})/(\d{2})/(\d{2})"

# 置換後のフォーマットを定義。月、日、年の順に変更
repl = "\\2-\\3-\\1"

# 定義したパターンに基づき、テキスト内の日付フォーマットを置換
new_text = re.sub(pattern, repl, text)

# 置換後のテキストを出力
print(new_text)

02-20-2023

この部分は少しわかりづらいかもしませんので、詳細に説明します。

• textは置換を行いたい元の文字列です。この例では「2023/02/20」という日付フォーマットを持っています。
• patternは正規表現で、日付のパターンを表しています。\d{4}は4桁の数字（年）を意味し、\d{2}は2桁の数字（月または日）を意味します。括弧()によってこれらの部分をグループ化しています。これにより、置換時に特定の部分（年、月、日）を参照できるようになります。
• replは置換後のフォーマットを示しています。ここでは、\\2、\\3、\\1を用いて、元のテキストの2番目（月）、3番目（日）、1番目（年）のグループを新しい順序で参照しています。つまり、年/月/日のフォーマットを月-日-年のフォーマットに変更しています。
• re.sub()関数は、指定されたパターンにマッチするすべての部分を、指定された置換テキストに置換します。この例では、patternにマッチする日付をreplで定義された新しいフォーマットに置換しています。

このコードは、日付のフォーマットを変更する一般的な用途で使用される典型的な例です。正規表現のグループ化と後方参照を利用することで、非常に柔軟かつ強力なテキスト処理が可能になります。

よく使うグループ参照パターン一覧

\1, \2 の意味: 置換文字列内の \1 は1番目の () グループにマッチした文字列、\2 は2番目を指します。これを「後方参照」と呼び、マッチした内容を置換先で再利用できます。

Pandasでの正規表現を用いた置換

Pandasでは、replace()メソッドにregex=Trueオプションを指定することで、正規表現を使用したテキストデータの置換が可能です。これにより、DataFrameやSeries内のテキストを柔軟にかつ効率的に処理できます。

以下の例では、DataFrame内の全ての”Python”という文字列を”プログラミング”に置換しています。to_replaceに指定された”Python”は正規表現として解釈され、これによりDataFrame内の任意の場所にある”Python”という文字列が”プログラミング”に置換されます。

import pandas as pd

data = {'テキスト': ["Pythonは楽しい", "Pythonを学ぼう"]}
df = pd.DataFrame(data)
df['テキスト'] = df['テキスト'].replace(to_replace="Python", value="プログラミング", regex=True)
print(df)

          テキスト
0  プログラミングは楽しい
1  プログラミングを学ぼう

この場合、to_replace="Python"は正規表現パターンとして機能し、文字列”Python”に一致します。regex=Trueが指定されているため、Pandasはこのパターンを正規表現として処理し、一致するすべての部分を置換します。

Pandasでよく使うregex=True置換パターン

import pandas as pd

df = pd.DataFrame({
    'text': ['Python 3.10', 'Python3.11', 'python 3.12', 'PYTHON3.9']
})

# ① 大文字小文字を区別せずに置換（case=Falseはstr.replace専用オプション）
df['text'] = df['text'].str.replace(r'python', 'PY', case=False, regex=True)

# ② 連続スペースを1つに統一
df['text'] = df['text'].str.replace(r'\s+', ' ', regex=True)

# ③ バージョン番号を抽出して新列に保存（extractはre.subではなくstr.extract）
df['version'] = df['text'].str.extract(r'(\d+\.\d+)')

# ④ 特定パターンを含む行のみ条件付き置換
mask = df['text'].str.contains(r'3\.1\d', regex=True)
df.loc[mask, 'text'] = df.loc[mask, 'text'].str.replace(r'3\.1\d', '3.1x', regex=True)

str.replace() と DataFrame.replace() の違い（混同注意）:

⚠️ Pandas 2.0以降の注意: Series.str.replace() では regex 引数の明示指定が推奨されています。省略すると将来のバージョンで動作が変わる可能性があるため、regex=True または regex=False を必ず指定してください。

置換が終わらない時のトラブル対応【よくあるエラー】

正規表現による置換処理でよく遭遇するのが、「処理が終わらない」「無限ループに陥る」といった問題です。これらのトラブルの原因と対策を、実際のエラー例とともに解説します。

無限ループを引き起こすパターン

問題例1：空文字列にマッチするパターン

import re

# ❌ 危険なパターン：空文字列にマッチしてしまう
text = "abc"
print(f"元のテキスト: {text}")

try:
    # これは無限ループになる可能性がある
    # pattern = r"a*"  # 0個以上のaにマッチ（空文字にもマッチ）
    # result = re.sub(pattern, "X", text)
    print("❌ このコードは実行しないでください（無限ループの危険）")
except:
    pass

# ✅ 正しいパターン：1個以上を指定
pattern = r"a+"  # 1個以上のaにマッチ
result = re.sub(pattern, "X", text)
print(f"修正後: {result}")
# 出力: Xbc

問題例2：置換結果が再びパターンにマッチしてしまう

import re

# ❌ 置換結果が再びマッチしてしまう例
text = "aaa"
print(f"元のテキスト: {text}")

# 危険：置換した"aa"が再び"a+"パターンにマッチしてしまう
# このような場合は置換回数を制限するか、パターンを見直す

# ✅ 対策1：置換回数を制限
pattern = r"a+"
result = re.sub(pattern, "aa", text, count=1)  # 1回のみ置換
print(f"回数制限: {result}")
# 出力: aa

# ✅ 対策2：より具体的なパターンを使用
pattern = r"a{3,}"  # 3個以上のaにマッチ
result = re.sub(pattern, "bb", text)
print(f"具体的パターン: {result}")
# 出力: bb

処理時間が異常に長くなるパターン

問題例3：バックトラッキング地獄

import re
import time

def demonstrate_backtracking():
    problem_text = "a" * 30 + "x"  # 最後が'x'でマッチしない
    print(f"テストテキスト: {'a' * 30}x (マッチしない文字列)")
    
    def measure_time(pattern, text, description):
        start = time.time()
        try:
            result = re.search(pattern, text)
            end = time.time()
            print(f"{description}: {end - start:.6f}秒, マッチ: {result is not None}")
        except Exception as e:
            print(f"{description}: エラー - {e}")
    
    # バックトラッキング地獄のパターン
    measure_time(r"(a+)+b", problem_text, "❌ 悪いパターン (a+)+b")
    
    # 効率的なパターン
    measure_time(r"a+b", problem_text, "✅ 良いパターン a+b")
    
    # より極端な例
    extreme_text = "a" * 25 + "x"
    print(f"\nより極端な例: {'a' * 25}x")
    
    # 注意：このパターンは本当に時間がかかる場合があります
    measure_time(r"(a*)*b", extreme_text, "❌ 非常に悪いパターン (a*)*b")
    measure_time(r"a*b", extreme_text, "✅ 改良パターン a*b")
    
    # 原子グループの正しい書き方（一部の正規表現エンジンでサポート）
    try:
        # Pythonの標準reモジュールは原子グループをサポートしていない
        measure_time(r"(?>a+)b", extreme_text, "原子グループ（非サポート）")
    except:
        print("原子グループ: Pythonの標準reモジュールではサポートされていません")

demonstrate_backtracking()

問題例4：大量データでの非効率な処理

import re

# 大量のテキストデータ
large_text = "Python Java C++ JavaScript " * 10000
print(f"テキストサイズ: {len(large_text)} 文字")

# ❌ 非効率：複数回の置換処理
def inefficient_replace(text):
    start = time.time()
    # 複数回re.subを実行
    text = re.sub("Python", "パイソン", text)
    text = re.sub("Java(?!Script)", "ジャバ", text)  # JavaScriptは除外
    text = re.sub("C\\+\\+", "シープラスプラス", text)
    text = re.sub("JavaScript", "ジャバスクリプト", text)
    end = time.time()
    print(f"❌ 非効率処理: {end - start:.4f}秒")
    return text

# ✅ 効率的：一回の処理で完了
def efficient_replace(text):
    start = time.time()
    
    replacements = {
        "JavaScript": "ジャバスクリプト",  # 先に長いパターン
        "Java": "ジャバ",
        "C\\+\\+": "シープラスプラス",
        "Python": "パイソン"
    }
    
    pattern = "|".join(f"({re.escape(k)})" for k in replacements.keys())
    
    def replacer(match):
        for i, key in enumerate(replacements.keys(), 1):
            if match.group(i):
                return replacements[key]
        return match.group(0)
    
    result = re.sub(pattern, replacer, text)
    end = time.time()
    print(f"✅ 効率的処理: {end - start:.4f}秒")
    return result

# 実行時間の比較
# inefficient_replace(large_text[:100000])  # 短いテキストで実行
# efficient_replace(large_text[:100000])

メモリ不足を引き起こすパターン

問題例5：巨大な文字列生成

import re

# ❌ 巨大な置換結果でメモリ不足
text = "a" * 1000
print(f"元のテキストサイズ: {len(text)} 文字")

# 危険：各文字を長い文字列に置換
# pattern = "a"
# replacement = "x" * 10000  # 10000文字の文字列
# この置換は元の1000倍のメモリを消費する

# ✅ 対策：適切なサイズの置換
pattern = "a"
replacement = "x"  # 適切なサイズ
result = re.sub(pattern, replacement, text)
print(f"置換後サイズ: {len(result)} 文字")

デバッグとトラブル対応のテクニック

テクニック1：パターンの動作確認

import re

def debug_pattern(pattern, test_strings):
    """正規表現パターンの動作を確認する関数"""
    print(f"パターン: {pattern}")
    print("-" * 50)
    
    compiled_pattern = re.compile(pattern)
    
    for test_str in test_strings:
        matches = compiled_pattern.findall(test_str)
        print(f"テスト文字列: '{test_str}'")
        print(f"マッチ結果: {matches}")
        print()

# 使用例
test_cases = ["aaa", "aa", "a", "", "bbb"]
debug_pattern(r"a+", test_cases)
debug_pattern(r"a*", test_cases)  # 空文字列にもマッチすることを確認

テクニック2：処理時間の監視

import re
import signal

def timeout_handler(signum, frame):
    raise TimeoutError("処理時間が制限を超えました")

def safe_regex_sub(pattern, repl, string, timeout=5):
    """タイムアウト付きの安全なre.sub"""
    # シグナルハンドラを設定（Unix系OSのみ）
    try:
        signal.signal(signal.SIGALRM, timeout_handler)
        signal.alarm(timeout)
        
        result = re.sub(pattern, repl, string)
        
        signal.alarm(0)  # タイマーをクリア
        return result
        
    except TimeoutError:
        signal.alarm(0)
        print(f"⚠️ 処理がタイムアウトしました: {timeout}秒")
        return string
    except Exception as e:
        signal.alarm(0)
        print(f"❌ エラーが発生: {e}")
        return string

# 使用例（Unix系OSでのみ動作）
# result = safe_regex_sub(r"(a+)+b", "x", "aaaaab", timeout=1)

よくあるトラブルとその対策一覧

安全な正規表現置換のチェックリスト

# 正規表現置換を安全に行うためのチェック項目

def safe_replace_checklist(pattern, replacement, test_string):
    """安全な置換のためのチェック関数"""
    checks = []
    
    # 1. 空文字列にマッチしないか
    if re.match(pattern, ""):
        checks.append("⚠️ 空文字列にマッチする可能性があります")
    else:
        checks.append("✅ 空文字列マッチ問題なし")
    
    # 2. 置換結果が再びマッチしないか
    temp_result = re.sub(pattern, replacement, test_string, count=1)
    if re.search(pattern, replacement):
        checks.append("⚠️ 置換結果が再びパターンにマッチします")
    else:
        checks.append("✅ 再マッチ問題なし")
    
    # 3. バックトラッキングの多用がないか
    if "(.*)" in pattern or "+.*" in pattern:
        checks.append("⚠️ バックトラッキングが多発する可能性があります")
    else:
        checks.append("✅ バックトラッキング問題なし")
    
    return checks

# 使用例
pattern = r"a+"
replacement = "X"
test_string = "aaa"

for check in safe_replace_checklist(pattern, replacement, test_string):
    print(check)

これらのトラブル対応テクニックを知っておくことで、正規表現による置換処理を安全かつ効率的に実行できるようになります。

Pythonの正規表現を用いた置換は、テキストデータの処理を効率的かつ強力に行う方法です。この記事で紹介した基本操作から複数パターンの置換、グループ化や後方参照などのテクニックを活用して、Pythonでのテキスト処理をより効果的に行いましょう。

まとめ：Python正規表現置換の学習ロードマップ

この記事で解説した内容を難易度別に整理します。

次のステップとして読みたい記事:

• テキストデータ全体の前処理フロー（形態素解析・可視化含む）を学びたい方: Pythonを使ったテキストデータの前処理と可視化
• Pandasをより深く活用したい方（groupby・集計・条件抽出など）: Pythonのpandasとは何か【インストールと基本的な使い方を解説】
• 関数置換でより柔軟な条件分岐を書きたい方（lambdaの応用）: Pythonのlambdaで条件分岐する方法