import re
 
# リテラル文字のみのパターン
pattern = r'hello'
text = "say hello to the world"
 
match = re.search(pattern, text)
print(match.group())  # => "hello"
print(match.start())  # => 4
print(match.end())    # => 9

import re
 
# リテラルマッチは左から右へ最初に見つかった位置で成功する
text = "abcabcabc"
pattern = r'abc'
 
# search は最初のマッチを返す
m = re.search(pattern, text)
print(f"最初のマッチ: 位置{m.start()}-{m.end()}")  # => 位置0-3
 
# findall は全てのマッチを返す
all_matches = re.findall(pattern, text)
print(f"全マッチ: {all_matches}")  # => ['abc', 'abc', 'abc']
 
# finditer はイテレータで位置情報付き
for m in re.finditer(pattern, text):
    print(f"  位置{m.start()}-{m.end()}: '{m.group()}'")
# => 位置0-3: 'abc'
# => 位置3-6: 'abc'
# => 位置6-9: 'abc'

import re
 
text = "Python is Great. PYTHON IS GREAT. python is great."
 
# デフォルト: 大文字小文字を区別
print(re.findall(r'python', text))
# => ['python']
 
# IGNORECASE フラグ: 区別しない
print(re.findall(r'python', text, re.IGNORECASE))
# => ['Python', 'PYTHON', 'python']
 
# インラインフラグ: パターン内にフラグを埋め込む
print(re.findall(r'(?i)python', text))
# => ['Python', 'PYTHON', 'python']
 
# 部分的にフラグを適用（Python 3.6+）
# (?i:pattern) でその部分だけ大文字小文字無視
print(re.findall(r'(?i:python) is (?i:great)', text))
# => ['Python is Great', 'PYTHON IS GREAT', 'python is great']

import re
 
# 日本語のリテラルマッチ
text = "東京は日本の首都です。Tokyo is the capital of Japan."
 
# 日本語文字列もそのままマッチ可能
print(re.findall(r'東京', text))   # => ['東京']
print(re.findall(r'Tokyo', text))  # => ['Tokyo']
print(re.findall(r'首都', text))   # => ['首都']
 
# 混在テキストでのマッチ
log = "2026-02-15 エラー: ファイルが見つかりません (error: file not found)"
m = re.search(r'エラー', log)
print(m.group())  # => 'エラー'
 
# 絵文字もリテラルマッチ可能（Python 3）
emoji_text = "Hello! Nice to meet you!"
print(re.findall(r'Nice', emoji_text))  # => ['Nice']

# Python: raw string を推奨
import re
pattern = r'hello\.\*world'
re.search(pattern, text)
 
# Python: re.compile でプリコンパイル
compiled = re.compile(r'hello\.\*world')
compiled.search(text)

// JavaScript: リテラル記法
const pattern1 = /hello\.\*world/;
pattern1.test(text);
 
// JavaScript: コンストラクタ記法（動的パターン用）
const pattern2 = new RegExp('hello\\.\\*world');
pattern2.test(text);
// ※ コンストラクタでは文字列のエスケープも必要なため二重エスケープ

// Java: 常に文字列リテラル（raw string なし）
import java.util.regex.*;
Pattern pattern = Pattern.compile("hello\\.\\*world");
Matcher matcher = pattern.matcher(text);
 
// Java 13+: テキストブロックで若干読みやすくなる
// ただしバックスラッシュのエスケープは依然必要

# Ruby: Regexp リテラル
pattern = /hello\.\*world/
text =~ pattern
 
# Ruby: Regexp.new（動的パターン用）
pattern = Regexp.new('hello\.\*world')
 
