正規化表達式（Regular Expressions，簡稱 regex 或 regexp）是一種強大的搜尋和匹配字符串的工具。正規化表達式通常用於檢索、替換、拆分字符串，以及匹配特定的模式。使用時必須 import re，以下是一些正規化表達式的基本規則和元字符：
  1. 普通字符：
    2. 大多數字符（字母、數字、標點符號）在正規化表達式中表示它們自身。
  2. .（句點）：
    3. 匹配除換行符 \n 外的任意字符。
  3. ^：
    4. 匹配字符串的開頭。
  4. $：
    5. 匹配字符串的結尾。
  5. *：
    6. 匹配前一個元素零次或多次。
  6. +：
    7. 匹配前一個元素一次或多次。
  7. ?：
    8. 匹配前一個元素零次或一次。
  8. {n}：
    9. 匹配前一個元素 exactly n 次。
  9. {n,}：
    10. 匹配前一個元素至少 n 次。
  10. {n,m}：
    11. 匹配前一個元素至少 n 次且不超過 m 次。
  11. []：
    12. 匹配方括號內的任意一個字符。例如，[aeiou] 匹配任何元音字母。
  12. [^]：
    13. 匹配不在方括號內的任意一個字符。例如，[^0-9] 匹配任何非數字字符。
  13. |：
    14. 匹配位於 | 左邊或右邊的表達式。
  14. `()：
    15. 用來創建捕獲組，並指定運算符的範圍。
  15. \：
    16. 用來轉義特殊字符，使其按照字面含義進行匹配。
這只是正規化表達式的一些基本元字符和規則。正規化表達式還有更多高級的功能和概念，例如非貪婪匹配、反向引用等。如果需要深入了解，建議查閱正規化表達式的相關資源或教程。

範例說明：
import re

  1. . 匹配任意字符（除了換行符 \n）。

    2. pattern_dot = re.compile(r'he..o')
    match_dot = pattern_dot.search("hello")
    print(match_dot.group()) # Output: hello

  2. & 匹配字符串的開頭。

    3. pattern_start = re.compile(r'^hello')
    match_start = pattern_start.search("hello world")
    print(match_start.group()) # Output: hello

  3. $ 匹配字符串的結尾。

    4. pattern_end = re.compile(r'world$')
    match_end = pattern_end.search("hello world")
    print(match_end.group()) # Output: world

  4. * 匹配前一個字符零次或多次。

    5. pattern_star = re.compile(r'go*l')
    match_star = pattern_star.search("goooooal")
    print(match_star.group()) # Output: gooooal

  5. + 匹配前一個字符一次或多次。

    6. pattern_plus = re.compile(r'go+l')
    match_plus = pattern_plus.search("goooooal")
    print(match_plus.group()) # Output: gooool

  6. ? 匹配前一個字符零次或一次。

    7. pattern_question = re.compile(r'colou?r')
    match_question = pattern_question.search("color")
    print(match_question.group()) # Output: color

  7. {n} 匹配前一個字符恰好 n 次。

    8. pattern_exact = re.compile(r'\d{3}')
    match_exact = pattern_exact.search("123456")
    print(match_exact.group()) # Output: 123

  8. {m,n} 匹配前一個字符至少 m 次，最多 n 次。

    9. pattern_range = re.compile(r'\d{2,4}')
    match_range = pattern_range.search("12345")
    print(match_range.group()) # Output: 1234

  9. [] 字符集，匹配方括號中的任意一個字符。

    10. pattern_char_set = re.compile(r'[aeiou]')
    match_char_set = pattern_char_set.search("hello")
    print(match_char_set.group()) # Output: e

  10. [^] 否定字符集，匹配除了方括號中的任意一個字符之外的字符。

    11. pattern_not_char_set = re.compile(r'[^aeiou]')
    match_not_char_set = pattern_not_char_set.search("hello")
    print(match_not_char_set.group()) # Output: h

  11. | 或，匹配左右兩邊的任意一個模式。

    12. pattern_or = re.compile(r'cat|dog')
    match_or = pattern_or.search("I have a cat")
    print(match_or.group()) # Output: cat

  12. () 分組，將模式分組，形成子模式。

    13. pattern_group = re.compile(r'(\d{2})-(\d{2})-(\d{4})')
    match_group = pattern_group.search("01-15-2023")
    print(match_group.groups()) # Output: ('01', '15', '2023')

  13. \ 轉義字符，用於匹配一些特殊字符，例如 \. 匹配實際的句點。

    14. pattern_escape = re.compile(r'\d\.\d')
    match_escape = pattern_escape.search("3.14")
    print(match_escape.group()) # Output: 3.1

非貪婪匹配（Non-Greedy Matching）：
在正規表達式中，一般的匹配模式是貪婪的，即它會匹配盡可能多的字符。但有時我們可能希望匹配盡可能少的字符，這時就需要使用非貪婪匹配。在正規表達式中，非貪婪匹配使用 ? 修飾符。

範例：
使用貪婪匹配的表達式：
import re
pattern_greedy = re.compile(r'<.*>')
match_greedy = pattern_greedy.search("<tag1>content1</tag1><tag2>content2</tag2>")
print(match_greedy.group()) # Output: <tag1>content1</tag1><tag2>content2</tag2>，如此得到整個字串

使用非貪婪匹配的表達式：
import re
pattern_non_greedy = re.compile(r'<.*?>')
match_non_greedy = pattern_non_greedy.search("<tag1>content1</tag1><tag2>content2</tag2>")
print(match_non_greedy.group()) # Output: <tag1>，只得到 <tag1>

反向引用（Backreference）：
反向引用是指在正規表達式中使用先前匹配的結果來進行進一步的匹配。在正規表達式中，使用圓括號 () 括起來的部分表示一個分組，這些分組可以在後面的表達式中被引用。

範例：
import re
pattern_backreference = re.compile(r'(\w+) is \1')
match_backreference = pattern_backreference.search("word is word, python is python, regex is regex")
print(match_backreference.group()) # Output: word is word