Python正则表达式生成器

import re
from typing import Optional, Dict

# Regex: match one Nginx access-log line and extract ip, ts, method, path, status, rt_ms
NGINX_LOG_RE = re.compile(r"""
^
(?P<ip>(?:\d{1,3}\.){3}\d{1,3})      # IPv4 address (not range-validated)
\s+-\s+-\s+                          # literal " - - " with spaces
\[
  (?P<ts>\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2})
\]
\s+
(?P<method>[A-Z]+)                   # HTTP method in uppercase
\s+
(?P<path>\S+)                        # path without spaces
\s+
HTTP/\d\.\d                          # HTTP version like 1.1, 2.0
\s+
(?P<status>\d{3})                    # 3-digit status code
\s+                                  # at least one space after status
(?:.*\s)?                            # optional middle fields (size, referrer, UA, etc.)
(?P<rt_ms>\d+)ms                     # integer response time followed by "ms"
$
""", re.VERBOSE)

def parse_nginx_line(line: str) -> Optional[Dict[str, str]]:
    """
    Parse a single Nginx access-log line.
    Returns a dict with keys: ip, ts, method, path, status, rt_ms, or None if no match.
    """
    m = NGINX_LOG_RE.match(line)
    if not m:
        return None
    return m.groupdict()

Detailed explanation

• ip: Captures an IPv4 dotted-quad. This pattern does not enforce 0–255 per octet for performance and simplicity.
• ts: Captures timestamp strictly as "YYYY-MM-DD HH:MM:SS" inside brackets.
• method: Captures one or more uppercase letters.
• path: Captures a non-space sequence (no spaces allowed).
• status: Captures a 3-digit HTTP status.
• rt_ms: Captures the trailing integer response time immediately followed by "ms".
• The regex is anchored with ^ and $ to ensure full-line matches and avoid partial matches.
• After status, the pattern tolerates arbitrary middle fields (bytes, referrer, user-agent, etc.) and extracts the final "ms" token at line end.

Usage examples and tests

def _show(line: str) -> None:
    parsed = parse_nginx_line(line)
    print(("OK", parsed) if parsed else ("NO MATCH", line))

# Positive examples (should match)
pos_lines = [
    "203.0.113.12 - - [2024-08-12 14:23:11] GET /api/v1/items?id=42 HTTP/1.1 200 512 - Mozilla/5.0 18ms",
    "198.51.100.99 - - [2025-01-01 00:00:00] POST /index.html HTTP/1.0 404 1024 \"-\" curl/8.4.0 123ms",
    "192.0.2.5 - - [2024-12-31 23:59:59] HEAD /ping HTTP/1.1 200 18ms",  # no extra middle fields
]

# Negative examples (should not match)
neg_lines = [
    "203.0.113.12 - - [2024/08/12 14:23:11] GET /api/v1 HTTP/1.1 200 18ms",  # wrong timestamp format
    "203.0.113.12 - - [2024-08-12 14:23:11] get /api HTTP/1.1 200 18ms",    # method not uppercase
    "203.0.113.12 - - [2024-08-12 14:23:11] GET /api v1 HTTP/1.1 200 18ms", # space in path
    "203.0.113.12 - - [2024-08-12 14:23:11] GET /api HTTP/1.1 2000 18ms",   # 4-digit status
    "203.0.113.12 - - [2024-08-12 14:23:11] GET /api HTTP/1.1 200 18 ms",   # space between number and ms
    "2001:db8::1 - - [2024-08-12 14:23:11] GET /api HTTP/1.1 200 18ms",     # IPv6 not supported by this pattern
]

for line in pos_lines:
    _show(line)

for line in neg_lines:
    _show(line)

# Minimal assertion checks
assert parse_nginx_line(pos_lines[0]) == {
    'ip': '203.0.113.12',
    'ts': '2024-08-12 14:23:11',
    'method': 'GET',
    'path': '/api/v1/items?id=42',
    'status': '200',
    'rt_ms': '18',
}