# Ruby: %r{} 記法（スラッシュが多いパターンに便利）
pattern = %r{http://example\.com/path}

# Perl: パターンマッチ演算子
if ($text =~ /hello\.\*world/) {
    print "マッチ\n";
}
 
# Perl: qr// でプリコンパイル
my $pattern = qr/hello\.\*world/;
if ($text =~ $pattern) { ... }

import re
 
pattern = r'c.t'
texts = ["cat", "cot", "cut", "ct", "coat", "c\nt"]
 
for t in texts:
    m = re.search(pattern, t)
    result = m.group() if m else "不一致"
    print(f"  '{t}' → {result}")
 
# 出力:
#   'cat' → cat
#   'cot' → cot
#   'cut' → cut
#   'ct'  → 不一致     (ドットは1文字必須)
#   'coat' → coa は不一致、c.t にはマッチしない
#   'c\nt' → 不一致    (ドットは改行にマッチしない ※DOTALL除く)
 
# DOTALL フラグで改行にもマッチ
m = re.search(r'c.t', "c\nt", re.DOTALL)
print(m.group())  # => "c\nt"

# ドットの実用パターン
 
import re
 
# 1. 任意の1文字を含むパターン
print(re.findall(r'b.g', "bag big bog bug"))
# => ['bag', 'big', 'bog', 'bug']
 
# 2. 固定長パターンのマッチ
print(re.findall(r'...-....', "Tel: 03-1234-5678"))
# => ['03-1234']  ※意図と異なる可能性
 
# 3. ドットの正しい使い方: 特定の1文字が不明な場合
# ファイル名パターン: 拡張子の前の任意の1文字
print(re.findall(r'file.\.txt', "file1.txt file2.txt fileA.txt"))
# => ['file1.txt', 'file2.txt', 'fileA.txt']

import re
 
# パイプによる選択
pattern = r'cat|dog|bird'
texts = ["I have a cat", "I have a dog", "I have a fish"]
 
for t in texts:
    m = re.search(pattern, t)
    print(f"  '{t}' → {m.group() if m else '不一致'}")
 
# 出力:
#   'I have a cat' → cat
#   'I have a dog' → dog
#   'I have a fish' → 不一致
 
# 注意: パイプの優先順位
# gr(a|e)y  → "gray" or "grey"     (グループ内で選択)
# gray|grey → "gray" or "grey"     (同等)
# gra|ey    → "gra" or "ey"        (意図と異なる可能性)

# パイプの優先順位を理解する
 
import re
 
# パイプは正規表現で最も優先度が低い演算子
# 連結(隣接文字)の方が優先される
 
# 例1: abc|def は (abc)|(def) と同じ
print(re.findall(r'abc|def', "abc def abdef"))
# => ['abc', 'def']
 
# 例2: グループで範囲を制限
print(re.findall(r'gr(a|e)y', "gray grey graey"))
# => ['a', 'e']  ※ キャプチャグループの内容が返る
 
# 非キャプチャグループを使えばマッチ全体が返る
print(re.findall(r'gr(?:a|e)y', "gray grey graey"))
# => ['gray', 'grey']
 
# 例3: 複数の選択肢を持つパターン
log_pattern = r'ERROR|WARN|INFO|DEBUG'
log = "2026-02-15 [ERROR] Connection failed"
m = re.search(log_pattern, log)
print(m.group())  # => 'ERROR'
 
# 例4: NFA エンジンでは左から順に試行される
# 最初にマッチした選択肢で確定
print(re.search(r'Java|JavaScript', "JavaScript").group())
# => 'Java' (先に試行されてマッチ)
 
# 長い選択肢を先に書くことで対処
print(re.search(r'JavaScript|Java', "JavaScript").group())
# => 'JavaScript'

import re
 
# * : 0回以上
print(re.findall(r'ab*c', "ac abc abbc"))     # => ['ac', 'abc', 'abbc']
 
# + : 1回以上
print(re.findall(r'ab+c', "ac abc abbc"))     # => ['abc', 'abbc']
 
# ? : 0回または1回
print(re.findall(r'colou?r', "color colour"))  # => ['color', 'colour']

# 量指定子の詳細な動作
 
import re
 
# * (0回以上) -- 空マッチに注意
print(re.findall(r'a*', "aaa"))
# => ['aaa', '']  ※ 末尾で空マッチが発生
 
print(re.findall(r'a*', "bbb"))
# => ['', '', '', '']  ※ 各位置で0回マッチ
 
# + (1回以上) -- 空マッチは発生しない
print(re.findall(r'a+', "aaa"))
# => ['aaa']
 
print(re.findall(r'a+', "bbb"))
# => []
 
# ? (0回または1回) -- オプショナルな要素
print(re.findall(r'https?', "http and https"))
# => ['http', 'https']
 
# 量指定子の貪欲(greedy)マッチ
# デフォルトでは可能な限り多くの文字を消費する
print(re.search(r'a+', "aaaaaa").group())
# => 'aaaaaa' (全ての 'a' を消費)
 
# 非貪欲(lazy)マッチ -- ? を付ける
print(re.search(r'a+?', "aaaaaa").group())
# => 'a' (最小限の1文字のみ)
 
# 非貪欲の実用例: HTML タグ内のテキスト
html = "<b>bold</b> and <i>italic</i>"
print(re.findall(r'<.+>', html))    # 貪欲: ['<b>bold</b> and <i>italic</i>']
print(re.findall(r'<.+?>', html))   # 非貪欲: ['<b>', '</b>', '<i>', '</i>']

import re
 
# 基本的なグループ化
pattern = r'(hello) (world)'
m = re.search(pattern, "say hello world")
print(m.group(0))  # => 'hello world' (マッチ全体)
print(m.group(1))  # => 'hello' (グループ1)
print(m.group(2))  # => 'world' (グループ2)
print(m.groups())  # => ('hello', 'world')
 
# 非キャプチャグループ (?:...)
# グループ化するがキャプチャしない
pattern = r'(?:hello|hi) (world)'
m = re.search(pattern, "say hello world")
print(m.group(1))  # => 'world' (グループ番号がずれない)
 
# 名前付きグループ (?P<name>...)
pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
m = re.search(pattern, "Date: 2026-02-15")
print(m.group('year'))   # => '2026'
print(m.group('month'))  # => '02'
print(m.group('day'))    # => '15'
print(m.groupdict())     # => {'year': '2026', 'month': '02', 'day': '15'}

import re
 
# 基本的な文字クラス
print(re.findall(r'[aeiou]', "hello world"))
# => ['e', 'o', 'o']  ※ 母音だけをマッチ
 
# 範囲指定
print(re.findall(r'[a-z]', "Hello 123"))
# => ['e', 'l', 'l', 'o']
 
print(re.findall(r'[A-Za-z0-9]', "Hello 123!"))
# => ['H', 'e', 'l', 'l', 'o', '1', '2', '3']
 
# 否定文字クラス
print(re.findall(r'[^a-z]', "hello 123!"))
# => [' ', '1', '2', '3', '!']
 
# 文字クラス内でのメタ文字の扱い
# ほとんどのメタ文字はリテラルとして扱われる
print(re.findall(r'[.+*?]', "a.b+c*d?e"))
# => ['.', '+', '*', '?']
 
# ただし以下は特殊:
# ] → 文字クラスの終了（先頭に置くかエスケープ: [\]] or []abc]）
# \ → エスケープ
# ^ → 先頭にある場合のみ否定
# - → 文字間にある場合のみ範囲指定（先頭/末尾ならリテラル）

import re
 
# {n} 正確にn回
print(re.findall(r'\d{3}', "12 123 1234 12345"))
# => ['123', '123', '123']  ※ 1234 から 123 を抽出、12345 から 123 と 45は別
 
# {n,m} n回以上m回以下
print(re.findall(r'\d{2,4}', "1 12 123 1234 12345"))
# => ['12', '123', '1234', '1234']
 
# {n,} n回以上
print(re.findall(r'\d{3,}', "1 12 123 1234 12345"))
# => ['123', '1234', '12345']
 
# {,m} 0回以上m回以下 (= {0,m})
print(re.findall(r'a{,3}', "aaaa"))
# => ['aaa', 'a', '']  ※ 最大3つの 'a' にマッチ
 
# 実用例: 郵便番号
print(re.findall(r'\d{3}-\d{4}', "〒100-0001 東京都千代田区"))
# => ['100-0001']
 
# 実用例: IPv4 アドレス（簡易版）
print(re.findall(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}',
                 "Server: 192.168.1.1, Gateway: 10.0.0.1"))
