Python敏感词过滤案例如何过滤敏感词汇

wen python案例 2026-06-29 23

本文目录导读：

简单替换法（基础版）
正则表达式过滤法
字典树（Trie）过滤法（高效版）
使用第三方库：better_profanity
使用第三方库：filter.py
完整项目示例（带文件读取）
性能优化建议
使用建议
注意事项

我来为你介绍几种Python敏感词过滤的实现方法：

简单替换法（基础版）

def simple_filter(text, sensitive_words):
    """
    简单的敏感词替换
    """
    filtered_text = text
    for word in sensitive_words:
        filtered_text = filtered_text.replace(word, '*' * len(word))
    return filtered_text
# 使用示例
sensitive_words = ['敏感词1', '敏感词2', '违法内容']
text = "这是一个包含敏感词1和敏感词2的文本"
result = simple_filter(text, sensitive_words)
print(result)  # 这是一个包含***和***的文本

正则表达式过滤法

import re
def regex_filter(text, sensitive_words):
    """
    使用正则表达式过滤敏感词
    """
    pattern = '|'.join(re.escape(word) for word in sensitive_words)
    return re.sub(pattern, lambda x: '*' * len(x.group()), text)
# 使用示例
sensitive_words = ['敏感词', '违法', '违规']
text = "这段文本包含敏感词和违法内容"
result = regex_filter(text, sensitive_words)
print(result)  # 这段文本包含***和**内容

字典树（Trie）过滤法（高效版）

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_end = False
class SensitiveFilter:
    def __init__(self, sensitive_words):
        self.root = TrieNode()
        self.build_trie(sensitive_words)
    def build_trie(self, words):
        """构建字典树"""
        for word in words:
            node = self.root
            for char in word:
                if char not in node.children:
                    node.children[char] = TrieNode()
                node = node.children[char]
            node.is_end = True
    def filter(self, text, replace_char='*'):
        """过滤敏感词"""
        result = list(text)
        i = 0
        while i < len(text):
            node = self.root
            j = i
            # 尝试匹配敏感词
            while j < len(text) and text[j] in node.children:
                node = node.children[text[j]]
                j += 1
                if node.is_end:
                    # 找到敏感词，替换
                    for k in range(i, j):
                        result[k] = replace_char
                    break
            i += 1
        return ''.join(result)
# 使用示例
words = ['敏感词', '违法', '不良信息']
filter_obj = SensitiveFilter(words)
text = "这段内容包含敏感词和违法内容，请过滤不良信息"
result = filter_obj.filter(text)
print(result)  # 这段内容包含***和**内容，请过滤****

使用第三方库：`better_profanity`

# 首先安装：pip install better_profanity
from better_profanity import profanity
# 初始化
profanity.load_censor_words()
# 添加自定义敏感词
custom_words = ['敏感词1', '敏感词2']
profanity.add_censor_words(custom_words)
# 检查是否包含敏感词
text = "这是一个敏感词1的测试文本"
print(profanity.contains_profanity(text))  # True
# 过滤敏感词
print(profanity.censor(text))  # 这是一个***的测试文本

使用第三方库：`filter.py`

# 安装：pip install filter-py
from filter import Filter
# 初始化过滤器
filter_obj = Filter()
# 添加敏感词
filter_obj.add_words(['敏感词1', '敏感词2'])
# 过滤文本
text = "这段包含敏感词1和敏感词2"
result = filter_obj.filter(text)
print(result)  # 这段包含***和***
# 从文件加载敏感词列表
# filter_obj.add_from_file('sensitive_words.txt')

完整项目示例（带文件读取）

import re
from typing import List, Set
class SensitiveWordFilter:
    def __init__(self, word_list: List[str] = None):
        self.sensitive_words: Set[str] = set()
        if word_list:
            self.add_words(word_list)
    def add_words(self, words: List[str]):
        """添加敏感词"""
        self.sensitive_words.update(words)
    def add_from_file(self, file_path: str, encoding='utf-8'):
        """从文件读取敏感词"""
        try:
            with open(file_path, 'r', encoding=encoding) as f:
                for line in f:
                    word = line.strip()
                    if word and not word.startswith('#'):
                        self.sensitive_words.add(word)
        except FileNotFoundError:
            print(f"文件 {file_path} 不存在")
    def filter_text(self, text: str, replace_char='*', word_level=True) -> str:
        """
        过滤敏感词
        :param text: 待过滤文本
        :param replace_char: 替换字符
        :param word_level: 是否按词替换（True替换整个词，False逐字替换）
        """
        filtered = text
        for word in sorted(self.sensitive_words, key=len, reverse=True):
            if word_level:
                filtered = filtered.replace(word, replace_char * len(word))
            else:
                # 每个字单独替换
                for char in word:
                    filtered = filtered.replace(char, replace_char)
        return filtered
    def check_sensitive(self, text: str) -> List[str]:
        """检查文本中的敏感词"""
        found = []
        for word in self.sensitive_words:
            if word in text:
                found.append(word)
        return found
    def censor_text(self, text: str, replace_char='*') -> str:
        """更智能的过滤（保留标点符号）"""
        # 构建正则模式
        pattern = '|'.join(re.escape(word) for word in self.sensitive_words)
        return re.sub(pattern, lambda m: replace_char * len(m.group()), text)
# 使用示例
def main():
    # 初始化过滤器
    filter_obj = SensitiveWordFilter()
    # 添加敏感词
    filter_obj.add_words(['暴力', '色情', '赌博', '毒品'])
    # 从文件加载（如果有敏感词文件）
    # filter_obj.add_from_file('sensitive_words.txt')
    # 测试文本
    test_text = """
    这是一个正常的文章内容。
    但是包含了一些暴力内容，还有赌博信息。
    请大家自觉遵守规定。
    """
    # 检查敏感词
    sensitive_found = filter_obj.check_sensitive(test_text)
    if sensitive_found:
        print(f"发现敏感词: {sensitive_found}")
    # 过滤文本
    filtered_text = filter_obj.filter_text(test_text)
    print("过滤后:")
    print(filtered_text)
if __name__ == '__main__':
    main()

性能优化建议

# 高效的过滤方法（使用set和字符串方法）
def fast_filter(text: str, sensitive_words: List[str], replace_char='*') -> str:
    """
    快速过滤敏感词（适用于大量敏感词）
    """
    # 建立替换映射
    word_to_asterisks = {
        word: replace_char * len(word) 
        for word in sensitive_words
    }
    # 按长度排序，避免部分替换问题
    sorted_words = sorted(sensitive_words, key=len, reverse=True)
    # 逐词替换
    result = text
    for word in sorted_words:
        result = result.replace(word, word_to_asterisks[word])
    return result
# 使用生成器提高内存效率
def filter_generator(text: str, sensitive_words: List[str]):
    """使用生成器逐个字符处理"""
    i = 0
    while i < len(text):
        matched = False
        # 尝试匹配最长的敏感词
        for word in sorted(sensitive_words, key=len, reverse=True):
            if text[i:i+len(word)] == word:
                yield '*' * len(word)
                i += len(word)
                matched = True
                break
        if not matched:
            yield text[i]
            i += 1
# 使用示例
text = "测试文本包含敏感词1"
for chunk in filter_generator(text, ['敏感词1']):
    print(chunk, end='')