assert parse_nginx_line(pos_lines[2]) == {
    'ip': '192.0.2.5',
    'ts': '2024-12-31 23:59:59',
    'method': 'HEAD',
    'path': '/ping',
    'status': '200',
    'rt_ms': '18',
}

assert parse_nginx_line(neg_lines[0]) is None
assert parse_nginx_line(neg_lines[1]) is None
assert parse_nginx_line(neg_lines[2]) is None
assert parse_nginx_line(neg_lines[3]) is None
assert parse_nginx_line(neg_lines[4]) is None
assert parse_nginx_line(neg_lines[5]) is None

Common matching scenarios

• ETL/streaming extraction: Use the compiled regex to parse each log line and emit a dict with the six fields for downstream processing.
• Batch parsing: Iterate over a file line by line, calling parse_nginx_line and filtering out None results.
• Validation: Quickly validate that an input string conforms to the expected log shape before ingestion.

Performance notes

• The pattern is anchored (^) and ($) to prevent partial matches and reduce backtracking.
• The only unbounded segment after the status uses a single greedy ".*" before the final whitespace and "rt_ms". This remains linear-time for typical single-line log entries.
• Octet range validation for IPv4 is intentionally omitted to avoid lengthy alternations. If strict 0–255 validation is required, consider validating the captured ip separately in Python for clarity and performance.
• Compile the regex once (as shown) and reuse it across lines to avoid recompilation overhead.

import re
from typing import Optional, Dict

# ISO 8601 扩展格式（YYYY-MM-DDTHH:MM:SS），可选毫秒（1–3位），时区必须为 Z 或 ±HH:MM
# 校验要点：
# - 闰年规则（可匹配 2-29）：能被400整除，或能被4整除但不能被100整除
# - 月份 01–12；每月天数上限正确；小时 00–23；分秒 00–59
ISO8601_DT_PATTERN = re.compile(
    r"""
^
(?P<date>
  (?:
    # 非闰年的通用日期（含2月1-28）
    (?:\d{4})-
    (?:
      (?:01|03|05|07|08|10|12)-(?:0[1-9]|[12]\d|3[01])   # 31天的月
      |
      (?:04|06|09|11)-(?:0[1-9]|[12]\d|30)               # 30天的月
      |
      (?:02-(?:0[1-9]|1\d|2[0-8]))                       # 2月1-28
    )
    |
    # 闰年专用的 2-29
    (?:
      (?:
        (?:\d{2}(?:0[48]|[2468][048]|[13579][26]))   # 非整百年，后两位 %4==0（不含00）
        |
        (?:[02468][048]|[13579][26])00               # 整百年且 %400==0
      )
      -02-29
    )
  )
)
T
(?P<time>
  (?:[01]\d|2[0-3])      # 小时 00-23
  :
  [0-5]\d                # 分 00-59
  :
  [0-5]\d                # 秒 00-59
)
(?:\.(?P<ms>\d{1,3}))?   # 可选毫秒 1-3 位
(?P<tz>
  Z
  |
  [+\-](?:[01]\d|2[0-3]):[0-5]\d   # 时区 ±HH:MM（此处允许 00:00–23:59）
)
$
""",
    re.VERBOSE,
)

def is_iso8601_dt(s: str) -> bool:
    """格式检查：字符串是否满足指定的 ISO 8601 日期时间格式。"""
    return ISO8601_DT_PATTERN.fullmatch(s) is not None

def parse_iso8601_dt(s: str) -> Optional[Dict[str, Optional[str]]]:
    """
    解析并返回命名分组：
    - date: YYYY-MM-DD
    - time: HH:MM:SS
    - ms:   毫秒数字（1–3位），若无则为 None
    - tz:   时区字符串（Z 或 ±HH:MM）
    未匹配返回 None。
    """
    m = ISO8601_DT_PATTERN.fullmatch(s)
    return m.groupdict() if m else None

详细的功能说明