# => ['192.168.1.1', '10.0.0.1']

import re
 
# ^ 行頭にマッチ
print(re.search(r'^hello', "hello world").group())    # => 'hello'
print(re.search(r'^hello', "say hello"))              # => None
 
# $ 行末にマッチ
print(re.search(r'world$', "hello world").group())    # => 'world'
print(re.search(r'world$', "world hello"))            # => None
 
# ^ と $ を組み合わせて全体マッチ
print(re.match(r'^\d{3}-\d{4}$', "100-0001"))
# => <re.Match object; ...>  マッチ成功
 
print(re.match(r'^\d{3}-\d{4}$', "100-0001 東京"))
# => None  (末尾に余分な文字があるため)
 
# 複数行モードでの ^ と $
text = """line1
line2
line3"""
 
# デフォルト: ^ は文字列全体の先頭のみ
print(re.findall(r'^line\d', text))
# => ['line1']
 
# MULTILINE: ^ が各行の先頭にマッチ
print(re.findall(r'^line\d', text, re.MULTILINE))
# => ['line1', 'line2', 'line3']

import re
 
# メタ文字をリテラルとして扱うにはバックスラッシュでエスケープ
price_pattern = r'\$\d+\.\d{2}'
text = "Price: $19.99 and $5.00"
 
