# 典型應用場景
files = ["report_2023_Q1.pdf", "report_2023_Q2.pdf", "summary_2023.txt"]
# 匹配所有季度報告文件：report_2023_Q*.pdf

import fnmatch

# 簡單匹配
files = ["data.csv", "data.txt", "config.ini", "image.png"]
csv_files = [f for f in files if fnmatch.fnmatch(f, "*.csv")]
# 結(jié)果: ['data.csv']

# 匹配多個擴展名
data_files = [f for f in files if fnmatch.fnmatch(f, "data.*")]
# 結(jié)果: ['data.csv', 'data.txt']

# 默認區(qū)分大小寫
fnmatch.fnmatch("File.TXT", "*.txt")  # False

# 使用fnmatchcase進行大小寫敏感匹配
fnmatch.fnmatchcase("File.TXT", "*.txt")  # False

# 轉(zhuǎn)換為小寫進行不敏感匹配
pattern = "*.txt".lower()
fnmatch.fnmatch("File.TXT".lower(), pattern)  # True

# 匹配多個模式
patterns = ["*.jpg", "*.png", "*.gif"]
image_files = [f for f in files if any(fnmatch.fnmatch(f, p) for p in patterns)]

# 更高效的方法
from itertools import filterfalse
image_files = list(filterfalse(lambda f: not any(fnmatch.fnmatch(f, p) for p in patterns), files))

import os

def find_files(root, pattern):
    """遞歸查找匹配文件"""
    matches = []
    for dirpath, _, filenames in os.walk(root):
        for filename in fnmatch.filter(filenames, pattern):
            matches.append(os.path.join(dirpath, filename))
    return matches

# 查找所有Python文件
python_files = find_files("/projects", "*.py")

import re

def wildcard_to_regex(pattern):
    """將通配符模式轉(zhuǎn)換為正則表達式"""
    # 轉(zhuǎn)義特殊字符
    pattern = re.escape(pattern)
    # 替換通配符
    pattern = pattern.replace(r'\*', '.*')
    pattern = pattern.replace(r'\?', '.')
    pattern = pattern.replace(r'\[!', '[^')
    pattern = pattern.replace(r'\[', '[')
    pattern = pattern.replace(r'\]', ']')
    return f'^{pattern}$'

# 使用示例
regex_pattern = wildcard_to_regex("log_202[0-9]_Q?.txt")
# 結(jié)果: '^log_202[0-9]_Q\..txt$'

class WildcardMatcher:
    """高效通配符匹配引擎"""
    def __init__(self, patterns):
        self.patterns = patterns
        self.trie = self._build_trie()
    
    def _build_trie(self):
        """構(gòu)建前綴樹"""
        root = {}
        for pattern in self.patterns:
            node = root
            for char in pattern:
                if char == '*':
                    # 通配符節(jié)點
                    node.setdefault('*', {})
                    node = node['*']
                else:
                    node = node.setdefault(char, {})
            node['$'] = True  # 結(jié)束標記
        return root
    
    def match(self, text):
        """檢查文本是否匹配任何模式"""
        return self._match_node(text, self.trie)
    
    def _match_node(self, text, node):
        """遞歸匹配節(jié)點"""
        if not text:
            return '$' in node
        
        char = text[0]
        rest = text[1:]
        
        # 處理通配符
        if '*' in node:
            # 嘗試跳過0個或多個字符
            if self._match_node(text, node['*']):
                return True
            if self._match_node(rest, node['*']):
                return True
        
        # 精確匹配
        if char in node:
            return self._match_node(rest, node[char])
        
        return False

# 使用示例
matcher = WildcardMatcher(["*.jpg", "image_*.png"])
print(matcher.match("photo.jpg"))  # True
print(matcher.match("image_123.png"))  # True

class WildcardDFA:
    """基于DFA的通配符匹配引擎"""
    def __init__(self, pattern):
        self.pattern = pattern
        self.dfa = self._build_dfa()
    
    def _build_dfa(self):
        """構(gòu)建DFA狀態(tài)機"""
        states = [{}]
        state = 0
        
        for char in self.pattern:
            if char == '*':
                # 通配符：添加自循環(huán)和前進
                states[state][char] = state
                states[state]['other'] = state + 1
                states.append({})
                state += 1
            else:
                # 普通字符：前進到新狀態(tài)
                states[state][char] = state + 1
                states.append({})
                state += 1
        
        # 設置接受狀態(tài)
        states[state]['accept'] = True
        return states
    
    def match(self, text):
        """匹配文本"""
        state = 0
        for char in text:
            if state >= len(self.dfa):
                return False
            
            # 檢查通配符轉(zhuǎn)換
            if '*' in self.dfa[state]:
                # 通配符狀態(tài)可以消耗任意字符
                state = self.dfa[state].get(char, self.dfa[state]['other'])
            elif char in self.dfa[state]:
                state = self.dfa[state][char]
            else:
                return False
        
        # 檢查是否在接受狀態(tài)
        return state == len(self.dfa) - 1 and 'accept' in self.dfa[state]

