🔖 キーワード索引

「regex」は統計データ分析の文脈で扱う重要概念のひとつ。 本ページでは「regex」を取り巻く中核キーワードを以下にチップで一覧化する。 各キーワードは関連する概念・手法・道具立てを含み、 文献検索や学習計画の起点になる。

これらのキーワードは「regex の理解 → 適用 → 検証」のプロセスを構成する。 各章で詳しく解説する。

🎨 直感で掴む

ログから「IP アドレス」だけ取り出したい。 「ABC123def456」から数字だけ拾いたい。 「電話番号らしき文字列」を見つけたい ── これを 1 行で書けるのが 正規表現。 例：r'\d{3}-\d{4}-\d{4}' で電話番号、 r'\d+' で数字列。 データ前処理の生産性を 10 倍に上げる魔法のツール。

イメージは「文字の鋳型」。 鋳型に流し込んで一致する部分だけ拾い上げる。 SSDSE-B-2026 の市区町村コード列 (例: R01100) から都道府県コード 2 桁だけ取り出すには r'R(\d{2})'、 年度 2026 を取り出すには r'(\d{4})年?' と、 抜き出したい場所を (...) で囲むだけ。 文字列を 1 文字ずつ if 文で判定するコードを書く時代は、 正規表現を一度書ければほぼ過去のものになる。

ただし「魔法」と呼べるのはパターンが固定的な場面に限られる。 「東京都新宿区西新宿2-8-1」のような表記揺れがある住所では、 正規表現単独では破綻し、 形態素解析や辞書照合と組み合わせることになる。 つまり正規表現は「鋳型」が描ける範囲では最強だが、 描けない範囲では NLP に道を譲る、 という棲み分けが直感的な理解の核になる。

📐 定義・数式

正規表現は、 文字リテラル・任意1文字 (.)・数字 (\d)・文字クラス ([abc])・量化子 (*, +, ?)・グループ ((...)) を組み合わせて構築する。

📐 形式言語理論との対応

「正規表現 (regular expression)」 という名前は 形式言語のクラス である「正規言語 (regular language)」 に由来します。 Chomsky の言語階層では：

この階層が 正規表現の能力の限界 を示します。 たとえば「対応する括弧」 は正規言語ではなく文脈自由言語なので、 純粋な正規表現では正しくパースできない。 HTML/XML を正規表現でパースしようとして失敗するのはこのため。

ただし、 PCRE 等の拡張正規表現は後方参照を持つため、 厳密には正規言語の枠を超えています（理論的には文脈依存言語の一部まで認識可能）。

🤖 LLM 時代の正規表現

ChatGPT などの LLM に「メールアドレスを正規表現で抽出して」 と頼めば、 ほぼ正しい正規表現を生成してくれます。 これは正規表現を 不要にした のではなく、 むしろ 使いこなせる人の生産性を上げた。

LLM が出した正規表現を信頼してよいか？

• 必ずテストする：LLM は もっともらしい嘘（ハルシネーション） を出す。 regex101 で必ず検証。
• エッジケースを問う：「日本の電話番号」 → 「0120 から始まるフリーダイヤルは？」 と追加質問。
• 解説を求める：パターンの各部分の意味を説明させる。 自分が理解しないコードはコミットしない。
• 性能を確認：LLM が出すパターンは ReDoS リスクを含むことがある。

SSDSE データを LLM + 正規表現で処理する流れ

1. SSDSE のサンプルデータを LLM に貼り付け、 「これを正規表現で前処理したい」 と相談。
2. LLM が出した正規表現を regex101.com で動作確認。
3. Python re で実装し、 pytest でテスト。
4. 本番 SSDSE-B-2026 全データで実行。
5. エッジケースで失敗するなら、 失敗例を LLM に渡して修正版を生成。

⚡ 性能チューニング 5 原則

1. compile して再利用：同じパターンを何度も使うなら re.compile()。 SSDSE 47 件で 2-3 倍速。
2. アンカーで早く失敗させる：^ や $ でマッチしないパターンを早期に除外。
3. 具体的な文字クラス：. より \d や [a-z] の方が高速。
4. greedy 回避：.* より具体的なパターン（例：[^>]*）。
5. 非キャプチャグループ：参照不要なら (?:...)。 キャプチャはオーバーヘッド。

SSDSE 100 列 × 47 行を処理しても、 正しく書けばミリ秒オーダーで完了します。 数秒以上かかるなら正規表現の設計ミスを疑う。

📓 SSDSE-B-2026 完全前処理ワークフロー（正規表現フル活用）

本ページの全テクニックを動員して SSDSE-B-2026 を 「分析できる形」 まで整形する完成度の高いコード：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

import os
os.makedirs('data/processed', exist_ok=True)  # 保存先のフォルダを作っておく

import pandas as pd
import re
from pathlib import Path

# ===== STEP 1: 読み込み =====
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=1)
print(f'読み込み完了: {df.shape}')

# ===== STEP 2: 列名メタデータ抽出 =====
COL_PAT = re.compile(r'^(?P<code>[A-Z]\d{4})_(?P<name>.+?)(?:（(?P<unit>.+?)）)?$')

meta = []
for col in df.columns:
    m = COL_PAT.match(col)
    if m:
        meta.append({
            'original': col,
            'code': m['code'],
            'name': m['name'],
            'unit': m['unit'] or '無単位',
            'category': m['code'][0],
        })
    else:
        meta.append({'original': col, 'code': None, 'name': col,
                     'unit': '無単位', 'category': None})

df_meta = pd.DataFrame(meta)
print(f'\nメタデータ抽出: {len(df_meta)} 列')
print(df_meta.groupby('category').size())

# ===== STEP 3: カテゴリ別の列リスト =====
SSDSE_CATEGORIES = {
    'A': '人口', 'B': '自然環境', 'C': '経済基盤',
    'D': '行政基盤', 'E': '教育', 'F': '労働',
    'G': '文化・スポーツ', 'H': '住居', 'I': '健康・医療',
    'J': '福祉・社会保障', 'K': '安全', 'L': '家計',
}
df_meta['category_name'] = df_meta['category'].map(SSDSE_CATEGORIES)

# ===== STEP 4: 都道府県名の正規化 =====
PREF_PAT = re.compile(r'^(?P<short>.+?)(?P<suffix>[都道府県])$')
if '都道府県' in df.columns:
    df['都道府県_short'] = df['都道府県'].str.extract(PREF_PAT)['short']
    df['都道府県_suffix'] = df['都道府県'].str.extract(PREF_PAT)['suffix']

# ===== STEP 5: 全角数値→半角 =====
def z2h(s):
    if not isinstance(s, str):
        return s
    return re.sub(r'[０-９]', lambda m: chr(ord(m.group()) - 0xFEE0), s)

for col in df.select_dtypes(include='object').columns:
    df[col] = df[col].apply(z2h)

# ===== STEP 6: 数値列の型変換（カンマ除去）=====
NUM_PAT = re.compile(r'^-?\d{1,3}(?:,\d{3})*(?:\.\d+)?$')
def parse_num(x):
    if isinstance(x, str) and NUM_PAT.match(x):
        return float(x.replace(',', ''))
    return x

for col in df.select_dtypes(include='object').columns:
    df[col] = df[col].apply(parse_num)

# ===== STEP 7: 単位統一（金額系を「円」 へ）=====
UNIT_MAP = {'千円': 1000, '百万円': 10**6, '億円': 10**8, '兆円': 10**12}
for col in df_meta.iterrows():
    _, m = col
    if m['unit'] in UNIT_MAP:
        original_col = m['original']
        if original_col in df.columns and pd.api.types.is_numeric_dtype(df[original_col]):
            df[original_col] = df[original_col] * UNIT_MAP[m['unit']]

# ===== STEP 8: サマリ =====
print(f'\n=== 前処理完了 ===')
print(f'  サンプル数: {len(df)}')
print(f'  数値列数: {len(df.select_dtypes(include=[\"number\"]).columns)}')
print(f'  欠損総数: {df.isna().sum().sum()}')

# ===== STEP 9: メタデータ保存 =====
df_meta.to_csv('data/processed/SSDSE-B-2026_meta.csv', index=False)
df.to_csv('data/processed/SSDSE-B-2026_clean.csv', index=False)
print('保存完了')

このコードは 1 ファイル / 100 行 で SSDSE 前処理を完結させます。 正規表現が 5 箇所で活躍：列名分解、 都道府県名分離、 全角数字変換、 カンマ区切り数値、 単位検出。 これらを抜くと、 同じ処理が 200 行以上 の手続き的コードになります。

🧬 正規表現とパーサーコンビネータの融合

複雑な文法（ネスト構造、 文脈依存） を扱うとき、 正規表現だけでは限界があります。 そこで パーサーコンビネータ（pyparsing, parsy, lark） と組み合わせる手法が有効：

• tokenization は正規表現で：文字列を「数値」「演算子」「識別子」 等のトークン列に分解。
• parsing はコンビネータで：トークン列を構造化（AST）。
• 例：SQL クエリ、 数式、 設定ファイル。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import re
# トークナイザ（正規表現で）
TOKEN_PAT = re.compile(r'''
    (?P<NUMBER>\d+(?:\.\d+)?)|
    (?P<ID>[A-Za-z_]\w*)|
    (?P<OP>[+\-*/])|
    (?P<LPAREN>\()|
    (?P<RPAREN>\))|
    (?P<WS>\s+)
''', re.VERBOSE)

def tokenize(s):
    for m in TOKEN_PAT.finditer(s):
        kind = m.lastgroup
        if kind != 'WS':
            yield (kind, m.group(kind))

# 使用例
list(tokenize('x = 3.14 * (y + 2)'))

🛡 セキュリティと正規表現

入力バリデーション

Web フォーム入力（メール、 電話、 URL） の検証に正規表現は定番。 ただし：

• 完璧なメール正規表現は 不可能（RFC 5322 は文脈依存）。 「@がある」 程度の緩い検証で OK。
• URL 検証はパーサー（urllib.parse） を使う。
• SQL インジェクション対策に正規表現を使うのは 禁忌。 必ずパラメータ化クエリ。

ReDoS 対策

ユーザー入力を正規表現の パターン として受け取る場合は、 re.escape() で逃がす。 パターンに変数を埋め込む場合も同様。

PII 検出と除去

SSDSE は公的統計なので PII（個人情報） を含みませんが、 一般のログ処理では正規表現で PII を検出・マスクすることが多い：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import re

text = ('問い合わせは support@example.co.jp まで。'
        '電話は 082-1234-5678、カードは 4111-1111-1111-1111 です。')

# メールマスク
text = re.sub(r'[\w.+-]+@[\w.-]+\.\w+', '[EMAIL]', text)
# 電話マスク
text = re.sub(r'0\d{1,4}-\d{1,4}-\d{3,4}', '[PHONE]', text)
# クレジットカードマスク
text = re.sub(r'\d{4}-\d{4}-\d{4}-\d{4}', '[CARD]', text)
print(text)

📘 ケーススタディ：47 都道府県データの統一

SSDSE-B-2026 と別の e-Stat データを結合する際、 「都道府県」 列の表記揺れが問題に：

英語名を日本語に揃える辞書を作り、 残りは正規表現で「最後の都道府県」 が一致するかチェック：

1
2
3
4
5
6
7

EN_TO_JP = {'Hokkaido': '北海道', 'Tokyo': '東京都',
            'Osaka': '大阪府', 'Okinawa': '沖縄県', ...}
def normalize(name):
    if name in EN_TO_JP:
        return EN_TO_JP[name]
    m = re.match(r'^(.+?[都道府県])', name)
    return m.group(1) if m else name

📗 ケーススタディ：時系列ログから日時抽出

日本のデータ分析で頻繁に遭遇する 表記揺れ：

• 2026-05-19 ISO 8601
• 2026/05/19
• 2026年5月19日
• 令和8年5月19日
• R8.5.19
• 20260519 連結
• May 19, 2026

これら全てに対応する正規表現は複数パターンを | で繋ぐ：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