matches = re.findall(price_pattern, text)
print(matches)  # => ['$19.99', '$5.00']
 
# エスケープが必要なメタ文字の例:
#   \.  → リテラルのドット
#   \*  → リテラルのアスタリスク
#   \+  → リテラルのプラス
#   \?  → リテラルのクエスチョンマーク
#   \(  → リテラルの開き括弧
#   \)  → リテラルの閉じ括弧
#   \[  → リテラルの開き角括弧
#   \{  → リテラルの開き波括弧
#   \|  → リテラルのパイプ
#   \\  → リテラルのバックスラッシュ
#   \^  → リテラルのキャレット
#   \$  → リテラルのドル記号

# エスケープが必要な実用パターン
 
import re
 
# 1. ファイルパス（Windows）
path = r'C:\Users\gaku\Documents\file.txt'
pattern = r'C:\\Users\\(\w+)\\Documents\\(\w+\.txt)'
m = re.search(pattern, path)
if m:
    print(f"ユーザー: {m.group(1)}, ファイル: {m.group(2)}")
    # => ユーザー: gaku, ファイル: file.txt
 
# 2. URL パターン
url = "https://example.com/path?key=value&key2=value2"
pattern = r'https?://([^/]+)(/[^?]*)?\?(.+)'
m = re.search(pattern, url)
if m:
    print(f"ホスト: {m.group(1)}")  # => example.com
    print(f"パス: {m.group(2)}")    # => /path
    print(f"クエリ: {m.group(3)}")  # => key=value&key2=value2
 
# 3. 数学的な式
expr = "f(x) = 3x^2 + 2x + 1"
pattern = r'f\(x\) = (\d+)x\^(\d+)'
m = re.search(pattern, expr)
if m:
    print(f"係数: {m.group(1)}, 指数: {m.group(2)}")
    # => 係数: 3, 指数: 2
 
# 4. IPアドレス（ドットのエスケープ重要）
ip_text = "Server 192.168.1.1 Port 8080"
pattern = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
m = re.search(pattern, ip_text)
print(m.group())  # => '192.168.1.1'

import re
 
# 二重エスケープの問題
# Windowsパスをマッチする場合:
 
# NG: 通常文字列 -- バックスラッシュが二重に解釈される
pattern_bad = "C:\\\\Users\\\\\\w+"
# Python文字列としての解釈: C:\\Users\\\w+
# 正規表現としての解釈: C:\Users\ + 単語文字列
 
# OK: raw string を使う
pattern_good = r"C:\\Users\\\w+"
 
text = r"C:\Users\gaku"
print(re.search(pattern_good, text).group())  # => C:\Users\gaku

# 二重エスケープ問題が発生しやすいケース
 
import re
 
# ケース1: バックスラッシュ自体をマッチ
# 目的: テキスト中の \ を見つける
text = "path\\to\\file"
 
# NG: 通常文字列
# "\\" → Python文字列: \ → 正規表現: エスケープ不完全
# OK: raw string
pattern = r'\\'  # raw string: \\ → 正規表現: リテラル \
print(re.findall(pattern, text))  # => ['\\', '\\']
 
# ケース2: \n をリテラル文字列としてマッチ
# 目的: テキスト中の文字列 "\n" (バックスラッシュ+n) を見つける
text = r"改行は\nで表します"
 
# NG: "\n" → Python文字列: 改行文字 → 改行にマッチしてしまう
# OK:
pattern = r'\\n'  # raw string: \\n → 正規表現: リテラル \ + n
print(re.findall(pattern, text))  # => ['\\n']
 
# ケース3: Java / JavaScript では更に注意
# Java: Pattern.compile("\\\\n") → \\ → リテラル \ + n
# JavaScript: /\\n/ → リテラル \ + n
# JavaScript: new RegExp("\\\\n") → 文字列エスケープ + 正規表現エスケープ

