从基础到高级详解Python Shell通配符匹配技术的完整指南

# 典型应用场景
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")]
# 结果: ['data.csv']

# 匹配多个扩展名
data_files = [f for f in files if fnmatch.fnmatch(f, "data.*")]
# 结果: ['data.csv', 'data.txt']

# 默认区分大小写
fnmatch.fnmatch("file.txt", "*.txt")  # false

# 使用fnmatchcase进行大小写敏感匹配
fnmatch.fnmatchcase("file.txt", "*.txt")  # false

# 转换为小写进行不敏感匹配
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):
    """将通配符模式转换为正则表达式"""
    # 转义特殊字符
    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")
# 结果: '^log_202[0-9]_q\..txt$'

class wildcardmatcher:
    """高效通配符匹配引擎"""
    def __init__(self, patterns):
        self.patterns = patterns
        self.trie = self._build_trie()
    
    def _build_trie(self):
        """构建前缀树"""
        root = {}
        for pattern in self.patterns:
            node = root
            for char in pattern:
                if char == '*':
                    # 通配符节点
                    node.setdefault('*', {})
                    node = node['*']
                else:
                    node = node.setdefault(char, {})
            node['$'] = true  # 结束标记
        return root
    
    def match(self, text):
        """检查文本是否匹配任何模式"""
        return self._match_node(text, self.trie)
    
    def _match_node(self, text, node):
        """递归匹配节点"""
        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):
        """构建dfa状态机"""
        states = [{}]
        state = 0
        
        for char in self.pattern:
            if char == '*':
                # 通配符：添加自循环和前进
                states[state][char] = state
                states[state]['other'] = state + 1
                states.append({})
                state += 1
            else:
                # 普通字符：前进到新状态
                states[state][char] = state + 1
                states.append({})
                state += 1
        
        # 设置接受状态
        states[state]['accept'] = true
        return states
    
    def match(self, text):
        """匹配文本"""
        state = 0
        for char in text:
            if state >= len(self.dfa):
                return false
            
            # 检查通配符转换
            if '*' in self.dfa[state]:
                # 通配符状态可以消耗任意字符
                state = self.dfa[state].get(char, self.dfa[state]['other'])
            elif char in self.dfa[state]:
                state = self.dfa[state][char]
            else:
                return false
        
        # 检查是否在接受状态
        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数据块
        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:
    """基于通配符的文件备份系统"""
    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):
        """执行备份操作"""
        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):
                # 构建目标路径
                rel_path = os.path.relpath(filepath, source_dir)
                target_path = os.path.join(rule['target'], rel_path)
                
                # 创建目录并复制文件
                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:
    """基于通配符的日志分析系统"""
    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"发现错误: {report['total_errors']} 条")

class configmanager:
    """基于通配符的配置管理系统"""
    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")
# 获取所有数据库相关配置
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万次调用）：
# fnmatch.fnmatch: 2.3秒
# 预编译模式: 0.8秒

# 使用cython编写高性能匹配函数
# 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

# 编译后调用
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结尾
if fnmatch.fnmatch(filename, "*.txt") and filename.endswith(".txt"):

# 转义特殊字符
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系统失败

# 解决方案：使用os.path
import os
pattern = os.path.join("c:", "data", "*.csv")

# 错误：无法匹配以点开头的文件
fnmatch.fnmatch(".hidden", "*")  # false

# 解决方案：显式包含点文件
fnmatch.fnmatch(".hidden", ".*")  # true

# 危险：大目录递归匹配
find_files("/", "*.log")  # 可能遍历整个文件系统

# 解决方案：添加深度限制
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