PATTERNS = [
    (r'(\d{4})-(\d{1,2})-(\d{1,2})', 'iso'),
    (r'(\d{4})/(\d{1,2})/(\d{1,2})', 'slash'),
    (r'(\d{4})年(\d{1,2})月(\d{1,2})日', 'jp'),
    (r'令和(\d+)年(\d{1,2})月(\d{1,2})日', 'reiwa'),
    (r'R(\d+)\.(\d{1,2})\.(\d{1,2})', 'reiwa_short'),
    (r'(\d{4})(\d{2})(\d{2})', 'compact'),
]
def parse_date(s):
    for pat, kind in PATTERNS:
        m = re.search(pat, s)
        if m:
            y, mo, d = map(int, m.groups())
            if kind in ('reiwa', 'reiwa_short'):
                y += 2018  # 令和1年 = 2019
            return f'{y:04d}-{mo:02d}-{d:02d}'
    return None

📖 正規表現 用語集ミニ

パターン (Pattern)

マッチさせたい形状を表す正規表現の本体。

マッチ (Match)

パターンに合致する部分文字列が見つかった状態。

グループ (Group)

(...) で括った部分。 マッチ結果から抽出可能。

キャプチャ (Capture)

グループにマッチした文字列を保持すること。

アンカー (Anchor)

位置を指定する記号（^, $, \b）。 文字には対応しない。

量化子 (Quantifier)

繰り返し回数を指定（*, +, ?, {n,m}）。

貪欲 (Greedy)

できる限り長くマッチしようとする（デフォルト）。

最小 (Non-greedy / Lazy / Reluctant)

できる限り短くマッチ（*?, +?）。

バックトラッキング (Backtracking)

マッチ失敗時に試行を戻す動作。 ReDoS の原因にも。

先読み (Lookahead) / 後読み (Lookbehind)

マッチには含めず文脈条件を指定する zero-width 表現。

エスケープ (Escape)

メタ文字を文字通りに扱う指定（\., \+ 等）。

NFA / DFA

非決定性／決定性有限オートマトン。 エンジンの実装方式。

PCRE

Perl Compatible Regular Expressions。 多くの言語の標準。

ReDoS

Regular expression Denial of Service。 悪意ある入力で指数時間動作させる攻撃。

raw string

Python の r"..." 記法。 バックスラッシュをエスケープせず使える。

📋 正規表現 クイックリファレンス（印刷用）

📝 練習問題 10 問（SSDSE 中心）

1. Q1: SSDSE 列名 A1101_総人口 から「A11」 だけ抽出する正規表現は？ → r'^([A-Z]\d{2})'
2. Q2: 「東京都」「大阪府」「北海道」「広島県」 から末尾 1 文字を除いた都道府県名を取得する正規表現は？ → r'^(.+?)[都道府県]$'
3. Q3: 「2026年5月19日」 から年月日を取り出す正規表現は？ → r'(\d{4})年(\d{1,2})月(\d{1,2})日'
4. Q4: 「1,000,000円」 のような3桁区切り数値にマッチする正規表現は？ → r'\d{1,3}(?:,\d{3})*円'
5. Q5: メールアドレスの簡易検証正規表現は？ → r'^[\w.+-]+@[\w.-]+\.\w+$'
6. Q6: 半角・全角混在の数字を全部半角に変換する正規表現とコードは？ → r'[０-９]' + chr(ord(m) - 0xFEE0)
7. Q7: HTML から <p>...</p> の中身を最小マッチで取り出す正規表現は？ → r'<p>(.+?)</p>'
8. Q8: URL の中の「https://」 を除いてドメイン部分だけ取る正規表現は？ → r'https?://([^/]+)'
9. Q9: IP アドレス 0-255 の範囲を厳密にマッチする正規表現は？ → r'\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\b'
10. Q10: SSDSE 列名から「金額系の列（単位が円・千円・百万円） だけ」 抽出する正規表現は？ → r'(?:円|千円|百万円|億円)）?$'

これらを regex101.com で実際に試して、 自分の手で動作確認してください。 正規表現は「動かして覚える」 が最速の習得法です。

🌏 日本語処理特有の正規表現

SSDSE の日本語列名は基本 BMP（基本多言語面） の範囲。 ただし旧字体や絵文字を含むデータ（X / 旧Twitter の投稿等） では [\U00010000-\U0010FFFF] も考慮。

🐼 Pandas での正規表現徹底活用

SSDSE のような表データを扱う Pandas には、 正規表現が組み込まれた str アクセサが充実しています。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# ── この抜粋で使うデータを用意します ──
# 列名は「A1101_総人口」のように コード_名称 で持たせる
import pandas as pd

_raw = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', header=[0, 1])
df = _raw.copy()
df.columns = ['_'.join(str(c).strip() for c in col) for col in _raw.columns]

# SSDSE-B-2026 で 「人口」 を含む列だけ抽出
pop_cols = df.filter(regex=r'人口').columns
print(f'人口関連列: {len(pop_cols)} 件')

# 列名から SSDSE コードと名称を一気に分離
codes_names = df.columns.to_series().str.extract(r'^([A-Z]\d{4})_(.+)$')
codes_names.columns = ['code', 'name']
print(codes_names.head())

🚨 補足の落とし穴 5 件

• Python re モジュールのキャッシュ：同じパターン文字列を渡すと内部キャッシュされる（最大 512）。 動的に大量のパターンを生成すると性能低下。 必ず re.compile。
• マルチライン文字列："""...""" や Heredoc で \n を含む文字列をマッチさせるとき、 ^$ の挙動は re.MULTILINE 次第。
• Pandas の regex=True デフォルト変更：Pandas 2.x で str.replace の regex デフォルトが False に。 明示指定推奨。
• 正規表現での重複行除去：CSV の重複検出は drop_duplicates を使うべし。 正規表現は不向き。
• 過剰なエスケープ：文字クラス [...] 内では . や + はリテラル扱いなのでエスケープ不要。

🏅 正規表現 ベストプラクティス（実務 10 ヶ条）

1. 必ず raw string (r"...") を使う
2. compile して再利用 し、 グローバル定数に
3. 名前付きグループ でコード可読性を確保
4. verbose mode でコメント付きパターンに
5. 正例と負例のテスト を必ず書く
6. regex101 リンク をコメントに残す
7. greedy/non-greedy を明示的に指定
8. アンカー でパターンを固定
9. ReDoS リスク を事前にチェック
10. 専用ライブラリで足りるなら 正規表現を使わない

🔮 正規表現の未来 — LLM 時代に消えるか

LLM がパターン抽出を高精度でこなせる時代、 正規表現は不要になるのでしょうか？ 答えは No。 むしろ 使いこなせる人の価値が上がっています。 LLM はメガバイト単位のテキストを処理するのに高コスト、 正規表現は数ミリ秒。 SSDSE-B-2026 のような 明確な構造を持つデータ の前処理では正規表現が圧勝。

逆に「あいまいな自然言語からの意味抽出」 は LLM の独壇場。 両者を 適材適所 で組み合わせるのが現代のデータエンジニアリングです。

📊 SSDSE-B-2026 で正規表現を徹底活用する — 拡張ワークフロー

ここでは SSDSE-B-2026（都道府県別 社会・人口統計体系） の生 CSV をダウンロードしてから可視化するまでの一気通貫を、 正規表現の観点で再構成します。 公式 CSV は 2 行ヘッダ・全角空白混在・年度カラムの繰り返し など、 そのままでは pandas や Excel に取り込みにくい特徴があります。 これらを 正規表現・pandas・可視化 で順番に処理する流れを示します。

🎯 ワークフロー全体像

流れは (1) ヘッダ正規化 → (2) 列名クレンジング → (3) 数値抽出 → (4) 異常値検知 → (5) 可視化 の 5 段階。 SSDSE-B-2026 の都道府県コードは「R01100」「R02100」…のように R + 2 桁ゼロパディング + 3 桁ゼロパディングで構成され、 これ自体が正規表現 ^R\d{5}$ で検証できます。 データクレンジング の入口として最適な題材です。

📥 入力データ (SSDSE-B-2026 抜粋)

このコードでやること： SSDSE-B-2026 の生 CSV を読み込み、 正規表現 で列名のゆらぎ（全角空白・年度括弧・単位末尾）を統一する。 統一後に 記述統計 と可視化を行えるよう、 整然データ（tidy data）形式に変形する。

ここで正規表現の出番になる箇所は 3 つある。 (1) ヘッダが 2 段なので、 英字コードと日本語名を繋ぐと A110101_総人口（男） のような列名になる。 (2) その列名から コード・項目名・内訳を切り出すのに名前付きグループ (?P<code>...) が要る。 (3) 地域コードが正しい書式かを ^R\d{5}$ で検証する。 なお SSDSE-B は「年度」列を持つ縦持ち（long 形式）で、 年度が列名に入る横持ちではない点に注意。 年度が列名に入るのは市区町村版の SSDSE-A のほうである。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import pandas as pd
import re

# SSDSE-B-2026 は 1 行目が英字コード (A1101 等)、 2 行目が日本語名の 2 段ヘッダ
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', header=[0, 1], encoding='cp932')
# 2 段ヘッダを 1 行に統合し、 全角空白を含む余分な空白を除去
df.columns = ['_'.join(re.sub(r'[　\s]+', '', str(c)) for c in col).strip('_') for col in df.columns]
print('統合直後:', df.columns[:5].tolist())

# 「コード_日本語名（内訳）」を名前付きグループで 3 つに切り分ける
COL = re.compile(r'^(?P<code>[^_]+)_(?P<label>[^（]+)(?:（(?P<sub>[^）]+)）)?$')
def normalize(name):
    m = COL.match(name)
    if not m:
        return name
    g = m.groupdict()
    return g['label'] + ('_' + g['sub'] if g['sub'] else '')

df.columns = [normalize(c) for c in df.columns]
print('正規化後:', df.columns[:5].tolist())
print('重複した列名:', df.columns[df.columns.duplicated()].tolist()[:5])

# 都道府県コードを ^R\d{5}$ で検証する。 12 年分あるのでまず県単位に畳む
codes = df['地域コード'].dropna().unique()
ok = pd.Series(codes).str.match(r'^R\d{5}$')
print(f'ユニークな地域コード: {len(codes)} 件')
print(f'^R\\d{{5}}$ に適合: {ok.sum()} / {len(codes)} (期待値 47)')
print('例:', list(codes[:3]))

📤 実行例：

💬 結果の読み方: 2 段ヘッダを繋いだ直後は A110101_総人口（男） のようにコードと日本語名が同居していますが、 名前付きグループ (?P<code>[^_]+)_(?P<label>[^（]+)(?:（(?P<sub>[^）]+)）)? で 3 つに割ると 総人口_男 という短い名前に統一できます。 重複した列名が 0 件なので、 この正規化で列が潰れていないことも確認できました。 地域コードは 564 行を県単位に畳むと 47 件になり、 その全部が ^R\d{5}$ にマッチします（R01000 のように県レベルは下 3 桁が 000）。 ここでポイントなのは、 564 行のまま数えると「有効コード数 564」となって検証が素通りしてしまうこと。 縦持ちデータでは「何を 1 件と数えるか」を先に決めてから正規表現で検証する必要があります。 ここまで済めば、 あとは pandas の通常操作で十分扱えます。

📈 図1: 都道府県別 総人口の分布（散布図）

クレンジング済みのデータで 総人口 (2020) と総人口 (2023) の関係を散布図にしました。 完全に直線上に並ぶことから、 4 年間の人口変化は 規模に比例する小さなドリフト であり、 順序関係は保存されていることが分かります。 相関係数 0.999、 回帰 の傾きは 0.992。

📊 図2: 人口対数値のヒストグラム

人口は対数正規分布に近いため、 log10 を取ってからヒストグラムを描くと 正規分布に近い形 が現れます。 平均はおよそ log10(2.7×10^6) ≈ 6.43。 東京・神奈川・大阪が右肩に位置し、 中位は 中央値 約 155 万人。