import re
 
# ショートハンドの動作確認
 
# \d: 数字
print(re.findall(r'\d+', "abc123def456"))
# => ['123', '456']
 
# \w: 単語文字
print(re.findall(r'\w+', "hello, world! 123"))
# => ['hello', 'world', '123']
 
# \s: 空白文字
text = "hello\tworld\nnext line"
print(re.findall(r'\s', text))
# => ['\t', '\n', ' ']
 
# \b: 単語境界
text = "cat caterpillar concatenate"
print(re.findall(r'\bcat\b', text))
# => ['cat']  ※ 完全一致のみ
 
print(re.findall(r'\bcat', text))
# => ['cat', 'cat', 'cat']  ※ cat で始まる単語
 
# 大文字版は否定
print(re.findall(r'\D+', "abc123def"))  # 非数字
# => ['abc', 'def']
 
print(re.findall(r'\W+', "hello, world!"))  # 非単語文字
# => [', ', '!']
 
print(re.findall(r'\S+', "hello world"))  # 非空白文字
# => ['hello', 'world']

import re
 
# ユーザー入力をリテラルとしてパターンに組み込む場合
user_input = "file (1).txt"
 
# NG: そのまま使うとメタ文字が解釈される
try:
    re.search(user_input, "file (1).txt")  # () がグループとして解釈
except re.error as e:
    print(f"エラー: {e}")
 
# OK: re.escape() でメタ文字をエスケープ
escaped = re.escape(user_input)
print(escaped)  # => 'file\\ \\(1\\)\\.txt'
m = re.search(escaped, "file (1).txt")
print(m.group())  # => 'file (1).txt'
 
# 実用例: ユーザー入力のリテラル検索
def search_literal(text, query):
    """ユーザー入力をリテラルとして検索"""
    pattern = re.escape(query)
    return re.findall(pattern, text)
 
print(search_literal("price is $10.00", "$10.00"))
# => ['$10.00']
 
# 実用例: リテラルで囲まれた部分を抽出
def extract_between(text, start, end):
    """start と end の間の文字列を抽出"""
    pattern = re.escape(start) + r'(.+?)' + re.escape(end)
    return re.findall(pattern, text)
 
print(extract_between("value = [hello]", "[", "]"))
# => ['hello']

# Python
import re
re.escape("hello.world")  # => 'hello\\.world'

// JavaScript (標準にはないが、よく使われるユーティリティ)
function escapeRegExp(string) {
    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}
escapeRegExp("hello.world");  // => "hello\\.world"

// Java
java.util.regex.Pattern.quote("hello.world");
// => "\\Qhello.world\\E" (リテラルブロックで囲む)

# Ruby
Regexp.escape("hello.world")  # => "hello\\.world"

import re
 
text = """Hello World
hello python
HELLO REGEX"""
 
# i フラグ: 大文字小文字を無視
print(re.findall(r'hello', text, re.IGNORECASE))
# => ['Hello', 'hello', 'HELLO']
 
# m フラグ: 複数行モード (^$ が各行に作用)
print(re.findall(r'^hello', text, re.MULTILINE | re.IGNORECASE))
# => ['Hello', 'hello', 'HELLO']
 
# s フラグ: ドットが改行にもマッチ
print(re.search(r'Hello.+REGEX', text, re.DOTALL).group())
# => 'Hello World\nhello python\nHELLO REGEX'
 
# x フラグ: 冗長モード (空白・コメントを無視)
pattern = re.compile(r'''
    \d{4}       # 年 (4桁)
    -            # ハイフン区切り
    \d{2}       # 月 (2桁)
    -            # ハイフン区切り
    \d{2}       # 日 (2桁)
''', re.VERBOSE)
print(pattern.search("Date: 2026-02-11").group())
# => '2026-02-11'

import re
 
# パターン内にフラグを埋め込む
# (?flags) の形式
 
# (?i) 大文字小文字無視
print(re.findall(r'(?i)hello', "Hello HELLO hello"))
# => ['Hello', 'HELLO', 'hello']
 
# (?m) 複数行モード
text = "line1\nline2\nline3"
print(re.findall(r'(?m)^\w+', text))
# => ['line1', 'line2', 'line3']
 
