从基础到高级详解Python字符串边界匹配完整指南

# 典型应用场景
filename = "report_2023_Q4.pdf"
url = "https://www.example.com/api/v1/users"
log_line = "ERROR: Database connection failed"

# 基本用法
is_pdf = filename.endswith('.pdf')  # True
is_secure = url.startswith('https')  # True

# 支持元组参数
is_image = filename.endswith(('.png', '.jpg', '.gif'))  # False
is_api = url.startswith(('http', 'https', 'ftp'))  # True

# 手动切片检查
def check_prefix(text, prefix):
    return text[:len(prefix)] == prefix

# 检查后缀
def check_suffix(text, suffix):
    return text[-len(suffix):] == suffix

# 使用示例
is_error_log = check_prefix(log_line, "ERROR:")  # True

# 转换为统一大小写
is_pdf = filename.lower().endswith('.pdf')  # True

# 使用casefold处理特殊字符
filename = "Report_2023.PDF"
is_pdf = filename.casefold().endswith('.pdf')  # True

import re

# 匹配URL协议
pattern = r'^(https?|ftp)://'
match = re.match(pattern, url)
if match:
    protocol = match.group(1)  # 'https'

# 匹配日志级别
log_pattern = r'^(DEBUG|INFO|WARN|ERROR):'
level_match = re.match(log_pattern, log_line)
if level_match:
    log_level = level_match.group(1)  # 'ERROR'

# 匹配文件扩展名
ext_pattern = r'\.(pdf|docx?|xlsx?)$'
ext_match = re.search(ext_pattern, filename)
if ext_match:
    file_ext = ext_match.group(1)  # 'pdf'

# 匹配URL路径结尾
path_pattern = r'/(users|products|orders)$'
path_match = re.search(path_pattern, url)
if path_match:
    endpoint = path_match.group(1)  # 'users'

# 匹配以数字开头的字符串
num_start = re.match(r'^\d', "2023_report")  # True

# 匹配以标点结尾的字符串
punct_end = re.search(r'[.!?]$', "Hello world!")  # True

# 多条件匹配
def is_valid_filename(name):
    # 以字母开头，以扩展名结尾
    return bool(re.match(r'^[a-zA-Z].*\.(txt|csv|json)$', name))

class PrefixTrie:
    """高效前缀匹配引擎"""
    def __init__(self):
        self.root = {}
    
    def add_prefix(self, prefix):
        node = self.root
        for char in prefix:
            node = node.setdefault(char, {})
        node['$'] = True  # 标记前缀结束
    
    def has_prefix(self, text):
        node = self.root
        for char in text:
            if char not in node:
                return False
            node = node[char]
            if '$' in node:
                return True
        return False

# 使用示例
trie = PrefixTrie()
trie.add_prefix("ERROR:")
trie.add_prefix("WARN:")
trie.add_prefix("INFO:")

log_line = "ERROR: Database connection failed"
print(trie.has_prefix(log_line))  # True

class SuffixAutomaton:
    """高效后缀匹配引擎"""
    def __init__(self, patterns):
        self.patterns = patterns
        self.min_length = min(len(p) for p in patterns) if patterns else 0
    
    def has_suffix(self, text):
        if not self.patterns:
            return False
        
        # 检查长度是否足够
        if len(text) < self.min_length:
            return False
        
        # 检查所有模式
        for pattern in self.patterns:
            if text.endswith(pattern):
                return True
        return False

# 使用示例
image_exts = SuffixAutomaton(['.jpg', '.png', '.gif', '.bmp'])
filename = "vacation_photo.png"
print(image_exts.has_suffix(filename))  # True

def stream_prefix_matcher(stream, prefix):
    """流式数据前缀匹配"""
    buffer = ""
    prefix_len = len(prefix)
    
    while True:
        chunk = stream.read(1024)  # 读取1KB数据块
        if not chunk:
            break
        
        buffer += chunk
        while len(buffer) >= prefix_len:
            if buffer.startswith(prefix):
                yield True
                buffer = buffer[prefix_len:]
            else:
                yield False
                buffer = buffer[1:]

# 使用示例
with open('large_log.txt', 'r') as f:
    for match in stream_prefix_matcher(f, "ERROR:"):
        if match:
            # 处理错误日志
            process_error_log()

class FileTypeValidator:
    """文件类型验证器"""
    def __init__(self):
        self.signatures = {
            b'\xFF\xD8\xFF': 'jpg',  # JPEG文件头
            b'\x89PNG\r\n\x1a\n': 'png',
            b'%PDF': 'pdf',
            b'\x50\x4B\x03\x04': 'zip'
        }
    
    def validate(self, file_path):
        """验证文件类型"""
        with open(file_path, 'rb') as f:
            # 读取文件头
            header = f.read(max(len(sig) for sig in self.signatures))
            
            # 检查所有签名
            for signature, file_type in self.signatures.items():
                if header.startswith(signature):
                    return file_type
        
        # 检查文件扩展名
        if '.' in file_path:
            ext = file_path.split('.')[-1].lower()
            return ext if ext in ('txt', 'csv', 'json') else None
        
        return None