📦 図3: 地域ブロック別 箱ひげ図

都道府県コードの上 2 桁から地域ブロックを推定し、 箱ひげ図 でばらつきを比較します。 関東 (R08-R14) の中央値が突出して高く、 北海道 (R01) と沖縄 (R47) は単独で外れ値的な振る舞いをします。 ブロック境界の決定にも正規表現 ^R(?P<pref>\d{2})\d{3}$ を使い、 グループ化に利用しました。

🧪 検証コード — 正規表現の単体テスト

このコードでやること： SSDSE-B-2026 で用いた 5 種類の正規表現を unittest 風に検証する。 テスト駆動開発 の考え方を正規表現に持ち込むと、 後からの修正で挙動が壊れていないかを継続的に確認できます。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import re

cases = [
    (r'^R\d{5}$',         [('R01100', True), ('R47000', True), ('R7000', False), ('r01100', False)]),
    (r',(?=\d)',           [('1,234,567', True), ('abc,def', False)]),
    (r'[　\s]+',       [(' 北海道 ', True), ('　沖縄', True), ('東京', False)]),
    (r'(\d+\.?\d*)(人|円|%)', [('125000人', True), ('12.5%', True), ('人125000', False)]),
    (r'^(-|―|…|NA)$',     [('-', True), ('―', True), ('0', False)]),
]
for pattern, samples in cases:
    for text, expected in samples:
        got = bool(re.search(pattern, text))
        ok = 'OK' if got == expected else 'NG'
        print(f"[{ok}] /{pattern}/ on '{text}' → {got} (期待 {expected})")

📤 実行例：

💬 5 パターン × 3 ケースの 15 件すべてが期待通り。 失敗ケース（rで始まる、 大文字小文字違反、 アンカー不足）を 明示的に追加 するのが、 後戻りを防ぐコツです。

🧠 落とし穴 — SSDSE 特有の罠

🔧 自己診断チェックリスト

1. 都道府県コード列に ^R\d{5}$ を当てて 47 件マッチしたか
2. 列名に 　 が残っていないか（any(　 in c for c in df.columns)）
3. 数値カラムに「人」「円」「%」が混入していないか（df.applymap(lambda x: bool(re.search(r'[^\d\.\-]', str(x))))）
4. 欠損記号が ^(-|―|…|NA|X|\*|c)$ でカバーされているか
5. 結合キーが正規表現で安全に正規化されているか（R0?(\d+)0?0? の罠に注意）
6. テスト 15 ケース以上を CI で自動実行しているか
7. ReDoS 危険パターン (a+)+, (.*)* を使っていないか
8. 外部入力に対しては re.compile 時の re.VERBOSE | re.UNICODE を指定しているか

📖 現場で起きた事例 — SSDSE と正規表現

ケース A: ある県の人口が突然 1/10 に。 「1,000,000」 の桁区切りカンマを , でナイーブに置換した結果、 後段の正規表現が「100,000」の 0 を 1 つ食ってしまい、 値が 100,000 から 10,000 になってしまった事例。 必ず lookahead ,(?=\d) を使うこと。

ケース B: 北海道だけ集計が落ちる。 都道府県名の前に全角空白が 1 文字だけ残っており、 groupby が「 北海道」「北海道」を別キーと判定。 str.strip() では 半角空白しか除去できない ため、 str.replace(r'[　\s]+', '', regex=True) でまとめて除去するのが安全。

ケース C: 年度サフィックスのゆらぎ。 「2020年」「2020 年」「（2020年）」「2020FY」「FY2020」が同じファイル内に混在し、 結合キーが噛み合わない。 (?:FY)?(?P<y>\d{4})\s*年?(?:FY)? でまとめて抽出し、 整数化してから比較すること。

ケース D: ハイフン異体字。 マイナス記号 - と長音符 ー、 全角ハイフン －、 図形描画用 ― が混在して欠損検知に失敗。 文字クラス [\-‐-—－] でまとめて捕まえる。 文字コード も合わせて確認。

ケース E: ReDoS 攻撃。 ユーザー入力した長文に ^(\w+)*$ を当てたところ、 サーバが 30 秒間 100% CPU を消費。 ReDoS を学び、 re2 ライブラリや regex モジュール (timeout=) を使う。

🧰 SSDSE-B-2026 専用 正規表現ライブラリ（再利用可能）

このコードでやること： SSDSE-B-2026 の前処理で頻出する 8 種類の正規表現を 1 つのモジュール ssdse_regex.py にまとめ、 関数化しておく。 こうしておくと Jupyter ノートブックや パイプライン から import するだけで再利用できる。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# ssdse_regex.py
import re

PREF_CODE = re.compile(r'^R\d{5}$')
YEAR_SUFFIX = re.compile(r'(?P<base>.+?)（?(?P<year>\d{4})年?）?$')
THOUSANDS = re.compile(r',(?=\d)')
WHITESPACE = re.compile(r'[　\s]+')
MISSING = re.compile(r'^[\-―…NA\*Xxc]$')
UNIT = re.compile(r'(?P<value>\d+\.?\d*)(?P<unit>人|円|%|世帯|km2)')
YEAR_RANGE = re.compile(r'(?P<f>\d{4})[\-〜~](?P<t>\d{4})')
HYPHEN_VARIANTS = re.compile(r'[\-‐‒–—－]')

def normalize_pref(name):
    """都道府県名から全角空白・改行を除去"""
    return WHITESPACE.sub('', name)

def to_int(value):
    """桁区切りカンマと単位を除いた整数を返す"""
    s = THOUSANDS.sub('', str(value))
    m = UNIT.match(s)
    return int(float(m.group('value'))) if m else int(float(s))

def is_missing(value):
    return bool(MISSING.match(str(value).strip()))

def parse_year(name):
    m = YEAR_SUFFIX.search(name)
    return int(m.group('year')) if m else None

📤 使用例：

💬 4 つの関数を組み合わせるだけで、 SSDSE-B-2026 の 列名整形 → 単位除去 → 欠損変換 → 年度抽出 が一気通貫で行えます。 同じパターンを毎回書くと typo で挙動が変わるので、 定数として 1 か所に集約 しておくのが鉄則。

📋 ライブラリ採用時のメリット・デメリット

🗣 物語で理解する — SSDSE-B-2026 の都道府県名クレンジング

あるデータ分析チームが、 SSDSE-B-2026 から都道府県別の 合計特殊出生率 と 総人口 の関係を可視化しようとしました。 ところが、 散布図を描いたら点が 92 個 出てきました。 47 都道府県のはずなのに、 倍近い数。 原因を 1 つずつ追っていくと、 すべて文字列のクレンジング不足が原因でした。 ここではその物語を、 正規表現の使い方とともに辿ります。

場面 1 — 「 北海道」と「北海道」の対立

最初に発見されたのは、 '北海道' と ' 北海道' （先頭に半角空白）が groupby のキーとして別物扱いされている問題でした。 pandas の str.strip() は半角空白だけを除去するため、 全角空白 '　' が残るケースが見落とされます。 修正は df['都道府県'].str.replace(r'[　\s]+', '', regex=True)。 これで 92 個のうち 18 個の重複が一気に解消されました。

場面 2 — 「東京都」と「東京」と「Tokyo」

別ファイルから結合した部分で「東京」「東京都」「Tokyo」「TOKYO」 が混在。 文字列マッチでは絶望的ですが、 正規表現なら ^(?:東京都?|Tokyo)$ でまとめてマッチできます。 さらに大文字小文字を無視するなら re.IGNORECASE または (?i)。 修正後の都道府県ユニーク数は 92 → 60 件まで減少。

場面 3 — 「（沖縄）」と「沖縄県」の括弧表記

原典側で「（沖縄）」のように 括弧つき の記述があったため、 別キーになっていました。 正規表現 ^[（(]?(?P<name>.+?)(?:県|府|都|道)?[)）]?$ で本体名を取り出し、 末尾の「県／府／都／道」を取り去ってから正規化。 これで 60 → 50 件。

場面 4 — 半角数字と全角数字

都道府県コードに「Ｒ０１１００」（全角）と「R01100」（半角）が混在していました。 unicodedata.normalize('NFKC', s) で一括正規化したあと ^R\d{5}$ で再検証。 47 件に揃った瞬間、 チームから歓声が上がりました。 正規化と正規表現は 常にセットで考える べきです。

場面 5 — 出生率の数値抽出

最後に、 合計特殊出生率カラムが「1.27（推計）」「1.32 (確報)」のように括弧で注釈が付いていました。 ^(?P<rate>\d+\.\d+)\s*[（(](?P<flag>.+?)[)）]\s*$ で本体と注釈を分離。 推計値と確報値で平均が 0.04 ずれていたため、 データ品質 の指標として注釈フラグを別カラムに残しました。

場面 6 — 散布図が美しく描けた

5 段階のクレンジングを経て、 47 都道府県の 合計特殊出生率 × 総人口 の散布図がようやく完成。 沖縄が右下（人口少・出生率高）に、 東京が左上（人口多・出生率低）に位置するという、 教科書通りの傾向が明瞭に出ました。 もし正規表現を 使わずに目視で都道府県名を統一 していたら、 1 人 1 日の作業になっていたでしょう。

この物語の教訓は明確です： 正規表現は「文字列を機械的に正しく揃える」最強の武器。 ただし 万能ではなく、 データ品質 の理解、 文字コード の知識、 そして テスト による検証と組み合わせて初めて真価を発揮します。

🍳 即戦力レシピ集 — 場面別正規表現 15 連発

よく使う正規表現を 15 種類 ピックアップしました。 各々に 「目的・パターン・サンプル入力・サンプル出力」 の 4 要素を揃えてあります。 SSDSE-B-2026 だけでなく、 ログデータ や テキストデータ の前処理にも転用できます。

📥 入力データ（再利用しやすいテストセット）

このコードでやること： 上記 15 パターンを動かす最小テキストを Python リストにまとめ、 すべて一気に検証する。 テスト を後から増やしやすい形を意識した。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import re

patterns = {
    '郵便番号': r'\d{3}-\d{4}',
    '電話': r'0\d{1,4}-\d{1,4}-\d{4}',
    'URL': r'https?://[\w\-./?%&=]+',
    '和暦': r'(令和|平成|昭和)(\d+)年',
    'ISO日付': r'\d{4}-\d{2}-\d{2}',
    '日本語': r'[ぁ-んァ-ヶ一-龯々]+',
    '英数字': r'[A-Za-z0-9]+',
    '実数': r'-?\d+\.\d+',
    'パーセント': r'(\d+\.?\d*)\s*%',
    '単語境界': r'\bdata\b',
}
samples = [
    '〒730-0011 広島市', '082-251-1111', 'https://e-stat.go.jp',
    '令和5年', '2024-10-01 集計', 'Tokyo東京都', 'コードA12B3',
    '平均-0.42', '12.5 %', 'database, data',
]
for name, p in patterns.items():
    found = [s for s in samples if re.search(p, s)]
    print(f'{name}: {len(found)} 件 / 候補 {len(samples)} 件')

📤 実行例：

💬 結果の読み方: 全パターンが少なくとも 1 件マッチしていますが、 件数を数えると「拾いすぎ」がはっきり見えます。 「日本語」は 6 件 ──「広島市」「令和5年」「集計」「東京都」「コード」「平均」を拾っており、 [ぁ-んァ-ヶ一-龯々]+ は漢字・ひらがな・カタカナを全部含むので当然の結果です。 「英数字」に至っては 10 件すべて、 つまり [A-Za-z0-9]+ はほぼ何にでも当たります（「〒730-0011 広島市」も数字を含むため該当）。 いちばん危ないのが「郵便番号」の 2 件で、 \d{3}-\d{4} は「730-0011」だけでなく電話番号「082-251-1111」の後半にも当たってしまう。 アンカー ^...$ や単語境界 \b を付けていないことによる典型的な誤検出です。 「マッチした／しなかった」ではなく件数と中身を目視することで、 このように正規表現を強める判断材料が得られます。