# (?s) ドットオール
print(re.search(r'(?s)line1.+line3', text).group())
# => 'line1\nline2\nline3'
 
# (?x) 冗長モード
pattern = r'''(?x)
    (\d{4})     # 年
    -(\d{2})    # 月
    -(\d{2})    # 日
'''
m = re.search(pattern, "2026-02-15")
print(m.groups())  # => ('2026', '02', '15')
 
# 複数フラグの組み合わせ
print(re.findall(r'(?im)^hello', "Hello\nhello\nHELLO"))
# => ['Hello', 'hello', 'HELLO']
 
# スコープ付きフラグ (Python 3.6+)
# (?i:pattern) でその部分だけフラグ適用
pattern = r'(?i:hello) world'  # hello は大文字小文字無視、world は区別
print(re.findall(pattern, "Hello world HELLO world hello World"))
# => ['Hello world', 'hello world']  ※ 'HELLO world' はマッチ、'hello World' は不一致
# 実際には:
# 'Hello world' → マッチ
# 'HELLO world' → マッチ
# 'hello World' → 不一致（world が大文字のため）

import re
 
# 1. ログファイルの解析（複数行 + 大文字小文字無視）
log = """
2026-02-15 10:30:00 [ERROR] Database connection failed
2026-02-15 10:31:00 [Warning] High memory usage
2026-02-15 10:32:00 [error] Disk space low
"""
 
# ERROR も Warning も error もマッチ
errors = re.findall(
    r'^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} \[(?:error|warning)\] (.+)$',
    log,
    re.MULTILINE | re.IGNORECASE
)
print(errors)
# => ['Database connection failed', 'High memory usage', 'Disk space low']
 
# 2. 複雑なパターンの可読性向上（冗長モード）
email_pattern = re.compile(r'''
    ^                       # 文字列の先頭
    [a-zA-Z0-9._%+-]+      # ローカルパート
    @                       # アットマーク
    [a-zA-Z0-9.-]+          # ドメイン名
    \.                      # ドット
    [a-zA-Z]{2,}            # TLD
    $                       # 文字列の末尾
''', re.VERBOSE)
 
# 3. 複数行テキストの解析（ドットオール + 複数行）
html = """<div class="content">
    <p>First paragraph</p>
    <p>Second paragraph</p>
</div>"""
 
# div の中身全体を抽出
m = re.search(r'<div[^>]*>(.*?)</div>', html, re.DOTALL)
if m:
    print(m.group(1).strip())

import re
 
# 日本の郵便番号
postal_code = re.compile(r'^\d{3}-\d{4}$')
assert postal_code.match('100-0001')
assert not postal_code.match('1000001')
assert not postal_code.match('100-000')
 
# 日本の携帯電話番号
mobile_phone = re.compile(r'^0[789]0-\d{4}-\d{4}$')
assert mobile_phone.match('090-1234-5678')
assert mobile_phone.match('080-1234-5678')
assert not mobile_phone.match('03-1234-5678')
 
# 西暦日付 (YYYY-MM-DD)
date_pattern = re.compile(r'^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$')
assert date_pattern.match('2026-02-15')
assert date_pattern.match('2026-12-31')
assert not date_pattern.match('2026-13-01')
assert not date_pattern.match('2026-00-15')
 
# 時刻 (HH:MM:SS)
time_pattern = re.compile(r'^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d$')
assert time_pattern.match('00:00:00')
assert time_pattern.match('23:59:59')
assert not time_pattern.match('24:00:00')
assert not time_pattern.match('12:60:00')

import re
 
# Markdown のリンクを抽出
text = "詳細は[公式サイト](https://example.com)と[FAQ](https://example.com/faq)を参照"
links = re.findall(r'\[([^\]]+)\]\(([^)]+)\)', text)
for label, url in links:
    print(f"  {label} → {url}")
# => 公式サイト → https://example.com
# => FAQ → https://example.com/faq
 
# ハッシュタグの抽出
tweet = "今日は天気がいい #sunny #tokyo 最高！"
tags = re.findall(r'#(\w+)', tweet)
print(tags)  # => ['sunny', 'tokyo']
 
# 引用符で囲まれた文字列
text = 'She said "hello" and "goodbye"'
quoted = re.findall(r'"([^"]*)"', text)
print(quoted)  # => ['hello', 'goodbye']
 
