正規表示式是處理文字的利器，它能精準匹配特定模式的字串。理解其語法規則，能大幅提升程式碼的效率和靈活性。本文從基礎語法出發，逐步深入探討字元類別、特殊字元的應用，並以 Unicode 字元的處理方式作為延伸。接著，我們將探討子字串和參照的機制，如何有效捕捉特定片段並重複利用。為加深理解，我們提供了 Python 程式碼範例，示範如何運用正規表示式進行字串操作，並比較貪婪量詞和懶惰量詞的差異，讓讀者更清楚地掌握它們的應用場景。最後，本文介紹了 ELIZA 聊天機器人的運作原理，並以 Python 程式碼展示其實作方式，體現正規表示式在自然語言處理領域的應用價值。

正規表示式語法

正規表示式（Regular Expressions）是一種強大的字串查詢和匹配工具。它允許您使用特定的模式來查詢和操控字串中的文字。

字元類別

• [a-z]：匹配任意小寫拉丁字母。
• [a-lnp-zα-εη-ω]：匹配任意小寫拉丁字母（除「m」和「o」外）或任意小寫希臘字母（除「ζ」外）。
• [^0-9]：匹配任意非阿拉伯數字字元。

特殊字元

• \：用於保護特殊字元，例如 \[, \], \\ 等。
• ^：當作第一個字元時，表示匹配除括號內字元之外的所有字元。
• -：當作最後一個字元時，表示匹配字元本身。

Unicode 字元

• \uABCD：匹配 Unicode 字元，其程式碼為 U+ABCD。
• \U00ABCDEF：匹配 Unicode 字元，其程式碼超出基本平面。

子字串和參照

• ([a-z])([a-z])\1\2：描述了一種語言，其中兩個字元相同。
• \1, \2 等：參照括號內的子字串。

示例

• ([a-z])([a-z])\1\2：匹配「aa」、「bb」等字串。
• [a-z]{3,5}：匹配長度為 3 到 5 的小寫拉丁字母字串。

常見正規表示式語法

• .：匹配任意單個字元。
• *：匹配前一個字元的 0 次或多次出現。
• +：匹配前一個字元的 1 次或多次出現。
• ?：匹配前一個字元的 0 次或 1 次出現。
• {n, m}：匹配前一個字元的 n 到 m 次出現。
• |：匹配左右兩個表示式之一。
• ^：匹配字串的開始。
• $：匹配字串的結束。

結語

正規表示式是一種強大的工具，能夠幫助您高效地查詢和操控字串中的文字。透過掌握正規表示式語法，您可以更好地解決字串相關的問題。

正規表示式與形式語言

在電腦科學中，正規表示式（Regular Expression）是一種用於匹配字串的模式。形式語言（Formal Language）則是用於描述一組字串的集合。這兩個概念在電腦科學中非常重要，尤其是在文書處理、編譯器設計和模式匹配等領域。

形式語言的定義

形式語言是一組字串的集合，通常用於描述一組語法或語言的規則。例如，自然語言中的語法規則可以用形式語言來描述。形式語言可以用不同的方法來定義，例如使用生產式（Production）或正規表示式。

正規表示式的應用

正規表示式是一種強大的工具，用於匹配字串的模式。它可以用於搜尋、替換和驗證字串。例如，以下正規表示式 (([a-z])([a-z]))\1\2\3 可以匹配字串中的重複模式。

示例分析

給定的正規表示式 (([a-z])([a-z]))\1\2\3 可以分解為以下部分：

• ([a-z]) 匹配任何小寫字母，並將其作為一組（group 1）。
• ([a-z]) 匹配任何小寫字母，並將其作為另一組（group 2）。
• \1 和 \2 分別參照第一組和第二組的內容。
• \3 參照第三組的內容，但在這個正規表示式中，並沒有明確的第三組，因此這可能是一個錯誤。

這個正規表示式試圖匹配一個模式，其中兩個小寫字母重複出現。然而，由於 \3 的參照可能是錯誤的，這個正規表示式可能不會如預期般運作。

修正和應用