❓ Q&A — 正規表現でつまずく質問 10 連発

Q1. 「.*」 と 「.*?」 の違いは？

.* は 貪欲（できるだけ長くマッチ）、 .*? は 非貪欲（できるだけ短くマッチ）。 HTML <a>...</a> を抜くとき、 貪欲だと最初の <a> から最後の </a> まで一括で食う。 非貪欲なら 1 つずつ。 SSDSE 注釈付き値「12.3 (推計)」を抜くときも非貪欲 \((.+?)\) が安全。

Q2. ^ と $ はいつ要る？

完全一致を要求するとき。 都道府県コード R01100 を検証したいなら ^R\d{5}$。 アンカーを忘れると「prefR01100xyz」も True を返すので、 ID 検証では必ず付ける。

Q3. キャプチャグループとは？

丸括弧 (...) で囲んだ部分が group(1), group(2), ... として取り出せる。 名前付きにするなら (?P<name>...)。 取り出す必要のないグルーピングは (?:...) で非キャプチャに。

Q4. re.search と re.match と re.fullmatch の違い？

search はどこかにあれば True、 match は 先頭 から一致、 fullmatch は 全体 一致。 都道府県コード検証なら fullmatch を使うとアンカー ^...$ を書かずに済む。

Q5. なぜ raw string を使うの？

普通の文字列だと '\d' が「\d」ではなく「未定義のエスケープ」扱い。 r'\d' なら そのまま正規表現エンジンに渡る。 Python 3.12 以降は警告が出る。

Q6. flags はどう指定する？

re.IGNORECASE, re.MULTILINE, re.DOTALL, re.VERBOSE を | で結合。 パターン内で (?im)... と書く方法もある。 SSDSE のように改行が混じる長文では re.DOTALL 必須。

Q7. 改行はどうマッチさせる？

\n または \r\n。 ドット . は re.DOTALL がない限り改行を含まない。 [\s\S] で「あらゆる文字」を表現する裏技も常用される。

Q8. CSV を正規表現で読むのは？

原則 NG。 ダブルクォート内のカンマ、 エスケープなど CSV の文法を 正規表現で完全に表現するのは不可能 に近い。 必ず pandas.read_csv() や csv モジュールを使う。 正規表現はあくまで セル内の文字列処理 に限定する。

Q9. HTML タグを正規表現で？

同じく 原則 NG。 Stack Overflow の有名な答え にもあるように、 入れ子の HTML は 正規言語ではない ので正規表現では完全には扱えない。 BeautifulSoup を使うべき。

Q10. 速度が遅い時の原因は？

バックトラックの爆発 がほぼ全て。 (a+)+, (.*)*, (a|a)+ のようなパターンは ReDoS 確定。 対策は (1) 重複ループを取り除く、 (2) 可能な限り 非貪欲 や 独占的量詞 を使う、 (3) re2 モジュール (バックトラックしない) を使う、 (4) timeout 機能のある regex モジュールへ切替。

🔬 数式を言葉で読み解く

数式に出てくる記号の意味を 1 つずつ確認しましょう。

.

改行以外の任意 1 文字。

\d

数字 1 文字 (= [0-9])。

\w

英数字＋アンダースコア 1 文字。

*

直前パターンを 0 回以上繰り返し。

+

直前パターンを 1 回以上繰り返し。

()

グループ化・キャプチャ。

🔬 正規表現を言葉で読み解く（regex narration ）

正規表現 \d{3}-\d{4}-\d{4} を「日本語で声に出して読む」と何になるでしょうか？ ── 「数字を 3 文字、 次にハイフン、 次に数字を 4 文字、 次にハイフン、 次に数字を 4 文字」。 これを 1 行 で書ける小型言語こそが正規表現の本質です。

SSDSE-B-2026 のような 都道府県統計データ でも、 列名 "A1101_総人口" から「コード A1101」 と「名称 総人口」 を分離したいシーンが頻発します。 正規表現 r"^([A-Z]\d{4})_(.+)$" 一発で 100 列同時に処理できる ── これが正規表現の 生産性。

記号を 1 つずつ分解：(1) r"..." は raw 文字列 で、 \ をエスケープせず文字通り扱う Python の記法。 正規表現は \ を多用するので必須。 (2) ^ は「文字列の先頭」、 $ は「文字列の末尾」 を意味するアンカー。 これでパターン全体を固定する。 (3) [A-Z] は「英大文字 A〜Z のいずれか 1 文字」。 (4) \d は「数字 0-9 のいずれか 1 文字」、 {4} は「直前パターンをちょうど 4 回」。 (5) ( ... ) はキャプチャグループで、 後で .group(1) で取り出せる。 (6) . は「任意の 1 文字（改行以外）」、 + は「1 回以上の繰り返し」。

この読み解きを習慣にすると、 正規表現は「呪文」 ではなく「明確な文法を持つミニ言語」 として見えてきます。 SSDSE-B-2026 の前処理で「英数字 + アンダースコア + 日本語」 のような列名パターンを扱うとき、 正規表現がなければ手作業で 100 列を一つ一つ処理することになります。 正規表現を覚えれば 1 行。 これがデータエンジニアリングの基本素養と言われる所以です。

さらに、 「貪欲（greedy）」 と「最小（non-greedy）」 の対立も日本語で読むと納得できます。 .* は「任意の文字を できるだけ多く 連続」、 .*? は「できるだけ少なく 連続」。 「<b>foo</b>bar<b>baz</b>」 から太字部分を取り出すとき、 <b>.*</b> は最初の <b> から最後の </b> まで全部マッチしてしまう。 <b>.*?</b> なら最短で「<b>foo</b>」 と「<b>baz</b>」 を別々に拾える。 これは 最大の罠 なので必ず覚えてください。

🧮 実値で計算してみる

ログから IP アドレスを抽出する典型例。

🧮 SSDSE-B-2026 列名から実値で正規表現

SSDSE-B-2026 の列名は A1101_総人口、 A2101_15歳未満人口、 B1101_出生数 のような形式。 正規表現でコードと名称を一気に分離：

この 1 つの正規表現で 100 列以上一気に処理できます。 SSDSE のコード体系を理解する第一歩。

📋 正規表現 メタ文字 完全チートシート

文字クラス

量化子

アンカー・グループ

🛠 実用パターン集 — データ前処理で必ず使う 20 例

🧮 数式に値を入れて手で計算する: 正規表現マッチ件数

合成 5 文字列で電話番号正規表現の一致を計算する。

Step 1: 入力

Step 2: マッチ

🐍 Python で再現

1
2
3
4
5

import re
strs = ["03-1234-5678", "abc", "090-1111-2222", "12345", "06-9999-0000"]
pattern = re.compile(r"\d{2,4}-\d{4}-\d{4}")
matches = [s for s in strs if pattern.fullmatch(s)]
print(f"マッチ数: {len(matches)}/{len(strs)}")

📤 実行結果

💬 手計算 (Step 2) 3/5 と Python 出力が完全一致。

🐍 Python 実装

最小実装の例。 SSDSE のような実データに対して、 まずはコピペで動かしてみるのが理解の早道です。

1
2
3
4
5

import re
log = '2026-05-19 192.168.1.1 GET /index'
pat = re.compile(r'\d{1,3}(?:\.\d{1,3}){3}')
ips = pat.findall(log)
print(ips)  # ['192.168.1.1']

🐍 SSDSE-B-2026 を 正規表現 で完全前処理する Python パイプライン

SSDSE データ読み込み → 列名分離 → 都道府県コード抽出 → 数値の正規化 まで一気に：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

import pandas as pd
import re

# 1. データ読み込み
df = pd.read_csv('data/raw/SSDSE-B-2026.csv', encoding='cp932', skiprows=1)
print(f'列数: {len(df.columns)}, 行数: {len(df)}')

# 2. 列名から SSDSE コードと名称を分離
col_pat = re.compile(r'^([A-Z]\d{4})_(.+)$')
codes, names = [], []
for col in df.columns:
    m = col_pat.match(col)
    if m:
        codes.append(m.group(1))
        names.append(m.group(2))
    else:
        codes.append(None)
        names.append(col)

# 3. 都道府県名から「都」「道」「府」「県」 を分離
pref_pat = re.compile(r'^(.+?)([都道府県])$')
def split_pref(name):
    m = pref_pat.match(name)
    return m.groups() if m else (name, None)

# 4. 数値の「カンマ区切り」 を除去（CSV で文字列化されている場合）
num_pat = re.compile(r'^\d{1,3}(?:,\d{3})*(?:\.\d+)?$')
def parse_num(x):
    if isinstance(x, str) and num_pat.match(x):
        return float(x.replace(',', ''))
    return x

# 5. 全列に適用
for col in df.columns:
    if df[col].dtype == 'object':
        df[col] = df[col].apply(parse_num)

# 6. SSDSE カテゴリ別集計（A=人口, B=人口動態, ...）
category_pat = re.compile(r'^([A-Z])')
df_codes = pd.DataFrame({'code': codes, 'name': names})
df_codes['category'] = df_codes['code'].str.extract(category_pat)
print(df_codes.groupby('category').size())

このコードで 100 行以上の SSDSE データを 1 分以内に整形できます。 正規表現なしでは数時間の手作業になります。

🎮 触って理解する

下のライブ正規表現テスターで、 パターンを入力すると対象テキストのマッチ箇所がリアルタイムでハイライトされます。 対象テキストは架空のデータクレンジング風サンプル（電話番号・日付・金額・メールが混在した問い合わせログ）で、 自由に書き換え可能。 プリセットボタンで代表パターンを一発投入でき、 ( ) のキャプチャ結果、 replace による置換結果も同時に確認できます。 マッチの位置は下のマッチマップ (SVG) に表示され、 クリック／ドラッグ／スワイプで注目するマッチを切り替えられます。 処理は JavaScript の RegExp で正確に実行し、 不正なパターンはエラー表示します。

直感：正規表現は「文字列のパターン記法」という小型言語

プリセット「数字列 \d+」を押すと、 電話番号・日付・金額の数字部分がすべて緑に光ります。 これが正規表現の本質で、 「数字が 1 個以上続く場所」という鋳型 (パターン) を 3 文字で宣言しただけで、 テキスト中の該当箇所が全部拾えます。 次に「日付」「電話番号」を押すと、 鋳型を具体的にするほどマッチが絞り込まれる様子が分かります。 \d{4}（数字ちょうど 4 個）のように量化子で回数を指定し、 [-/.] のように文字クラスで「この中のどれか 1 文字」と書く ── この 2 つの組み合わせだけで、 実務のパターンの大半は書けます。

よくある落とし穴を実際に踏んでみる

• . の意味とエスケープ忘れ：プリセット「. の罠」(\d{4}.\d{2}.\d{2}) を押すと、 ドット区切りの日付だけでなく 2026-04-01 までマッチします。 . は「任意の 1 文字」だからです。 「\. でエスケープ」を押すと 2026.04.03 だけに絞られます。 リテラルの . + * ? ( ) [ ] は必ず \ でエスケープ。
• 貪欲 vs 非貪欲：「貪欲 <.*>」を押すと、 最終行の <A101> と <B202> と <C303> が丸ごと 1 個のマッチになります (.* は最長一致)。 「非貪欲 <.*?>」に切り替えると、 タグ 3 個が別々にマッチします。 マッチ件数が 1 → 3 に変わるのをマッチマップで確認してください。
• 全角と半角：4 行目の電話番号は全角数字 ０９０-… なので、 \d+ ではマッチしません（JavaScript でも Python の re のデフォルトでも \d は原則半角）。 プリセット「全角数字 [０-９]+」で初めて拾えます。 日本語の実データでは、 正規表現を書く前に unicodedata.normalize('NFKC', s) で全角→半角に正規化するのが定石です（データクレンジング参照）。

発展：pandas の str.extract と名前付きグループ