# キーバリューペアの抽出
config = "host=localhost port=3306 db=mydb user=admin"
pairs = re.findall(r'(\w+)=(\S+)', config)
print(dict(pairs))  # => {'host': 'localhost', 'port': '3306', 'db': 'mydb', 'user': 'admin'}

import re
 
# 1. スネークケース → キャメルケース
def snake_to_camel(name):
    return re.sub(r'_([a-z])', lambda m: m.group(1).upper(), name)
 
print(snake_to_camel('hello_world'))    # => 'helloWorld'
print(snake_to_camel('my_var_name'))    # => 'myVarName'
 
# 2. キャメルケース → スネークケース
def camel_to_snake(name):
    return re.sub(r'(?<!^)(?=[A-Z])', '_', name).lower()
 
print(camel_to_snake('helloWorld'))    # => 'hello_world'
print(camel_to_snake('myVarName'))     # => 'my_var_name'
 
# 3. 連続する空白の正規化
text = "hello   world\t\t\tnext"
print(re.sub(r'\s+', ' ', text))  # => 'hello world next'
 
# 4. HTMLタグの除去
html = "<p>Hello <b>World</b></p>"
print(re.sub(r'<[^>]+>', '', html))  # => 'Hello World'
 
# 5. 日付フォーマットの変換 (YYYY/MM/DD → YYYY-MM-DD)
date = "2026/02/15"
print(re.sub(r'(\d{4})/(\d{2})/(\d{2})', r'\1-\2-\3', date))
# => '2026-02-15'
 
# 6. 後方参照を使った重複語の検出と修正
text = "the the quick brown fox fox"
print(re.sub(r'\b(\w+)\s+\1\b', r'\1', text))
# => 'the quick brown fox'

import re
 
# NG: raw string を使わずに正規表現を書く
pattern_bad = "\\b\\w+\\b"  # 読みにくい、エスケープミスしやすい
 
# OK: raw string を使う
pattern_good = r"\b\w+\b"   # 明快で間違いにくい
 
text = "hello world"
print(re.findall(pattern_good, text))  # => ['hello', 'world']
 
# 特に危険な例:
# "\b" は Python では バックスペース文字(0x08)
# r"\b" は正規表現の単語境界
print("\b" == "\x08")   # => True  -- バックスペース!
print(r"\b" == "\\b")   # => True  -- 正規表現の \b

import re
 
# NG: ドットで何でもマッチさせる
pattern_bad = r'\d+.\d+.\d+'
 
# これは "192.168.1.1" だけでなく以下にもマッチしてしまう:
texts = ["192.168.1.1", "192-168-1-1", "192x168x1x1", "192 168 1 1"]
for t in texts:
    m = re.search(pattern_bad, t)
    if m:
        print(f"  マッチ: {m.group()}")  # 全てマッチしてしまう
 
# OK: ドットをエスケープして明示的にする
pattern_good = r'\d+\.\d+\.\d+\.\d+'
for t in texts:
    m = re.search(pattern_good, t)
    if m:
        print(f"  マッチ: {m.group()}")  # "192.168.1.1" のみマッチ

import re
 
# NG: 正規表現で書く必要がないケース
 
# 単純な文字列検索は in 演算子で十分
text = "hello world"
 
# NG
if re.search(r'hello', text):
    pass
 
# OK (高速かつ明快)
if 'hello' in text:
    pass
 
# NG: 先頭/末尾のチェックに正規表現
if re.match(r'^hello', text):
    pass
 
# OK
if text.startswith('hello'):
    pass
 
# NG: 固定文字列の置換
re.sub(r'hello', 'hi', text)
 
# OK
text.replace('hello', 'hi')

import re
 
text = "say hello world"
 
# match() は文字列の先頭からのみマッチを試みる
m = re.match(r'hello', text)
print(m)  # => None  ※ 先頭が 'say' なので不一致
 
# search() は文字列全体を検索する
m = re.search(r'hello', text)
print(m.group())  # => 'hello'
 
# fullmatch() は文字列全体が一致するかを確認
m = re.fullmatch(r'hello', "hello")
print(m.group())  # => 'hello'
 
m = re.fullmatch(r'hello', "hello world")
print(m)  # => None  ※ 末尾に余分な文字があるため
 
# 全体マッチのベストプラクティス:
# 入力検証には fullmatch() を使用（Python 3.4+）
# テキスト検索には search() を使用
# 行頭マッチには match() を使用