如果我們想要匹配一個字串，其中兩個小寫字母重複出現，例如 “abab”，我們可以使用以下正規表示式：([a-z]{2})\1。這個正規表示式匹配任何兩個小寫字母的組合，並將其作為一組（group 1），然後使用 \1 來參照這一組，從而匹配重複的模式。

  flowchart TD
    A[開始] --> B[匹配兩個小寫字母]
    B --> C[將匹配的內容作為一組]
    C --> D[參照這一組來匹配重複的模式]
    D --> E[成功匹配則傳回 true]
    E --> F[失敗匹配則傳回 false]

圖表翻譯：

這個流程圖描述了使用正規表示式匹配字串的過程。首先，正規表示式嘗試匹配兩個小寫字母的組合。成功匹配後，將這個組合作為一組，以便後續參照。接著，正規表示式使用這個參照來匹配重複的模式。如果匹配成功，則傳回 true，否則傳回 false。

正規表示式的組成元素

正規表示式（Regular Expression）是一種強大的文字模式匹配工具，廣泛用於各種程式設計語言中。它由三個主要成分組成：字元、群組和量詞。

字元

字元是正規表示式的基本單位，可以是任何單個字元，包括英文字母、數字、特殊符號等。例如，a、1、@都是單個字元。

群組

群組是指在正規表示式中使用括號()將多個字元或模式封裝起來，形成一個單位。這樣可以方便地對這些字元進行操作，例如重複、選擇等。群組也可以用來捕捉子匹配，以便在替換字串時參照。例如，(abc)是一個群組，匹配字串abc。

量詞

量詞是用來指定前面的模式或字元的出現次數。常見的量詞包括：

• *：零次或多次
• +：一次或多次
• ?：零次或一次
• {n}：恰好n次
• {n,}：n次或多次
• {n,m}：至少n次，至多m次

例如，a*匹配零個或多個a，a+匹配一個或多個a，a?匹配零個或一個a，a{3}恰好匹配三個a。

示例

import re

# 匹配字串"hello"中的"ll"出現一次或多次
pattern = r"hel+o"
match = re.search(pattern, "hello")
if match:
    print("匹配成功")
else:
    print("匹配失敗")

# 匹配字串中所有以"a"開頭，後面跟著零個或多個"b"，然後是"c"的子字串
pattern = r"ab*c"
string = "abc ac bc"
matches = re.findall(pattern, string)
print(matches)

正規表示式基礎

正規表示式（Regular Expression）是一種強大的文字匹配工具，常用於搜尋、驗證和提取特定模式的文字。以下是正規表示式的一些基礎概念：

量詞（Quantifier）

量詞用於指定前面的元素出現的次數。常見的量詞包括：

• *：0次或以上
• +：1次或以上
• ?：0次或1次
• {p}：恰好p次
• {p, q}：至少p次，至多q次
• {p,}：至少p次

邏輯或運算子（|）

邏輯或運算子用於指定多個模式中的任意一個。例如：a|b可以匹配"a"或"b"。

特殊字元

• .：匹配任何字元（除換行符外）
• (?:)：非捕捉群組，用於指定一個模式，但不捕捉其內容。

非捕捉群組

非捕捉群組使用(?:)來定義。它允許你將一個模式作為一個單位，但不捕捉其內容。這對於提高正規表示式的效率和簡潔性很有幫助。

例子

• a*：匹配0個或多個"a"
• a+：匹配1個或多個"a"
• a?：匹配0個或1個"a"
• a{3,5}：匹配3到5個"a"
• a|b：匹配"a"或"b"
• .：匹配任何字元（除換行符外）
• (?:a)b：匹配"a"後跟"b"，但不捕捉"a"

內容解密：

以上內容介紹了正規表示式的基礎概念，包括量詞、邏輯或運算子、特殊字元和非捕捉群組。這些元素是構建正規表示式的基礎，掌握它們可以幫助你更好地使用正規表示式進行文字匹配和提取。

圖表翻譯：

  flowchart TD
    A[開始] --> B[輸入正規表示式]
    B --> C[解析量詞]
    C --> D[解析邏輯或運算子]
    D --> E[解析特殊字元]
    E --> F[匹配文字]
    F --> G[輸出結果]