• 支持的格式：YYYY-MM-DDTHH:MM:SS[.ms]Z|±HH:MM
• 严格的范围校验：
  • 年：4位数字（0000–9999 均可匹配；闰年按规则判定）
  • 月：01–12
  • 日：根据不同月份的天数判定；2月在闰年允许29日
  • 时间：小时 00–23，分 00–59，秒 00–59（不支持闰秒 60）
  • 毫秒：可选小数点后 1–3 位数字（仅捕获数字部分为 ms）
  • 时区：必须存在，且为大写 Z 或 ±HH:MM（此处允许 00:00–23:59）
• 命名分组：
  • date：完整日期部分（YYYY-MM-DD）
  • time：完整时间部分（HH:MM:SS）
  • ms：毫秒数字（若无则为 None）
  • tz：时区（Z 或 ±HH:MM）

使用示例和测试用例

positives = [
    "2023-12-31T23:59:59Z",
    "2020-02-29T00:00:00+08:00",
    "2000-02-29T23:59:59-00:00",   # 世纪闰年
    "1996-02-29T12:30:15Z",        # 普通闰年
    "2024-02-29T00:00:00Z",
    "2023-01-31T00:00:00+00:00",
    "2023-12-31T23:59:59.1Z",      # 1位毫秒
    "2023-12-31T23:59:59.12+14:00",# 2位毫秒
    "2023-12-31T23:59:59.123-05:30"# 3位毫秒
]

negatives = [
    "2021-02-29T00:00:00Z",        # 非闰年 2-29
    "1900-02-29T12:00:00Z",        # 世纪年非闰年
    "2023-04-31T00:00:00Z",        # 4月无31日
    "2023-13-01T00:00:00Z",        # 非法月份
    "2023-00-10T00:00:00Z",        # 非法月份
    "2023-12-00T00:00:00Z",        # 非法日期
    "2023-12-31T24:00:00Z",        # 非法小时
    "2023-12-31T23:60:00Z",        # 非法分钟
    "2023-12-31T23:59:60Z",        # 非法秒（不支持闰秒）
    "2023-12-31T23:59:59.1234Z",   # 毫秒>3位
    "2023-12-31T23:59:59",         # 缺少时区
    "2023-12-31 23:59:59Z",        # 缺少 'T'
    "2023-12-31T23:59:59z",        # 小写 z 不允许
    "2023-12-31T23:59:59+0800",    # 时区缺少冒号
    "2023-12-31T23:59:59+25:00",   # 时区小时越界
    "2023-12-31T23:59:59+23:60",   # 时区分钟越界
]

print("=== 正例测试 ===")
for s in positives:
    assert is_iso8601_dt(s), f"应匹配但未通过：{s}"
    print(s, "->", parse_iso8601_dt(s))

print("\n=== 反例测试 ===")
for s in negatives:
    assert not is_iso8601_dt(s), f"不应匹配但通过了：{s}"
    print(s, "-> 不匹配")

# 单例解析演示
sample = "2020-02-29T00:00:00+08:00"
parts = parse_iso8601_dt(sample)
# parts 示例：
# {
#   'date': '2020-02-29',
#   'time': '00:00:00',
#   'ms':   None,
#   'tz':   '+08:00'
# }
print("\n解析示例：", sample, "->", parts)

常见匹配场景说明

• API 入参校验：严格验证后端接收的时间戳格式与范围。
• 日志解析：从日志中提取满足格式的时间，确保日期有效性（含闰年判断）。
• 数据清洗：对批量文本中的日期时间字段进行格式过滤与字段拆解（date/time/ms/tz）。

性能注意事项

• 该表达式为锚定匹配（^$）且字段长度固定，分支明确，不存在灾难性回溯风险。
• 建议使用预编译的模式对象（如 ISO8601_DT_PATTERN）并配合 fullmatch，提高性能与准确性。
• 如在高并发环境频繁调用，保持 regex 为模块级单例，避免重复编译。
• 如果只接受特定时区范围，可进一步收紧 tz 的取值范围以减少分支（例如限制到 ±14:00）。