import re
import time
 
text_lines = [f"line {i}: some text here" for i in range(100000)]
 
# NG: ループ内で毎回文字列パターンを使用
start = time.time()
for line in text_lines:
    re.search(r'\d+', line)
print(f"未コンパイル: {time.time() - start:.3f}s")
 
# OK: プリコンパイル
pattern = re.compile(r'\d+')
start = time.time()
for line in text_lines:
    pattern.search(line)
print(f"コンパイル済み: {time.time() - start:.3f}s")
 
# ※ Python の re モジュールは内部キャッシュ(最大512パターン)を持つため
#    少数のパターンを繰り返し使う場合は差が小さいが、
#    明示的なコンパイルは意図を明確にする

import re
 
# 1. 文字クラスは選択肢より高速
# NG
pattern_slow = r'a|b|c|d|e'
# OK
pattern_fast = r'[a-e]'
 
# 2. 非キャプチャグループでメモリ節約
# NG (キャプチャが不要な場合)
pattern_slow = r'(foo|bar|baz)+'
# OK
pattern_fast = r'(?:foo|bar|baz)+'
 
# 3. アンカーで検索範囲を限定
# NG
pattern_slow = r'error'  # 文字列全体を走査
# OK (エラーが行頭にある場合)
pattern_fast = r'^error'  # 各行の先頭のみチェック
 
# 4. 具体的なパターンが優先
# NG
pattern_slow = r'.+@.+\..+'  # 曖昧すぎる
# OK
pattern_fast = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
 
# 5. 選択肢は長いものから先に
# NG (短い選択肢が先にマッチして問題になるケース)
pattern_slow = r'Java|JavaScript'
# OK
pattern_fast = r'JavaScript|Java'

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

import re
user_input = "price is $10.00 (tax+)"
escaped = re.escape(user_input)
print(escaped)  # => 'price\\ is\\ \\$10\\.00\\ \\(tax\\+\\)'
 
# そのまま正規表現として安全に使える
pattern = re.compile(escaped)

import re
text = "line1\nline2\nline3"
# デフォルト: ドットは改行にマッチしない
print(re.search(r'line1.+line3', text))  # => None
 
# DOTALL: ドットが改行にもマッチ
m = re.search(r'line1.+line3', text, re.DOTALL)
print(m.group())  # => 'line1\nline2\nline3'

import re
pattern = re.compile(r'^hello.+world$', re.IGNORECASE | re.MULTILINE | re.DOTALL)
# JavaScript: /^hello.+world$/ims
# Perl: /^hello.+world$/ims

pattern = re.compile(r'(?ims)^hello.+world$')

import re
 
# Python のデフォルト(Unicode モード)
print(re.findall(r'\d+', "半角123 全角１２３"))
# => ['123', '１２３']  ※ 全角数字にもマッチする！
 
# ASCII モードに制限
print(re.findall(r'\d+', "半角123 全角１２３", re.ASCII))
# => ['123']  ※ 半角数字のみ
 
# JavaScript の /u フラグ
# /\d+/u は Unicode 数字にもマッチ
# /\d+/ は ASCII 数字のみ（エンジンによる）

import re
 
text = "hello world"
 
# match(): 文字列の先頭からマッチを試みる
re.match(r'hello', text)       # => マッチ
re.match(r'world', text)       # => None
 
# search(): 文字列全体を検索
re.search(r'hello', text)      # => マッチ
re.search(r'world', text)      # => マッチ
 
# fullmatch(): 文字列全体がパターンと一致するか
re.fullmatch(r'hello', text)   # => None
re.fullmatch(r'hello world', text)  # => マッチ

import re
 
pattern = re.compile(r'''
    ^                   # 文字列の先頭
    (?P<protocol>       # プロトコル部分
        https?          #   http または https
    )
    ://                 # スキーム区切り
    (?P<host>           # ホスト部分
        [^/]+           #   スラッシュ以外の1文字以上
    )
    (?P<path>           # パス部分 (オプション)
        /[^\s]*         #   スラッシュから始まる
    )?
    $                   # 文字列の末尾
''', re.VERBOSE)
 
m = pattern.match('https://example.com/path/to/page')
if m:
    print(m.groupdict())
    # => {'protocol': 'https', 'host': 'example.com', 'path': '/path/to/page'}