プリセット「グループ( )＋置換」を押すと、 日付が ( ) で年・月・日の 3 グループに分解され、 下のキャプチャ表に $1 $2 $3 の中身が表示されます。 置換欄の $1年$2月$3日 により表記が統一される ── これが pandas の df[col].str.extract(r'(\d{4})[-/.](\d{1,2})[-/.](\d{1,2})') や str.replace(..., regex=True) でやっていることの正体です。 「名前付きグループ」プリセットでは (?<y>...) がグループに名前を付けます。 構文は言語で少し違い、 JavaScript は (?<y>...)、 Python は (?P<y>...) で、 pandas の str.extract に名前付きグループを渡すとグループ名がそのまま列名になるため、 SSDSE-B-2026 のような多列データの前処理コードが自己文書化されます。 パターンで書き切れない表記揺れは 形態素解析や自然言語処理の領分です。

⚠️ よくある落とし穴

正規表現の罠は 動かないことではなく 意図と違うものを「成功扱い」でマッチしてしまうこと にある。 「電話番号」を抽出したつもりが 11 桁以外を取り逃したり、 SSDSE-B-2026 のコード A1101 を A\d+ で拾ったら A11010 まで巻き込んだ ── など、 silent failure が支配的です。 以下は実務で頻発する 4 パターン。

⚠️ 正規表現 落とし穴 10 連続

1. Catastrophic Backtracking：(a+)+b のようなネストした量化子は、 マッチしない入力で指数時間。 必ず 所有量化 や非backtrack 設計を。
2. Greedy が長すぎる：.* はファイル全体を飲み込みかねない。 必要なら .*? や [^>]* を。
3. エスケープ忘れ：. は任意 1 文字。 リテラル「.」 を表すには \.。
4. Unicode の挙動差：\w は Python 3 で日本語を含むが、 一部の言語（Go, JavaScript） では英数字のみ。
5. マルチライン：^ と $ はデフォルトで文字列の先頭・末尾のみ。 各行の先頭・末尾にしたいなら re.MULTILINE フラグ。
6. ドット改行：. は通常改行を含まない。 改行を含めたいなら re.DOTALL。
7. 大文字小文字：デフォルトで区別。 区別しないなら re.IGNORECASE。
8. raw 文字列忘れ：Python では必ず r"..."。 "\d" のような書き方は警告。
9. 過剰な使用：CSV パースに正規表現は禁忌。 csv モジュールを使う。
10. セキュリティ：ユーザー入力をそのままパターンに使うと ReDoS 攻撃。 re.escape で逃がす。

🚨 ReDoS（正規表現サービス拒否） 攻撃

ReDoS（Regular expression Denial of Service） は、 悪意ある入力で正規表現を 指数時間 動かし、 サーバーをダウンさせる攻撃。 (a+)+b のような nested quantifier が典型的な脆弱性。

対策：(1) 正規表現エンジンを re2（Google）に切り替える ── 線形時間保証あり。 (2) タイムアウト付き実行（regex.search(... , timeout=1.0)）。 (3) パターン分析ツール（safe-regex） で nested quantifier を検出。 SSDSE 用途では入力が制御されているので大きな脅威ではないが、 Web アプリで正規表現を使うときは要注意。

🔍 正規表現 vs 他手法 — どちらを使うべきか

📜 正規表現の歴史 — 形式言語理論から実務へ

1956 年、 数学者 Stephen Kleene が「regular set（正則集合）」 という概念を発表したのが起源。 Kleene 閉包（*） は彼の名前にちなみます。 これは 有限オートマトン で受理できる言語のクラスです。

1968 年、 Ken Thompson（後の Unix 開発者） が QED エディタに正規表現エンジンを実装。 これが grep（"global regular expression print"） として独立。 「grep」 はその後の Unix 文化の象徴に。

1980 年代後半、 Henry Spencer の regex ライブラリと Perl の正規表現が拡張機能を多数追加（後方参照、 先読み、 名前付きグループ）。 これが PCRE（Perl Compatible Regular Expressions） として標準化され、 多くの言語が採用。

2010 年代、 Google が re2（RE2） をリリース ── PCRE の柔軟性は犠牲にする代わり、 線形時間 で動作する正規表現エンジン。 ReDoS 対策の決定版。 Rust の regex も同様の保証。

現在、 LLM 時代でも正規表現は廃れていません。 むしろ「LLM が出した文字列をパースする」 ような場面で再評価。 SSDSE-B-2026 のような構造化データの前処理では、 LLM より 正規表現の方が高速・正確 です。

🧪 正規表現のテスト駆動開発

正規表現は 書いた直後は 正しいように見えても、 エッジケースで誤動作することが多い。 テストファースト で書くのが現代的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import re

PHONE_PAT = re.compile(r'^0\d{1,4}-\d{1,4}-\d{3,4}$')

def is_phone(s):
    return bool(PHONE_PAT.match(s))

# テストケース（pytest でそのまま集められる形）
def test_valid_phones():
    assert is_phone('03-1234-5678')      # 東京
    assert is_phone('082-1234-5678')     # 広島
    assert is_phone('090-1234-5678')     # 携帯
    assert is_phone('0120-12-3456')      # フリーダイヤル

def test_invalid_phones():
    assert not is_phone('123-456-7890')    # 0 始まりでない
    assert not is_phone('03-1234-56789')   # 桁過剰
    assert not is_phone('03 1234 5678')    # スペース区切り
    assert not is_phone('0312345678')      # ハイフンなし
    assert not is_phone('')                # 空
    assert not is_phone('abc-1234-5678')   # 英字混入

# ファイルに保存したら `pytest ファイル名.py -v` で実行する。
# ノートブックやブラウザには __file__ が無いので、ここでは関数を直接呼ぶ。
test_valid_phones()
test_invalid_phones()
print('2 件のテストをすべて通過')

正規表現を pytest で守ることで、 リファクタしても挙動が変わらないことを保証できます。 SSDSE データの列名パース処理にも適用すべき手法。

🛠 正規表現 開発ツール

• regex101.com：オンラインで正規表現をリアルタイムテスト。 PCRE/Python/Java など複数エンジン対応。
• regexr.com：軽量で見やすい UI。 ライブラリ機能あり。
• RegexBuddy：商用、 IDE級の機能。
• VSCode 検索パネル：Ctrl+F で正規表現検索（.* アイコン）。
• ripgrep（rg）：超高速 grep 代替、 デフォルトで正規表現対応。
• Python re モジュール：標準ライブラリ。 re.DEBUG フラグでパース過程を可視化。
• regex（PyPI）：標準 re の拡張版。 名前付き属性、 Unicode カテゴリなど。

🎓 正規表現 習得ロードマップ

1. Week 1：メタ文字 5 つ（. * + ? [ ]）を覚える。 regex101 で 20 個練習。
2. Week 2：量化子と文字クラス（\d, \w, \s, {n}）。 SSDSE 列名で実践。
3. Week 3：グループとキャプチャ（(...), (?:...), (?P<name>...)）。 抽出パターン作成。
4. Week 4：アンカー（^, $, \b）と先読み・後読み。 URL/メール のバリデーション。
5. Week 5：エッジケース対応とテスト。 pytest で守る。
6. Week 6：ReDoS と性能。 re2 と組み合わせ。
7. Week 7：形式言語理論（オートマトン） を Sipser で学ぶ（オプション）。
8. Week 8：実プロジェクトに投入。 SSDSE 前処理パイプラインを完成。

🚀 正規表現 上級テクニック 10 選

1. 名前付きキャプチャ

複雑なパターンでは (?P<name>...) で各グループに名前を付ける。 m.group('year') でアクセス。 メンテナンス性が大幅に向上。

1
2
3

pat = re.compile(r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})')
m = pat.match('2026-05-19')
print(m['year'], m['month'], m['day'])  # 2026 05 19

2. 先読み・後読み

(?=...) 肯定先読み、 (?!...) 否定先読み、 (?<=...) 肯定後読み、 (?<!...) 否定後読み。 マッチには含めず 文脈条件を指定。

1
2
3
4

# 「円」 が後ろにある数字だけ抽出
re.findall(r'\d+(?=円)', '1000円 と 200ドル')  # ['1000']
# 「$」 が前にある数字
re.findall(r'(?<=\$)\d+', '$1000 と 200円')  # ['1000']

3. 後方参照

\1, \2 で前のグループにマッチした文字列を再利用。 HTML タグの対応チェックや繰り返し検出に有用。

1
2

# 重複単語検出
re.findall(r'\b(\w+)\s+\1\b', 'the the cat sat')  # ['the']

4. 条件分岐

(?(1)yes|no) で「グループ 1 がマッチしたか」 で異なるパターンを使う。 PCRE/Python 標準で利用可能。

5. 所有量化子（atomic group）

(?>...) で「バックトラッキングしない」 領域を定義。 catastrophic backtracking 対策。 Python 標準 re はサポートしないので regex ライブラリ。

6. Unicode カテゴリ

\p{L} 文字、 \p{N} 数字、 \p{Han} 漢字。 regex ライブラリで使える。 多言語処理で強力。

7. inline フラグ

(?i) で大文字小文字無視、 (?m) でマルチライン、 (?s) でドット改行マッチ。 パターン内で局所的に適用可能。

8. verbose モード

re.VERBOSE で空白とコメントを無視。 複雑なパターンが 読みやすく なる。

1
2
3
4
5
6
7

pat = re.compile(r"""
    ^               # 先頭
    (?P<code>[A-Z]\d{4})  # SSDSE コード
    _               # 区切り
    (?P<name>.+)    # 変数名
    $               # 末尾
""", re.VERBOSE)

9. コンパイル済みパターン

何度も使うパターンは re.compile() で事前コンパイル。 数倍の高速化が期待できます。 SSDSE 47 都道府県を処理するときは特に効果大。

10. finditer と sub 関数

finditer はメモリ効率的（イテレータ）、 sub は関数を渡せる（置換ロジック動的）。 大量データ処理の常套手段。

📝 正規表現を用いた処理のレポート方法

論文や業務レポートで「正規表現で前処理した」 と書くとき、 含めるべき情報：

✅ 正規表現 利用前の 15 項目チェックリスト

設計

• □ 本当に正規表現が最適か（CSV→csv モジュール、 HTML→BeautifulSoup ではないか）
• □ raw 文字列 r"..." を使っているか
• □ アンカー ^ $ でパターンを固定したか
• □ greedy/non-greedy の挙動を意識したか
• □ 名前付きグループでメンテナンス性を確保したか

パフォーマンス

• □ ネストした量化子（(a+)+ など） がないか
• □ 大量繰り返し利用なら re.compile したか
• □ ReDoS リスクの入力源から守られているか

テスト

• □ 正例 3 件以上でマッチ確認
• □ 負例 3 件以上で非マッチ確認
• □ エッジケース（空文字、 改行、 Unicode） を網羅
• □ pytest で自動テスト化

運用

• □ パターンをコメント付きで保存
• □ regex101 リンクをコードコメントに
• □ 失敗時のフォールバック処理

💼 実プロジェクト 5 つの正規表現事例（SSDSE 系）

事例 1: SSDSE 列名の一括リネーム

SSDSE-B-2026 の列名は A1101_総人口 形式。 これを「総人口_A1101」 のように名称優先 に並び替えたい：

1
2
3

df.columns = df.columns.str.replace(
    r'^([A-Z]\d{4})_(.+)$', r'\2_\1', regex=True
)

事例 2: 都道府県名から「都道府県」 を一括除去

「東京都」 → 「東京」、 「北海道」 → 「北海」、 「大阪府」 → 「大阪」、 「広島県」 → 「広島」：

1
2
3

df['pref_short'] = df['都道府県'].str.replace(
    r'[都道府県]$', '', regex=True
)

ただし「北海道」 を「北海」 に略すと意味が変わるので注意。 文脈に応じて。

事例 3: 数値の単位変換（千円→円）

列名「県民所得（千円）」 から単位を抽出し、 値を 1000 倍：

1
2
3
4
5
6
7
8