這個流程圖展示了正規表示式的匹配過程，從輸入正規表示式開始，到解析量詞、邏輯或運算子和特殊字元，最終匹配文字並輸出結果。

正規表示式的延伸：懶惰量詞

在 POSIX 語法的基礎上，已經發展出許多延伸，包括 GNU 延伸、Perl 延伸（PCRE）以及在所有主要程式語言中的實作。其中一個重要的延伸是「懶惰量詞」（lazy quantifiers）。

貪婪量詞

POSIX 中的量詞被稱為「貪婪量詞」（greedy quantifiers），因為它們在匹配字元時總是會傳回最長可能的匹配。例如，當我們在字串「xxxabbbbyyy」中搜尋語言「ab+」（即以「a」後跟一個或多個「b」組成的字串）時，正規表示式引擎會傳回「abbbb」，這是包含最多「b」字元的最長字串。

懶惰量詞的引入

然而，「懶惰量詞」則提供了一種不同的匹配方式。它們在匹配字元時會傳回最短可能的匹配，而不是最長的。這種行為可以透過在量詞後新增一個問號（？）來實作。例如，「ab+?」會匹配「ab」而不是「abbbb」，因為它會傳回最短可能的匹配。

實際應用

在實際應用中，「懶惰量詞」可以用於更精確地控制匹配的行為，特別是在需要匹配最短可能的字串時。這種能力在處理複雜的文字模式時尤其有用。

程式碼示例

以下是使用 Python 的 re 模組實作「懶惰量詞」的示例：

import re

# 貪婪量詞
pattern = r"ab+"
string = "xxxabbbbyyy"
match = re.search(pattern, string)
print(match.group())  # Output: abbbb

# 懶惰量詞
pattern = r"ab+?"
string = "xxxabbbbyyy"
match = re.search(pattern, string)
print(match.group())  # Output: ab

在這個示例中，我們使用「貪婪量詞」和「懶惰量詞」分別匹配字串「xxxabbbbyyy」。結果顯示，「懶惰量詞」傳回了最短可能的匹配「ab」，而「貪婪量詞」傳回了最長可能的匹配「abbbb」。

圖表翻譯

  flowchart TD
    A[開始] --> B[匹配字元]
    B --> C{貪婪量詞}
    C -->|是| D[傳回最長匹配]
    C -->|否| E[傳回最短匹配]
    D --> F[輸出最長匹配]
    E --> F[輸出最短匹配]

這個圖表描述了「貪婪量詞」和「懶惰量詞」的匹配行為。當使用「貪婪量詞」時，會傳回最長可能的匹配；而當使用「懶惰量詞」時，會傳回最短可能的匹配。

正規表示式中的懶惰量詞

在正規表示式中，量詞（如 *、+、{n, m}）用於指定模式匹配的次數。預設情況下，這些量詞是貪婪的，也就是說，它們會盡可能匹配最長的字串。然而，透過在量詞後新增一個問號（?），我們可以將其變為懶惰的，從而匹配最短的字串。

貪婪與懶惰量詞的比較

• 貪婪量詞：匹配最長的字串。
• 懶惰量詞：匹配最短的字串。

懶惰量詞的應用

例如，對於正規表示式 a+，它會匹配一個或多個 a。如果我們將其修改為懶惰版本 a+?，它仍然會匹配一個或多個 a，但會傳回最短的匹配。

對於字串 xxxabbbyyy，貪婪版本 a+ 會匹配所有連續的 a，而懶惰版本 a+? 會匹配最少的 a，也就是一個 a。

實際案例

• ab+?：這個表示式會匹配 ab，因為它是最短的匹配。
• [a-z]*?：這個表示式描述的是包含空字串的語言，因為「0、1 或多個字元」的最小匹配是 0。

這些例子可能會讓讀者感到疑惑，為什麼要使用 ab+? 而不是 ab，因為它們傳回相同的結果。關鍵在於，懶惰量詞可以在更複雜的正規表示式中提供更好的控制，尤其是當你需要匹配特定的模式，但又不想匹配太多字元的時候。