# 使用示例
validator = FileTypeValidator()
file_type = validator.validate('report.pdf')
print(f"文件类型: {file_type}")  # 'pdf'

class Router:
    """基于前缀的URL路由"""
    def __init__(self):
        self.routes = []
    
    def add_route(self, prefix, handler):
        """添加路由规则"""
        self.routes.append((prefix, handler))
    
    def route(self, url):
        """路由分发"""
        for prefix, handler in self.routes:
            if url.startswith(prefix):
                return handler
        return self.default_handler
    
    def default_handler(self, request):
        return "404 Not Found"

# 使用示例
router = Router()
router.add_route('/api/users', user_handler)
router.add_route('/api/products', product_handler)
router.add_route('/static/', static_file_handler)

url = "/api/users/123"
handler = router.route(url)  # 返回user_handler

class LogAnalyzer:
    """实时日志分析器"""
    def __init__(self):
        self.patterns = {
            'error': re.compile(r'^ERROR:'),
            'warn': re.compile(r'^WARN:'),
            'info': re.compile(r'^INFO:'),
            'critical': re.compile(r'^CRITICAL:')
        }
        self.counters = {level: 0 for level in self.patterns}
    
    def process_log(self, line):
        """处理单行日志"""
        for level, pattern in self.patterns.items():
            if pattern.match(line):
                self.counters[level] += 1
                self.handle_log(level, line)
                return
        # 未知日志级别
        self.counters.setdefault('unknown', 0)
        self.counters['unknown'] += 1
    
    def handle_log(self, level, line):
        """处理特定级别的日志"""
        if level == 'error':
            send_alert(line)
        elif level == 'critical':
            trigger_incident(line)

# 使用示例
analyzer = LogAnalyzer()
with open('app.log') as f:
    for line in f:
        analyzer.process_log(line.strip())

# 预编译常用模式
URL_PROTOCOL_PATTERN = re.compile(r'^(https?|ftp)://')
FILE_EXT_PATTERN = re.compile(r'\.(pdf|docx?|xlsx?)$')

# 使用预编译模式
is_http = URL_PROTOCOL_PATTERN.match(url) is not None
is_pdf = FILE_EXT_PATTERN.search(filename) is not None

# 性能对比（100万次调用）：
# 未编译: 1.8秒
# 预编译: 0.4秒

# 使用Cython编写高性能匹配函数
# matcher.pyx
def cython_starts_with(text, prefix):
    cdef int i
    cdef int n = len(prefix)
    if len(text) < n:
        return False
    for i in range(n):
        if text[i] != prefix[i]:
            return False
    return True

# 编译后调用
from matcher import cython_starts_with
result = cython_starts_with("https://example.com", "https")

from pybloom_live import BloomFilter

class SuffixBloomFilter:
    """后缀匹配布隆过滤器"""
    def __init__(self, suffixes, error_rate=0.001):
        self.filter = BloomFilter(capacity=len(suffixes), error_rate=error_rate)
        self.min_length = min(len(s) for s in suffixes)
        for suffix in suffixes:
            self.filter.add(suffix)
    
    def ends_with(self, text):
        """检查文本是否以任何后缀结尾"""
        if len(text) < self.min_length:
            return False
        # 检查可能的长度
        for i in range(self.min_length, len(text)+1):
            suffix = text[-i:]
            if suffix in self.filter:
                return True
        return False

# 使用示例
image_filter = SuffixBloomFilter(['.jpg', '.png', '.gif'])
filename = "photo.png"
print(image_filter.ends_with(filename))  # True

# 简单情况使用startswith/endswith
if filename.endswith('.csv'):
    process_csv(filename)

# 空字符串处理
def safe_starts_with(text, prefix):
    return text.startswith(prefix) if text else False

# 高频调用场景使用预编译
URL_PREFIXES = ('http://', 'https://', 'ftp://')
if any(url.startswith(p) for p in URL_PREFIXES):
    process_url(url)

# 错误：处理特殊Unicode字符
text = "café"
print(text.endswith("e"))  # False，因为é是单个字符

# 解决方案：规范化Unicode
import unicodedata
normalized = unicodedata.normalize('NFD', text)
print(normalized.endswith("e\u0301"))  # True

# 错误：硬编码路径分隔符
is_config = file_path.endswith('/config.ini')  # Linux专用

# 解决方案：使用os.path
import os
is_config = file_path.endswith(os.path.sep + 'config.ini')

# 危险：一次性读取大文件
with open('huge.log') as f:
    lines = f.readlines()  # 可能耗尽内存
    for line in lines:
        if line.startswith("ERROR:"):
            process_error(line)

# 解决方案：流式处理
with open('huge.log') as f:
    for line in f:
        if line.startswith("ERROR:"):
            process_error(line)