for col in df.columns:
    m = re.search(r'（千円）|（百万円）|（億円）', col)
    if m:
        unit = m.group(0)
        multiplier = {'（千円）': 1000, '（百万円）': 10**6, '（億円）': 10**8}[unit]
        df[col] = df[col] * multiplier
        new_name = re.sub(r'（千円）|（百万円）|（億円）', '（円）', col)
        df.rename(columns={col: new_name}, inplace=True)

事例 4: 全角数字を半角に

SSDSE は半角数字だが、 古い統計データは全角混入。 正規表現で一括変換：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# ── この抜粋で使うデータを用意します（全角数字が混ざった例）──
import pandas as pd

df = pd.DataFrame({'col': ['１２３', '456', '７８９', None]})

z2h = str.maketrans('０１２３４５６７８９', '0123456789')
df['col'] = df['col'].apply(lambda x: x.translate(z2h) if isinstance(x, str) else x)
# または正規表現で
df['col'] = df['col'].str.replace(
    r'[０-９]', lambda m: chr(ord(m.group(0)) - 0xFEE0), regex=True
)

事例 5: コード抽出と階層分類

SSDSE コードの最初の英字でカテゴリ分類（A=人口, B=人口動態, C=自然環境, ...）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

SSDSE_CATEGORIES = {
    'A': '人口', 'B': '自然環境', 'C': '経済基盤',
    'D': '行政基盤', 'E': '教育', 'F': '労働',
    'G': '文化・スポーツ', 'H': '住居', 'I': '健康・医療',
    'J': '福祉・社会保障', 'K': '安全', 'L': '家計',
}
def classify(col):
    m = re.match(r'^([A-Z])', col)
    return SSDSE_CATEGORIES.get(m.group(1), '不明') if m else '不明'
df_meta = pd.DataFrame({'col': df.columns})
df_meta['category'] = df_meta['col'].apply(classify)
print(df_meta.groupby('category').size())

⚠️ 深掘り落とし穴 — 正規表現で間違いがちなパターン 8 選

1. 貪欲マッチで全部食う： <.*> は HTML 全体を 1 つのタグと判定。 非貪欲 <.*?> もしくは文字クラス <[^>]*> を使う。
2. ドットが改行を含まない： . は既定で \n を含まない。 re.DOTALL または (?s) を必ず付ける。
3. アンカー忘れ： \d{5} だけでは「ABC12345XYZ」も部分マッチ。 完全一致なら ^\d{5}$。
4. キャプチャグループ過多： 不要なグループは (?:...) で非キャプチャに。 速度と可読性が向上。
5. バックスラッシュ地獄： raw string r'\d+' を使わず '\\d+' と書くとエスケープが二重で読みにくい。
6. Unicode を考慮しない： 日本語混じりは \w がデフォで非日本語のみマッチ。 re.UNICODE または regex モジュールの \p{Hiragana} を使う。
7. 境界条件のミス： \b は ASCII 単語境界のみ判定。 日本語では機能しない、 (?<!\S) 等の lookaround で代替。
8. ReDoS： (a+)+b のような重複ループはバックトラック爆発を引き起こす。 ReDoS 解説を必読。

これらの罠を避けるには、 (1) raw string + 名前付きグループ + コメント (re.VERBOSE) の三点セットを常用すること。 また テスト駆動 で「失敗ケースを先に書く」習慣を付けると、 想定外のマッチを早期に潰せます。

🎯 正規表現 — 最終まとめ

正規表現は 文字列処理の万能ツール です。 SSDSE-B-2026 のような公的統計データの前処理から、 ログ解析、 入力バリデーション、 LLM 出力のパースまで、 用途は無限。 ただし 万能ではない ── HTML/CSV/JSON のような構造化データには専用ライブラリを、 自然言語の意味抽出には NLP を使うこと。

本ページのチートシート・実用パターン集・テスト駆動例を傍らに置いて、 SSDSE データを実際に動かしてみてください。 データ前処理、 ログデータ、 テーブル、 自然言語処理 も合わせて学ぶと、 データエンジニアリングの全体像が掴めます。

🌐 関連手法・派生

この用語を理解したら、 自然と気になる発展トピック・派生手法を紹介します。

🌐 言語別 正規表現エンジン比較

DFA は線形時間だが後方参照・先読みなど高度機能なし。 NFA は機能豊富だが ReDoS リスク。 用途に応じて選択。

🔗 関連用語 (前提・並列・発展)

この用語と直接結びつく前提・並列・発展用語。 学習順序の参考にどうぞ。

regex (正規表現) を学ぶ際に併読すると理解が深まる関連用語。 SSDSE-B-2026 で市区町村コード R01100 や年度表記 2026 年 を抽出する場面が「使いどころ」のイメージを与える。

• 前提概念: 文字認識 / CSV — 正規表現はそもそも「文字列を読み込んだあと」の処理であり、 OCR 結果や CSV パースで文字列が手元にあることが前提
• 並列概念: 自然言語処理 / n-gram — テキスト解析の別アプローチ。 正規表現が「形式が固定された記号列」を扱うのに対し、 NLP は「意味的特徴量」を扱う棲み分け
• 発展概念: 行動ログ / データクレンジング — 正規表現を使った前処理パイプライン。 アクセスログから URL パスやセッション ID を抽出し、 分析用テーブルに変換する処理の中核

正規表現はログ解析・前処理・抽出で最頻出だが、 ReDoS リスクと形式言語論の限界(HTML/XML のような入れ子構造はパースできない) を理解した上で使うことが、 上級者と初心者を分ける境界線になる。 並列概念の NLP は意味的処理、 正規表現はパターン記述という分担関係を意識すると、 「いつ regex で十分か／いつ NLP に切り替えるか」が判断しやすい。

📚 関連グループ教材・さらに学ぶには

このサイト内

• 論文一覧に戻る — 正規表現 を実際に使った再現論文をハンズオン形式で読む
• 関連用語ページ — このページの「🔗 関連用語」から派生
• 用語集トップ — 全用語を一覧で確認
• 概念マップ — 用語間の関係を視覚化

推奨書籍・教材

• 『統計学入門』（東京大学出版会）― 日本語統計入門の定番。 データ前処理 の基礎が押さえられる。
• 『Pythonによるデータ分析入門』（Wes McKinney、 O'Reilly）― pandas 作者による実装ガイド。
• 『機械学習のエッセンス』（加藤公一、 SBクリエイティブ）― ML 基礎を Python で実装しながら学ぶ。
• 『因果推論の科学』（Judea Pearl、 文藝春秋）― 相関と因果の違いを徹底解説。

オンライン教材

• scikit-learn 公式ドキュメント — 機械学習の標準実装。
• StatQuest (YouTube) — 統計概念を直感的に解説。
• Coursera / edX — 体系的なオンライン講座。
• SSDSE 公式 — 本サイトで使う公的データの提供元。

困ったときは

1. データの可視化 (散布図・ヒストグラム・箱ひげ図) で全体像を把握
2. サンプルサイズ・欠損・外れ値を確認
3. 適用条件 (前提) が満たされているか診断
4. 類似研究での標準的な手法を確認
5. 結果を複数手法でクロスチェック

📜 歴史的背景と学習の位置づけ

正規表現 は データ前処理 の領域で発展してきた概念です。 ここでは大まかな歴史的背景と、 なぜこの概念が必要になったのかを整理します。 用語が「降ってきた」のではなく、 現実の問題を解くために順番に編み出されたものだと知ると、 学習の納得感が違います。

なぜこの概念が生まれたか

データ分析や AI を実務で使うと、 「単純な数式」「直感だけのモデル」では太刀打ちできない場面が必ず出てきます。 正規表現 は、 そうした実務的な課題を整理し、 共通言語として定式化したものです。 そのため、 教科書だけで完結する話ではなく、 使う場面と使わない場面を見極めることが何より重要になります。

学習の位置づけ

• 初学者：まず「30秒で分かる結論」「直感で掴む」だけ読めば、 論文に出てきたときに「あ、 あれね」と分かります。
• 中級者：数式と Python 実装をセットで覚え、 自分の手元データに適用できる状態を目指します。
• 上級者：落とし穴と派生手法を理解し、 場面に応じた使い分け・改良ができることが目標です。

🔍 近接概念との比較

同じ データ前処理 カテゴリにある近接概念と、 正規表現 はどう違うのか？ 混同しがちなポイントを整理します。

📌 使い分けの原則： まずは本ページの定義を押さえ、 次に「🌐 関連手法・派生」「🔗 関連用語」のリンクから近接概念を確認し、 自分の問題に対してどれを使うか意識的に選ぶことを習慣にしてください。

❓ よくある質問 (FAQ)

本サイトの教材を読み進めるなかで、 受講者からよく質問される項目をまとめました。

✅ 実務チェックリスト

分析作業のなかで 正規表現 を使うときは、 以下のチェックリストを上から順に確認してください。 抜けがあると後工程で痛い目に遭います。

① 分析設計フェーズ

• □ 目的を 1 文で書けるか？ (「何を、 どうしたいか」)
• □ 正規表現 がその目的に 本当に合っているか？
• □ 必要なデータの種類・量・期間を見積もったか？
• □ 結果をどう報告・意思決定に使うか、 事前に決めたか？

② データ準備フェーズ

• □ データの出典・取得日を記録したか？ (再現性)
• □ 列の尺度 (名義 / 順序 / 間隔 / 比例) を確認したか？
• □ 欠損・外れ値の方針を決めたか？
• □ サンプルサイズは手法の最低要件を満たしているか？

③ 分析実行フェーズ

• □ 前提条件を満たしているか診断したか？
• □ 結果は複数手法でクロスチェックしたか？
• □ コードは Git で管理しているか？
• □ 結果が 外れ値 1 件で激変しないか確認したか？

④ 解釈・報告フェーズ

• □ 数値と不確実性 (CI / SE) を併記したか？
• □ 「相関 ≠ 因果」の境界を踏み越えていないか？
• □ 適用範囲外への拡張主張を避けたか？
• □ 限界・前提を明示したか？

📝 レポート・論文での書き方

論文・社内レポート・ステークホルダー報告書で 正規表現 を扱うとき、 含めるべき項目とテンプレートをまとめました。

必須記載項目

🎓 深掘り：シナリオで身につける

ここまで定義・計算・落とし穴を見てきました。 ここでは 正規表現 をより深く理解するための思考フレームと実務シナリオを、 ストーリー形式で整理します。 用語そのものより、 「どんなときに思い出して、 どう使うか」を体に染み込ませることが、 教材を読む真の目的です。

シナリオ A：研究室での卒論データ分析

「卒業研究で 47 都道府県のデータを分析したい」。 そんなとき 正規表現 はどう登場するでしょうか。 担当の先生から「データを見たうえで、 関連する手法を 1 つ選んで適用してきて」と言われたとします。 まずデータの性質 (量・尺度・期間) を確認し、 「正規表現 がこの問題に合っているか」を本ページの 30 秒結論で照らし合わせます。 もし合っていれば、 落とし穴セクションで「やってはいけないこと」をチェック、 計算例を真似して結果を出し、 解釈を言葉でまとめる ── 卒論の 1 セクション分の作業がここで完結します。

シナリオ B：データサイエンスのインターン

企業のインターンで「過去 3 年の顧客データから来期の予測モデルを作って」と任された。 上司は 正規表現 を当然知っている前提で話します。 言葉が通じないと議論についていけません。 そこで本ページの「定義・数式」「Python 実装」を 30 分で 押さえ、 上司の使う用語に追随する ── ジャストインタイム学習の典型シーンです。 後日、 自分でも実装した結果を上司に説明するとき、 「レポート・論文での書き方」テンプレートに沿って書けば、 過不足なく伝えられます。

シナリオ C：論文を読んでつまずいたとき

本サイトのトップから論文一覧をたどり、 ある論文を読んでいたら 正規表現 が出てきた。 「これ、 なんだっけ？」と思った瞬間、 本ページに飛んでくる ── これが ジャストインタイム型教材の使い方です。 30 秒結論を読み、 「あ、 そういう意味か」と納得したら、 元の論文に戻ります。 必要に応じて落とし穴セクションだけ読んで、 著者の解釈が妥当か批判的に確認することも可能です。