內容解密：

import re

# 貪婪匹配
print(re.findall('a+', 'xxxabbbyyy'))  # ['aaa', 'bb', 'yyy']

# 懶惰匹配
print(re.findall('a+?', 'xxxabbbyyy'))  # ['a', 'a', 'a', 'b', 'b', 'y', 'y', 'y']

在這個例子中，貪婪版本 a+ 匹配所有連續的 a，而懶惰版本 a+? 匹配每個單獨的 a。

使用Python進行正規表示式處理

正規表示式是一種強大的工具，能夠用於字串的搜尋、驗證和提取。Python的re模組提供了對正規表示式的支援。

基本概念

正規表示式是一種模式，用於匹配字串中的字元序列。它由特殊字元和普通字元組成，特殊字元包括., *, +, ?, {, }, [, ], (, ), ^, $, \等。

Python中的正規表示式

在Python中，正規表示式可以使用re模組進行處理。首先需要匯入re模組：

import re

然後可以使用re模組的方法進行正規表示式的處理。

常用方法

re模組提供了以下常用方法：

• match(): 對字串的開始進行匹配。
• search(): 對字串進行搜尋，傳回第一個匹配的位置。
• findall(): 對字串進行搜尋，傳回所有匹配的位置。
• sub(): 對字串進行替換。
• split(): 對字串進行分割。

示例

以下是使用re模組進行正規表示式處理的示例：

import re

# 對字串的開始進行匹配
match = re.match(r"hello", "hello world")
if match:
    print("匹配成功")

# 對字串進行搜尋
search = re.search(r"world", "hello world")
if search:
    print("搜尋成功")

# 對字串進行替換
sub = re.sub(r"hello", "hi", "hello world")
print(sub)  # 輸出：hi world

# 對字串進行分割
split = re.split(r",", "a,b,c")
print(split)  # 輸出：['a', 'b', 'c']

玄貓的正規表示式示例

以下是使用玄貓的正規表示式示例：

import re

# 對字串進行搜尋
search = re.search(r"\[(.*?)\]", "[abc]de[fgh]")
if search:
    print("搜尋成功")
    print(search.group(1))  # 輸出：abc

# 對字串進行替換
sub = re.sub(r"\[(.*?)\]", r"{\1}", "[abc]de[fgh]")
print(sub)  # 輸出：{abc}de{fgh}

9.4 正則語言

正則語言是電腦科學中的一個重要概念，尤其是在文字處理和模式匹配中。它提供了一種強大的工具，讓我們可以描述和匹配字串中的模式。

9.4.1 正規表示式

正規表示式是用於描述正則語言的表示式。它是一種特殊的字串，使用特殊字元和語法來描述模式。例如，r"([^0-9])([12][0-9]{3})([^0-9])"是一個正規表示式，匹配字串中的年份（1717至2023）。

9.4.1.1 sub 方法

sub 方法是 Python 中的 re 模組的一部分，用於替換字串中的模式。它的語法是 re.sub(pattern, repl, string), 其中 pattern 是正規表示式，repl 是替換字串，string 是要被替換的字串。

以下是使用 sub 方法的例子：

import re

def replace(m):
    if int(m.group(2)) >= 1717 and int(m.group(2)) <= 2023:
        return m.group(1) + str(int(m.group(2)) + 4000) + m.group(3)
    else:
        return m.group(0)

with open("input.txt", "r", encoding="utf-8") as f:
    for line in f:
        res = re.sub(r"([^0-9])([12][0-9]{3})([^0-9])", replace, line)
        print(res)

在這個例子中，replace 函式被用作 sub 方法的替換函式。它接收一個匹配物件 m，並傳回替換字串。

9.4.1.2 匹配物件

匹配物件是 re 模組的一部分，用於儲存匹配結果。它提供了 group(i) 方法，傳回第 i 個括號中的字串。

例如，m.group(1) 傳回第一個括號中的字串，m.group(2) 傳回第二個括號中的字串，依此類推。

9.4.1.3 ELIZA