# 使用示例
dfa_matcher = WildcardDFA("file_*.txt")
print(dfa_matcher.match("file_report.txt"))  # True

def stream_wildcard_matcher(stream, pattern):
    """流式通配符匹配生成器"""
    buffer = ""
    pattern_len = len(pattern)
    star_positions = [i for i, c in enumerate(pattern) if c == '*']
    
    while True:
        chunk = stream.read(1024)  # 讀取1KB數(shù)據(jù)塊
        if not chunk:
            break
        
        buffer += chunk
        while len(buffer) >= pattern_len:
            # 嘗試匹配
            if fnmatch.fnmatch(buffer[:pattern_len], pattern):
                yield buffer[:pattern_len]
                buffer = buffer[pattern_len:]
            else:
                # 沒有匹配，移動一個字符
                buffer = buffer[1:]

# 使用示例
with open('large_log.txt', 'r') as f:
    for match in stream_wildcard_matcher(f, "ERROR: *"):
        print(f"Found error: {match}")

class BackupSystem:
    """基于通配符的文件備份系統(tǒng)"""
    def __init__(self, rules):
        """
        rules: [
            {'source': '/var/log/*.log', 'target': '/backup/logs'},
            {'source': '/home/*/docs/*.docx', 'target': '/backup/docs'}
        ]
        """
        self.rules = rules
    
    def run_backup(self):
        """執(zhí)行備份操作"""
        for rule in self.rules:
            source_dir, pattern = os.path.split(rule['source'])
            if not source_dir:
                source_dir = '.'  # 當前目錄
            
            # 查找匹配文件
            for filepath in find_files(source_dir, pattern):
                # 構(gòu)建目標路徑
                rel_path = os.path.relpath(filepath, source_dir)
                target_path = os.path.join(rule['target'], rel_path)
                
                # 創(chuàng)建目錄并復制文件
                os.makedirs(os.path.dirname(target_path), exist_ok=True)
                shutil.copy2(filepath, target_path)
                print(f"Backed up: {filepath} -> {target_path}")

# 使用示例
backup_rules = [
    {'source': '/var/log/*.log', 'target': '/backup/logs'},
    {'source': '/home/*/docs/*.docx', 'target': '/backup/docs'}
]
backup_system = BackupSystem(backup_rules)
backup_system.run_backup()

class LogAnalyzer:
    """基于通配符的日志分析系統(tǒng)"""
    def __init__(self, log_dir):
        self.log_dir = log_dir
        self.patterns = {
            'error': "ERROR: *",
            'warning': "WARN*",
            'database': "*DB*"
        }
    
    def analyze_logs(self):
        """分析日志文件"""
        results = defaultdict(list)
        
        # 查找所有日志文件
        log_files = find_files(self.log_dir, "*.log")
        
        for log_file in log_files:
            with open(log_file, 'r') as f:
                for line in f:
                    line = line.strip()
                    for category, pattern in self.patterns.items():
                        if fnmatch.fnmatch(line, pattern):
                            results[category].append(line)
        
        # 生成報告
        report = {
            'total_errors': len(results['error']),
            'total_warnings': len(results['warning']),
            'database_events': len(results['database'])
        }
        return report

# 使用示例
analyzer = LogAnalyzer("/var/log/app")
report = analyzer.analyze_logs()
print(f"發(fā)現(xiàn)錯誤: {report['total_errors']} 條")

class ConfigManager:
    """基于通配符的配置管理系統(tǒng)"""
    def __init__(self, config_dir):
        self.config_dir = config_dir
        self.configs = self.load_configs()
    
    def load_configs(self):
        """加載所有配置文件"""
        configs = {}
        config_files = find_files(self.config_dir, "*.cfg")
        
        for file in config_files:
            with open(file, 'r') as f:
                configs[file] = self.parse_config(f)
        
        return configs
    
    def parse_config(self, file_obj):
        """解析配置文件"""
        config = {}
        for line in file_obj:
            line = line.strip()
            if not line or line.startswith('#'):
                continue
            key, value = line.split('=', 1)
            config[key.strip()] = value.strip()
        return config
    
    def get_config(self, pattern):
        """獲取匹配配置項"""
        result = {}
        for path, config in self.configs.items():
            if fnmatch.fnmatch(path, pattern):
                result.update(config)
        return result