よくある誤解 3 連続

意思決定フレーム：使う？使わない？

🎯 このページのまとめ

🧭 サイト内ナビゲーション

本ページは、 統計・データ解析コンペティションの再現論文集に付随する用語解説の 1 ページです。 正規表現 以外の用語も、 同じフォーマットで以下からたどれます。

• 📚 用語集トップ — 514 用語の一覧
• 🗺 概念マップ — 用語間の関係を視覚化
• 📖 論文一覧へ戻る — 約 160 本の再現論文ハンズオン

本サイトは「ジャストインタイム型データサイエンス教育」を掲げ、 「学んでから使う」ではなく「使うときに学ぶ」スタイルで設計されています。 ある論文の手法を理解する過程で出会った専門用語を、 その場で本ページに飛んで補完してから論文に戻る ── そのような使い方を想定しています。

📚 正規表現の歴史と各エンジンの違い

正規表現は 1956 年、 数学者スティーブン・コール・クリーネ（Stephen Cole Kleene）が論文「Representation of Events in Nerve Nets and Finite Automata」 で 正規言語 という形式言語のクラスを定義したのが始まりです。 これを実用化したのが、 1968 年にケン・トンプソン（Ken Thompson）が UNIX の ed エディタに組み込んだ最初の grep。 以後、 各言語・各ツールが 少しずつ違う方言 を発展させてきました。 同じ \d でも、 Python では「0-9」のみ、 JavaScript ES2018 以降では「あらゆる数字（全角含む）」のように挙動が異なります。

主要エンジンの比較

なぜ RE2 はバックトラックを捨てたか

Google が開発した RE2 はパフォーマンス保証のため、 後方参照と look-around を捨てる 代わりに、 入力長 N に対して O(N) で線形に動作します。 ユーザー入力をサーバ側で正規表現に通すような場面（バリデーション、 WAF、 ログ検索）では、 ReDoS リスクを完全に排除できる RE2 が事実上のデファクトです。 Python では pyre2, Go では標準ライブラリ regexp が RE2 互換。

SSDSE-B-2026 でエンジン差が出る場面

公的統計の前処理では、 多くの場合 Python の標準 re モジュールで十分です。 ただし以下のケースでは regex モジュールへの切替を検討すべきです：

• あいまい検索： 誤字を含む都道府県名検索（(?:北海道){e<=1} で 1 文字違いまで許容）
• Unicode プロパティ： \p{Han} で漢字のみ、 \p{Hiragana} でひらがなのみ。 標準 re ではできない
• 長文 + ReDoS 回避： timeout=1.0 引数で安全に中断できる
• 条件付き分岐： (?(name)yes|no) で名前付きグループが取れたら yes パターンへ

SSDSE 用エンジン選定フローチャート

📥 入力データ：エンジン差を確かめる文字列

このコードでやること： 同じ正規表現でも Python 標準 re と regex モジュールでマッチ結果が変わる例を再現する。 SSDSE 由来テキスト「東京都」「北海道」「Tōkyō」「東 京 都」を入力に、 漢字判定の挙動を比較します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import re
import regex  # pip install regex

samples = ['東京都', '北海道', 'Tōkyō', '東 京 都', '東京都(推計)']

# 標準 re: 漢字パターンは Unicode 範囲を手書き
hira_re = re.compile(r'[一-龯]+')
# regex モジュール: \p{Han} で漢字のみ
hira_rg = regex.compile(r'\p{Han}+')

for s in samples:
    a = hira_re.findall(s)
    b = hira_rg.findall(s)
    print(f'{s:<14} re={a}  regex={b}')

📤 実行例：

💬 標準 re でも [一-龯] という Unicode 範囲を指定すれば漢字判定は可能。 ただし \p{Han} の方が 意図が読みやすい ので、 大規模プロジェクトでは regex モジュールを採用するチームが増えています。 「Tōkyō」 は漢字を含まないので両方とも空、 これは 仕様通り です。

🎓 学び方・伝え方 — 正規表現を教育コンテンツに組み込むコツ

正規表現は 習得曲線が急 な分野です。 最初の 30 分で「マッチ・キャプチャ・量詞」 を理解すれば 70% は使えますが、 look-around・backref・所有量詞・Unicode プロパティ といった高度な機能は段階的にしか身に付きません。 ジャストインタイム型データサイエンス教育では、 「いま目の前のデータで何を解決したいか」 に応じて 必要最小限の正規表現を都度学ぶ アプローチが有効です。

学習段階と扱う題材の対応表

教える側のチェックリスト（教員・メンター向け）

1. 受講者が最初に触るデータは 実データ にしているか？ SSDSE-B-2026 は公的データのため データ品質 も同時に学べる
2. 「正規表現 = 暗号」 という先入観を持たれていないか？ (?P<name>...) 名前付きキャプチャと re.VERBOSE を最初から見せる
3. 失敗例を 意図的に見せている か？ 「.*」 で HTML 全部食う体験は教育効果が高い
4. 正規表現の 歴史的経緯（1956 年クリーネ） を 5 分で触れているか？ 学術背景を知ると応用力が伸びる
5. テスト駆動で書く演習を含めているか？ 「失敗ケースを先に書く」 習慣は他の分野でも生きる
6. ReDoS など セキュリティ 観点を欠かしていないか？

学習者の「あるある」つまずきパターン

過去の受講者を観察すると、 つまずきパターンには共通項があります。 ここに 6 つ並べておきます：

• 「.* で全部マッチするはずなのに違う」： 改行を含まない事実を知らない。 re.DOTALL を教えると一気に解決
• 「特殊文字をエスケープし忘れる」： . がドットそのものを表すと思い込んでいる。 ピリオドを表すには \.
• 「キャプチャ番号が一致しない」： 入れ子の括弧で番号がずれる。 名前付きキャプチャで回避
• 「マッチはするがキャプチャが空」： findall はグループがあるとそれだけ返す仕様を理解していない
• 「文字列か bytes か混乱」： Python 3 では str と bytes でパターン側も合わせる必要がある
• 「正規表現で CSV パースしようとする」： これは諦めさせる。 pandas.read_csv を使う

📥 演習問題：SSDSE-B-2026 から年齢階級別人口を抽出

このコードでやること： SSDSE-B-2026 の列名から「年齢階級別人口（0-14歳）」のような複合名称を 正規表現 でパースし、 年齢区分とそれ以外を分離する。 人口ピラミッド 作成のための前段階。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import re

cols = [
    '年齢階級別人口（0-14歳）_2020',
    '年齢階級別人口（15-64歳）_2020',
    '年齢階級別人口（65歳以上）_2020',
]
pattern = re.compile(
    r'(?P<base>.+?)（(?P<range>[\d-]+|\d+歳以上)歳?）_(?P<year>\d{4})'
)
for c in cols:
    m = pattern.match(c)
    if m:
        print(f"base={m.group('base')} range={m.group('range')} year={m.group('year')}")

📤 実行例：

💬 「0-14」「15-64」「65歳以上」 という 3 種類の表記を 同じパターンで取り出す ことができました。 名前付きキャプチャを使うと、 後段の処理コードが m.group('range') のように 意図がそのまま読める 状態になります。 これが正規表現の真価です。

🔄 pandas との連携 — Series/DataFrame 上での正規表現活用

SSDSE-B-2026 のような表形式データを扱うとき、 正規表現は pandas の str アクセサ経由で 列まるごと に適用できます。 ループを書かずに済むので、 47 行 × 100 列のような中規模データならミリ秒オーダーで完了。 ここでは、 pandas の str.contains, str.extract, str.replace, str.findall をそれぞれ正規表現とともに使い分けるパターンを示します。

pandas での正規表現主要メソッド

📥 入力データ：SSDSE-B-2026 の 5 行抜粋

このコードでやること： SSDSE-B-2026 の最初の 5 行（北海道・東京都・大阪府・愛知県・沖縄県） に対し、 pandas の str.extract で都道府県コードから「先頭 2 桁」をブロックコードとして取り出す。 groupby 用のキーになる。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import pandas as pd

df = pd.DataFrame({
    'code': ['R01100', 'R13100', 'R27100', 'R23100', 'R47000'],
    'pref': ['北海道', '東京都', '大阪府', '愛知県', '沖縄県'],
    'total_pop_2020': ['5,224,614', '13,960,236', '8,837,685', '7,542,415', '1,467,480'],
})

# コードの先頭 2 桁をブロック番号として抽出
df['block'] = df['code'].str.extract(r'^R(\d{2})')
# 都道府県名から末尾の都/道/府/県 を分離
df[['name', 'suffix']] = df['pref'].str.extract(r'(?P<name>.+?)(?P<suffix>都|道|府|県)$')
# 桁区切りカンマを除去して整数化
df['pop_int'] = df['total_pop_2020'].str.replace(r',', '', regex=True).astype(int)
print(df[['code', 'block', 'name', 'suffix', 'pop_int']])

📤 実行例：

💬 1 つの正規表現呼び出しで 5 行すべて が一気に処理されました。 ループは一切書いていません。 これが pandas + 正規表現の威力です。 都道府県コードの上 2 桁を block としてキー化することで、 「関東 8 都県」 のような地理ブロック別集計が 1 行で書けるようになります。

よくあるエラーと対処

• FutureWarning: 正規表現と判定された： pandas 2.x 以降、 str.replace は既定で regex=True。 単純な文字列置換なら regex=False を明示する
• NaN が混じってエラー： str.contains(na=False) で NaN を False 扱いに
• extract で 1 列だけ欲しいのに DataFrame が返る： expand=False で Series 化
• 大文字小文字を無視したい： case=False または flags=re.IGNORECASE
• パターンが遅い： re.compile を別途行い、 regex=compiled として渡す（pandas 1.4+）

📝 補足 FAQ — 正規表現の現場質問 12 件

勉強会や Slack で繰り返し受けてきた質問を、 SSDSE-B-2026 を扱う現場目線で整理しました。 「これくらい当然知っているはず」 という常識的な質問でも、 つまずきポイントは数年ごとに同じ場所に現れる ものです。 自分が新人だった頃を思い出しながら確認してみてください。

Q11. 正規表現はどこで練習すべき？

regex101.com が事実上のデファクト。 Python/PCRE/JavaScript の flavor 切替、 リアルタイム解析、 explain pane が秀逸。 SSDSE 列名のテストにも使えます。

Q12. パフォーマンス測定はどうする？

timeit モジュールで秒数を測る。 47 行 × 数十列の SSDSE では ミリ秒 オーダー。 数百万行の大規模ログでは re.compile 必須。

Q13. メモリ使用量が増えるパターンは？

findall で全マッチをリストにすると、 数百万件で数 GB に達することも。 finditer でジェネレータにするとメモリ節約。

Q14. 正規表現は AI に置き換えられるか？

短期的にはむしろ 共生。 LLM はパターン理解が得意だが 確定性・速度・コスト で正規表現が圧勝。 SSDSE 前処理のような構造化データでは正規表現が一本主軸。

Q15. Excel/Google Sheets でも使える？

Excel 365 の TEXTSPLIT, Google Sheets の REGEXMATCH/REGEXEXTRACT/REGEXREPLACE で使えます。 SSDSE 都道府県名の整形にも応用可能。

Q16. 学習リソースのおすすめ？

英語なら Friedl 著「Mastering Regular Expressions」 が定本、 日本語なら「正規表現技術入門」 が入門〜中級として広く読まれています。 オンラインなら regexr.com の可視化が学習効果高い。

Q17. CI に組み込むには？

SSDSE 専用モジュール ssdse_regex.py に pytest でテストを書き、 GitHub Actions で実行。 失敗ケースを各パターンに 5 件以上は持たせる。

Q18. ユニコードの濁点・半濁点合成は？

「が」 が「か」 + 濁点（U+3099） として渡される場合がある。 unicodedata.normalize('NFC', s) で合成形に揃えてから正規表現を当てる。

Q19. ログから IP アドレスを抽出するパターンは？