ELIZA 是一個著名的聊天機器人，使用正規表示式和模式匹配技術來模擬人類對話。它的工作原理是使用正規表示式匹配使用者輸入的字串，並根據匹配結果傳回相應的回應。

以下是使用 ELIZA 的例子：

HOW DO YOU DO. I AM THE DOCTOR. PLEASE
SIT DOWN AT THE TYPEWRITER AND TELL ME

在這個例子中，ELIZA 使用正規表示式匹配使用者輸入的字串，並傳回相應的回應。

ELIZA程式的誕生和運作原理

ELIZA是一個由Joseph Weizenbaum於1966年開發的聊天機器人程式，旨在模擬某些精神療法師（如羅傑斯式療法）的對話風格。Weizenbaum選擇這種對話模式是因為它允許程式在不需要大量背景知識的情況下進行對話。

ELIZA的命名和啟發

ELIZA的名稱來自於蕭伯納的劇作《皮格馬利翁》中的角色艾莉莎·杜利特爾，一位從酒吧女服務員變成上流社會女性的角色。Weizenbaum選擇這個名稱可能是因為艾莉莎的轉變和ELIZA程式的能力——透過模擬對話來改變使用者的觀點。

ELIZA的運作原理

ELIZA使用了一種簡單的模式匹配和替換機制來生成回應。程式會分析使用者的輸入，識別出特定的模式，然後根據這些模式生成一個回應。這個過程可以使用正規表示式來實作。

ELIZA的實作和演變

ELIZA的原始程式碼是用MADSLIP語言編寫的，後來被重新實作為Python版本。Python版本的ELIZA使用正規表示式來匹配使用者的輸入和生成回應。

ELIZA的影響和意義

ELIZA是第一個聊天機器人程式，它的出現標誌著人工智慧和自然語言處理領域的開始。ELIZA的簡單但有效的對話機制啟發了後續的聊天機器人和虛擬助手的開發。

ELIZA的程式實作

以下是ELIZA程式的一個簡單實作：

import re

# 定義一個字典來儲存模式和回應
patterns = {
    r"I (.*) you": "YOU SEEM TO NEED TO {} ME",
    r"(.*) hate (.*)": "WHY DO YOU HATE {}?",
    r"(.*) love (.*)": "WHY DO YOU LOVE {}?"
}

def eliza_response(input_text):
    # 分析使用者的輸入
    for pattern, response in patterns.items():
        match = re.match(pattern, input_text)
        if match:
            # 生成回應
            return response.format(match.group(1))
    return "I DON'T UNDERSTAND"

# 測試ELIZA程式
print(eliza_response("I hate you"))  # 輸出: YOU SEEM TO NEED TO HATE ME
print(eliza_response("I love you"))  # 輸出: WHY DO YOU LOVE YOU?

這個實作使用正規表示式來匹配使用者的輸入和生成回應。它是一個簡單的示例，展示了ELIZA程式的基本運作原理。

自然語言處理中的ELIZA程式

ELIZA是一個著名的聊天機器人程式，於1960年代由Joseph Weizenbaum開發。它的設計目的是模擬一個心理醫生的對話，使用簡單的模式匹配和替換來回應使用者的輸入。ELIZA的核心是使用一組規則和替換來處理使用者的輸入，並生成相應的回應。

從技術架構視角來看，正規表示式引擎的實作機制，無論是根據有限狀態自動機（FSA）還是回溯演算法，都深刻影響著其匹配效率和資源消耗。分析段落中提到的貪婪匹配和懶惰匹配的差異，體現了引擎在處理量詞時的策略不同，對於效能最佳化至關重要。尤其在處理大型文字或複雜模式時，選擇合適的匹配策略能有效避免效能瓶頸。技術限制深析顯示，正規表示式在處理遞迴或巢狀結構時，能力相對有限，這也催生了其他語法分析工具的發展。展望未來，正規表示式與機器學習的結合將是重要的發展方向，例如利用機器學習自動生成正規表示式，提升模式匹配的效率和準確性。玄貓認為，深入理解正規表示式引擎的底層機制，並結合實際應用場景選擇合適的匹配策略，才能最大限度地發揮其強大功能。