# 典型應(yīng)用場景
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

# 支持元組參數(shù)
is_image = filename.endswith(('.png', '.jpg', '.gif'))  # False
is_api = url.startswith(('http', 'https', 'ftp'))  # True

# 手動(dòng)切片檢查
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

# 轉(zhuǎn)換為統(tǒng)一大小寫
is_pdf = filename.lower().endswith('.pdf')  # True

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

import re

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

# 匹配日志級(jí)別
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'

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

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

# 匹配以數(shù)字開頭的字符串
num_start = re.match(r'^\d', "2023_report")  # True

# 匹配以標(biāo)點(diǎn)結(jié)尾的字符串
punct_end = re.search(r'[.!?]$', "Hello world!")  # True

# 多條件匹配
def is_valid_filename(name):
    # 以字母開頭，以擴(kuò)展名結(jié)尾
    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  # 標(biāo)記前綴結(jié)束
    
    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):
    """流式數(shù)據(jù)前綴匹配"""
    buffer = ""
    prefix_len = len(prefix)
    
    while True:
        chunk = stream.read(1024)  # 讀取1KB數(shù)據(jù)塊
        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:
            # 處理錯(cuò)誤日志
            process_error_log()

class FileTypeValidator:
    """文件類型驗(yàn)證器"""
    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):
        """驗(yàn)證文件類型"""
        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
        
        # 檢查文件擴(kuò)展名
        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):
        """添加路由規(guī)則"""
        self.routes.append((prefix, handler))
    
    def route(self, url):
        """路由分發(fā)"""
        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:
    """實(shí)時(shí)日志分析器"""
    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
        # 未知日志級(jí)別
        self.counters.setdefault('unknown', 0)
        self.counters['unknown'] += 1
    
    def handle_log(self, level, line):
        """處理特定級(jí)別的日志"""
        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())

# 預(yù)編譯常用模式
URL_PROTOCOL_PATTERN = re.compile(r'^(https?|ftp)://')
FILE_EXT_PATTERN = re.compile(r'\.(pdf|docx?|xlsx?)$')

# 使用預(yù)編譯模式
is_http = URL_PROTOCOL_PATTERN.match(url) is not None
is_pdf = FILE_EXT_PATTERN.search(filename) is not None

# 性能對(duì)比（100萬次調(diào)用）：
# 未編譯: 1.8秒
# 預(yù)編譯: 0.4秒

# 使用Cython編寫高性能匹配函數(shù)
# 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

# 編譯后調(diào)用
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):
        """檢查文本是否以任何后綴結(jié)尾"""
        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

# 高頻調(diào)用場景使用預(yù)編譯
URL_PREFIXES = ('http://', 'https://', 'ftp://')
if any(url.startswith(p) for p in URL_PREFIXES):
    process_url(url)

# 錯(cuò)誤：處理特殊Unicode字符
text = "café"
print(text.endswith("e"))  # False，因?yàn)楱κ菃蝹€(gè)字符

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

# 錯(cuò)誤：硬編碼路徑分隔符
is_config = file_path.endswith('/config.ini')  # Linux專用

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

# 危險(xiǎn)：一次性讀取大文件
with open('huge.log') as f:
    lines = f.readlines()  # 可能耗盡內(nèi)存
    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)