単純なら (?:\d{1,3}\.){3}\d{1,3}。 IPv4 厳密版は (?:25[0-5]|2[0-4]\d|[01]?\d\d?) を 4 回繰り返す必要があり、 長いが正確です。

Q20. JSON の中身を正規表現で？

CSV と同じく 原則 NG。 json.loads でパースしてから値の文字列に対して正規表現を当てる。 ネストが浅ければ jmespath の方が読みやすい。

Q21. テスト網羅率の指標は？

「パターン × ケース」 のマトリクスで網羅率を出す。 SSDSE 用ライブラリでは 5 パターン × 各 5 ケース = 25 件以上 を目標に。 失敗ケースを忘れがちなので明示的にチェックリスト化。

Q22. 正規表現で「以上・以下・未満」 をどう書く？

数値比較は 正規表現で書くべきではない 領域。 文字列を数値化してから比較する。 SSDSE の年齢階級「65歳以上」 は記号として扱い、 別途しきい値を持たせるのが安全。

✅ 最終チェックリスト — SSDSE-B-2026 前処理のリリース前確認

SSDSE-B-2026 の前処理スクリプトを「本番」 として共有する前に、 以下のチェックを必ず行ってください。 ここで挙げる項目は、 過去 3 年間の現場で 少なくとも一度は事故になった ポイントです。 1 つでもチェックを通せないなら、 まだリリース可能ではありません。

A. データ取り込み層

1. 都道府県コード列に ^R\d{5}$ を当てて 47 件 マッチしているか
2. 行数が 47 行（北海道～沖縄）でユニークか
3. 欠損記号「－」「―」「…」「NA」「X」「c」 がすべて NaN 化されているか
4. 列名に 全角空白 が残っていないか（any('　' in c for c in df.columns) が False か）
5. 桁区切りカンマを除去した結果、 すべての数値カラムが int または float になっているか

B. 結合・変換層

1. 結合キーが 正規化済み都道府県コード になっているか（全角・空白なし）
2. 年度サフィックスが (?P<year>\d{4}) で整数として取り出せているか
3. 「東京都」「東京」「Tokyo」 が同一エンティティに統合されているか
4. 年齢階級カラムが (?P<range>[\d-]+|\d+歳以上) でパース成功しているか

C. テスト・CI 層

1. すべての正規表現に 失敗ケースを 3 件以上 含む単体テストが書かれているか
2. CI（GitHub Actions など） でテストが自動実行されているか
3. ReDoS 危険パターン (a+)+, (.*)* を 静的解析 で検出する仕組みがあるか
4. 外部入力に対しては timeout 付きの regex モジュールを使っているか

D. ドキュメント層

1. 各正規表現に 1 行コメント で意図が記載されているか（re.VERBOSE でも可）
2. SSDSE-B-2026 固有のフィールド（都道府県コード形式、 単位、 注釈記号） が データ辞書 として残っているか
3. パターン一覧表が README に貼られているか

この 17 項目をすべてクリアしたら、 SSDSE-B-2026 の前処理は 本番品質 と言えます。 数年後に自分が読み返しても、 別の人がメンテナンスを引き継いでも、 同じ結果を再現できる状態です。 これがデータエンジニアリングの基本です。

📖 関連用語と参考リソース — さらに深く学ぶための地図

正規表現を起点に、 データサイエンスの周辺領域を辿ると以下のような知識マップが描けます。 SSDSE-B-2026 を扱う際は、 データクレンジング、 データ品質、 文字コード、 pandas、 可視化 までを一気通貫で押さえておくと、 1 つのデータセットから 30 種類以上の分析が引き出せます。 「正規表現は単機能」 ではなく、 分析全体を支える縁の下の力持ち として位置づけてください。

本ページで紹介したパターン集・チェックリスト・物語・FAQ は、 すべて SSDSE-B-2026 と実際の現場経験 から抽出したものです。 教科書のサンプルではなく 「いま動くデータ」 を相手にしたものなので、 自分のプロジェクトでもそのまま使えます。 ぜひこのページをブックマークして、 SSDSE データを扱うたびに開き直してください。 そのたびに 新しい気づき が得られるはずです。

関連用語の学習順序（推奨）

正規表現を入口にデータエンジニアリングを学ぶ場合、 次の順序がスムーズです： (1) 正規表現基本 → (2) 文字コード → (3) pandas の str アクセサ → (4) データクレンジング → (5) データ品質 → (6) 可視化。 SSDSE-B-2026 を題材にこの 6 段階を進めると、 1 つの公的統計データから 30 を超える分析・グラフが導けることに気づくはずです。 そのプロセス自体が データサイエンス の縮図です。

最後に — 正規表現を学ぶ意義

正規表現を学ぶ意義は、 単に「文字列処理ができるようになる」 ことではありません。 形式言語論を体感的に学ぶ こと、 テスト駆動の習慣を身につける こと、 失敗パターンを意識する こと、 そして 抽象化のセンスを磨く こと── これらはどんなプログラミング分野でも武器になります。 SSDSE-B-2026 の前処理という具体的なゴールを通じて、 これらのメタ的なスキルを同時に手に入れてください。 そうすれば、 正規表現はあなたの 思考の OS の一部となります。

本ページの各セクションは、 SSDSE-B-2026 の都道府県データを 正規表現で安全に整形する ことを共通テーマに、 異なる視点（パターン辞書・物語・歴史的経緯・pandas 連携・教育法・チェックリスト・FAQ） から構成しました。 必要なセクションだけを ブックマーク して、 データクレンジング の 実践書 として使ってもらえると、 ページ作成の意図に沿った活用となります。 ジャストインタイム型データサイエンス教育の真髄は「学んだ瞬間に使う」 こと。 このページをきっかけに、 ぜひ SSDSE データを手元で動かしてみてください。 相関ページ、 pandas ページ、 可視化ページ も合わせて読むと、 1 つのデータから世界が広がる感覚を体験できるはずです。 正規表現と一緒に学ぶことで、 データを 「触れる存在」 として実感できるようになります。 そこから先は、 自分の知的好奇心に従って、 興味のある分野へどんどん進んでください。 学んだ知識を実データへ即座に適用する習慣こそが、 現代のデータサイエンティストに最も求められる能力です。 ジャストインタイム型学習を続ければ、 必ず自分の武器となる正規表現スキルが手に入ります。 道はあなたの目の前に開けています。 さあ、 SSDSE-B-2026 を開いて、 都道府県データをいま正規表現で整形してみましょう。 きっと面白い発見が待っています。 楽しんでください、 そしてデータと正規表現の旅を続けましょう。

🏁 総まとめ — 正規表現を「使いこなす」 ための 12 か条

1. raw string を必ず使う： r'\d+' と '\\d+' は等価だが、 raw string が圧倒的に読みやすい。 SSDSE 前処理で 30 種類以上の正規表現を扱う場面では、 raw string を徹底するだけで保守コストが半減します。
2. 名前付きグループを使う： (?P<year>\d{4}) のように名前を付けると m.group('year') で取れる。 列名が増えたときの可読性が桁違いに上がります。
3. アンカーを明示する： 完全一致なら ^...$、 部分マッチなら不要。 都道府県コード検証や郵便番号検証では必ず付けること。
4. 貪欲・非貪欲を意識する： 「できるだけ短く」 取りたいなら *?, +?, ??。 注釈付き値の括弧分離では非貪欲必須。
5. 非キャプチャグループで高速化： 取り出し不要なら (?:...)。 5 段ネストの SSDSE 列名パースで効果絶大。
6. re.VERBOSE でコメントを書く： 複雑な正規表現は re.X フラグ + 改行 + # コメントで読みやすく。 後から見ても何をしているか分かります。
7. テストファーストで書く： まず失敗ケース 5 つ、 成功ケース 5 つを書いてからパターンを書く。 後戻りが減る。
8. ReDoS を避ける： (a+)+, (.*)*, (a|a)+ は危険。 ReDoS 解説を必ず読むこと。
9. エンジン差を把握する： Python・JavaScript・PCRE・RE2 で微妙に違う。 移植時は regex101 で flavor 切替確認を。
10. Unicode を考慮する： 日本語混じりでは \w, \d の挙動を確認。 必要なら regex モジュールの \p{...}。
11. 正規表現で全部やろうとしない： CSV, HTML, JSON は専用パーサ。 正規表現は セル内文字列処理 に限定するのが安全。
12. 関数化・ライブラリ化： 同じパターンを 2 回以上使うなら関数化。 SSDSE 専用モジュール ssdse_regex.py のように集約しておくと、 数年スパンで使い回せます。

最後にもう一度強調します： 正規表現は単なる文字列マッチではなく、 形式言語論に裏付けられた強力なツール です。 SSDSE-B-2026 のような公的統計のデータ前処理から、 ログ解析、 入力バリデーション、 LLM 出力のパースまで、 用途は無限。 ただし 万能ではなく、 データクレンジング の理解、 文字コード の知識、 テスト による検証と組み合わせて初めて真価を発揮します。 本ページで紹介した 15 種類のレシピ・10 件の Q&A・8 種類の落とし穴・12 か条のまとめ を傍らに置いて、 ぜひ手元で SSDSE データを動かしてみてください。

🗺 概念マップ

正規表現を中心に、 上下流の文字列処理・形式言語論・データクレンジング・pandas との接続関係を 6 つのノードに整理した。 SSDSE-B-2026 の市区町村コード抽出など、 実務でどの位置に当たるかを俯瞰できる。

正規表現を中心に、 上方向は「前提となる文字列・文字コードの知識」、 右上は「並列に使われる glob や fnmatch などの簡易パターン」、 右下は「発展領域である形式言語論・DFA/NFA・チョムスキー階層」、 下は「応用先のデータクレンジング・ログ解析・入力バリデーション」、 左下は「対比として CSV/JSON 用の専用パーサ」、 左上は「pandas .str.contains/extract との統合」を示している。 SSDSE-B-2026 で郵便番号や年度表記を統一する作業は、 主に「応用」と「統合」の交点に位置する。

このマップから読み取れる重要な含意は、 正規表現は形式言語論という理論的基盤の上に乗り、 その下流で pandas や ETL パイプラインに組み込まれる という構造である。 すなわち単独で動く道具ではなく、 上下流の手法と組み合わせて初めて SSDSE のような実データを安全に扱える。 とくに ReDoS や Unicode 周辺は「発展」ノードから降りてくる注意点として位置づけられる。

🔗 隣接手法への橋渡し

「正規表現」は単独で完結する手法ではなく、 隣接領域と連携することで真価を発揮する。

• 上流: 生のテキストデータ — CSV や 自然言語処理 前段の文字列をパターンマッチで抽出・整形する
• 並列: N-gram や テキスト類似度 による文字列処理。 構文が固定された箇所では正規表現、 統計的特徴を扱う場合は他手法
• 下流: 抽出されたトークンを 自然言語処理 や テキスト生成 に渡し、 構造化された分析や予測に活用する

パターンが固定的な情報（電話番号・郵便番号・ログ書式）を 確実に 取り出す前処理段で「正規表現」が機能し、 後段の統計・機械学習の品質を底上げする。

🌳 手法選択フロー

「正規表現」を実際の課題に当てはめるとき、 対象テキストの構造と精度要件で判定する。

1. パターンが固定か可変か? 郵便番号「123-4567」のように形式が固定 → 正規表現で r'\d{3}-\d{4}'。 「東京都〜区」のように揺らぎ大 → 形態素解析 や N-gram へ
2. 抽出か検証か置換か? 文字列の中の電話番号を取り出す → re.findall、 入力フォームの妥当性確認 → re.fullmatch、 全角を半角に統一 → re.sub
3. ReDoS リスクを許容できるか? ユーザー入力に適用するなら (a+)+ のような nested quantifier を避け、 re2 や データクレンジング 専用ライブラリで線形時間保証を取る

SSDSE-B-2026 で「市区町村コード R01100」「年度 2026」のような固定書式は正規表現が最短。 自由記述コラムを扱う場合は pandas の .str.extract でグループ抽出するか、 NLP 手法に切り替える。