# 使用示例
manager = ConfigManager("/etc/app_config")
# 獲取所有數(shù)據(jù)庫相關(guān)配置
db_config = manager.get_config("*/db_*.cfg")

class PatternMatcher:
    """預編譯模式匹配器"""
    def __init__(self, patterns):
        self.patterns = patterns
        self.regexes = [re.compile(fnmatch.translate(p)) for p in patterns]
    
    def match(self, text):
        """匹配文本"""
        for regex in self.regexes:
            if regex.match(text):
                return True
        return False

# 使用示例
matcher = PatternMatcher(["*.jpg", "*.png", "*.gif"])
print(matcher.match("image.png"))  # True

# 性能對比（100萬次調(diào)用）：
# fnmatch.fnmatch: 2.3秒
# 預編譯模式: 0.8秒

# 使用Cython編寫高性能匹配函數(shù)
# wildmatch.pyx
def cython_fnmatch(text, pattern):
    cdef int i = 0, j = 0, text_len = len(text), pattern_len = len(pattern)
    cdef int star = -1, mark = -1
    
    while i < text_len:
        if j < pattern_len and pattern[j] == '*':
            star = j
            mark = i
            j += 1
        elif j < pattern_len and (pattern[j] == '?' or pattern[j] == text[i]):
            i += 1
            j += 1
        elif star != -1:
            j = star + 1
            mark += 1
            i = mark
        else:
            return False
    
    while j < pattern_len and pattern[j] == '*':
        j += 1
    
    return j == pattern_len

# 編譯后調(diào)用
from wildmatch import cython_fnmatch
result = cython_fnmatch("file.txt", "*.txt")  # True

from concurrent.futures import ThreadPoolExecutor
import os

def parallel_find_files(root, pattern, workers=4):
    """并行查找匹配文件"""
    all_files = []
    for dirpath, _, filenames in os.walk(root):
        all_files.extend(os.path.join(dirpath, f) for f in filenames)
    
    # 分塊處理
    chunk_size = (len(all_files) + workers - 1) // workers
    chunks = [all_files[i:i+chunk_size] for i in range(0, len(all_files), chunk_size)]
    
    results = []
    with ThreadPoolExecutor(max_workers=workers) as executor:
        futures = []
        for chunk in chunks:
            futures.append(executor.submit(
                lambda files, pat: [f for f in files if fnmatch.fnmatch(os.path.basename(f), pat)],
                chunk, pattern
            ))
        
        for future in futures:
            results.extend(future.result())
    
    return results

# 使用示例
large_dir = "/data"
image_files = parallel_find_files(large_dir, "*.jpg", workers=8)

# 精確匹配文件擴展名
# 錯誤：可能匹配到file.txt.bak
if fnmatch.fnmatch(filename, "*.txt"):

# 正確：確保以.txt結(jié)尾
if fnmatch.fnmatch(filename, "*.txt") and filename.endswith(".txt"):

# 轉(zhuǎn)義特殊字符
def escape_wildcard(pattern):
    return pattern.replace("[", "[[]").replace("?", "[?]")

# 匹配包含通配符的文件名
pattern = escape_wildcard("file[1].txt")

# 高頻匹配場景使用預編譯
image_patterns = ["*.jpg", "*.png", "*.gif"]
image_matcher = PatternMatcher(image_patterns)

# 錯誤：Windows路徑使用反斜杠
pattern = "C:\\Data\\*.csv"  # 在Unix系統(tǒng)失敗

# 解決方案：使用os.path
import os
pattern = os.path.join("C:", "Data", "*.csv")

# 錯誤：無法匹配以點開頭的文件
fnmatch.fnmatch(".hidden", "*")  # False

# 解決方案：顯式包含點文件
fnmatch.fnmatch(".hidden", ".*")  # True

# 危險：大目錄遞歸匹配
find_files("/", "*.log")  # 可能遍歷整個文件系統(tǒng)

# 解決方案：添加深度限制
def safe_find_files(root, pattern, max_depth=5):
    matches = []
    for dirpath, dirnames, filenames in os.walk(root):
        # 計算當前深度
        depth = dirpath[len(root):].count(os.sep)
        if depth > max_depth:
            del dirnames[:]  # 跳過子目錄
            continue
        
        for filename in fnmatch.filter(filenames, pattern):
            matches.append(os.path.join(dirpath, filename))
    return matches