Python 민감 어 필터 링 을 위 한 4 가지 방법

우리 생활 속 의 일부 장소 에 서 는 나타 나 지 말 아야 할 민감 한 단어 가 자주 있 습 니 다.우 리 는 보통*를 사용 하여 그것 을 차단 합 니 다.예 를 들 어 니 마->**,일부 욕 하 는 민감 한 단어 와 일부 정치 민감 한 단 어 는 일부 공공장소 에 나타 나 서 는 안 됩 니 다.이 럴 때 우 리 는 일정한 수단 으로 이런 민감 한 단 어 를 차단 해 야 합 니 다.간단 한 버 전의 민감 한 단 어 를 차단 하 는 방법 을 소개 하 겠 습 니 다.
(나 는 이미 가능 한 한 욕 을 그림 의 형식 으로 만 들 었 다.그렇지 않 으 면 글 이 나 오지 않 는 다)
방법 1:replace 필터
replace 는 가장 간단 한 문자열 로 바 꿉 니 다.문자열 에 나타 날 수 있 는 민감 한 단어 가 있 을 때 저 희 는 해당 하 는 replace 방법 을 사용 하여 민감 한 단 어 를*로 바 꾸 면 됩 니 다.
단점:
텍스트 와 민감 어 는 적 을 때 는 괜 찮 고,많 을 때 는 효율 이 비교적 떨어진다.

import datetime
now = datetime.datetime.now()
print(filter_sentence, " | ", now)

여러 개의 민감 한 단어 라면 목록 으로 하나씩 바 꿀 수 있다.

for i in dirty:
 speak = speak.replace(i, '*')
print(speak, " | ", now)

방법 2:정규 표현 식 필터
정규 표현 식 은 좋 은 일치 방법 이 라 고 할 수 있 습 니 다.일상적인 조회 에서 기 회 는 정규 표현 식 을 사용 합 니 다.우리 의 파충 류 를 포함 하여 정규 표현 식 에 도 자주 사 용 됩 니 다.여기 서 우 리 는 주로'|'를 사용 하여 일치 합 니 다.'|'은 여러 대상 문자열 에서 하 나 를 선택 하여 일치 하 는 것 을 의미 합 니 다.간단 한 예 를 들다.

import re

def sentence_filter(keywords, text):
 return re.sub("|".join(keywords), "***", text)

print(sentence_filter(dirty, speak))

방법 3:DFA 여과 알고리즘
DFA 의 알고리즘,즉 Deterministic Finite Automation 알고리즘 을 중국어 로 번역 하면 가난 한 자동 동기 알고리즘 을 확인 하 는 것 입 니 다.그것 의 기본 사상 은 상태 이동 을 바탕 으로 민감 한 단 어 를 검색 하 는 것 이다.검 측 을 기다 리 는 텍스트 를 한 번 만 스 캔 하면 모든 민감 한 단 어 를 검 측 할 수 있다.(코드 설명 구현)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time：2020/4/15 11:40
# @Software：PyCharm
# article_add: https://www.cnblogs.com/JentZhang/p/12718092.html
__author__ = "JentZhang"
import json

MinMatchType = 1 #       
MaxMatchType = 2 #       


class DFAUtils(object):
 """
 DFA  
 """

 def __init__(self, word_warehouse):
  """
       
  :param word_warehouse:  
  """
  #   
  self.root = dict()
  #      ,         （                  ，               ）
  self.skip_root = [' ', '&', '!', '！', '@', '#', '$', '￥', '*', '^', '%', '?', '？', '<', '>', "《", '》']
  #      
  for word in word_warehouse:
   self.add_word(word)

 def add_word(self, word):
  """
      
  :param word:
  :return:
  """
  now_node = self.root
  word_count = len(word)
  for i in range(word_count):
   char_str = word[i]
   if char_str in now_node.keys():
    #      key，    ，         
    now_node = now_node.get(word[i])
    now_node['is_end'] = False
   else:
    #         dict
    new_node = dict()

    if i == word_count - 1: #     
     new_node['is_end'] = True
    else: #       
     new_node['is_end'] = False

    now_node[char_str] = new_node
    now_node = new_node

 def check_match_word(self, txt, begin_index, match_type=MinMatchType):
  """
                
  :param txt:      
  :param begin_index:   getSensitiveWord      ，        index
  :param match_type:     1：      ，2：      
  :return:    ，          ，     0
  """
  flag = False
  match_flag_length = 0 #        
  now_map = self.root
  tmp_flag = 0 #              

  for i in range(begin_index, len(txt)):
   word = txt[i]

   #          "
   if word in self.skip_root and len(now_map) < 100:
    # len(nowMap)<100                      
    tmp_flag += 1
    continue

   #     key
   now_map = now_map.get(word)
   if now_map: #   ，          
    #     key，    +1
    match_flag_length += 1
    tmp_flag += 1
    #            ，    ，       
    if now_map.get("is_end"):
     #       true
     flag = True
     #     ，    ,          
     if match_type == MinMatchType:
      break
   else: #    ，    
    break

  if tmp_flag < 2 or not flag: #         1，  
   tmp_flag = 0
  return tmp_flag

 def get_match_word(self, txt, match_type=MinMatchType):
  """
          
  :param txt:      
  :param match_type:     1：      ，2：      
  :return:        
  """
  matched_word_list = list()
  for i in range(len(txt)): # 0---11
   length = self.check_match_word(txt, i, match_type)
   if length > 0:
    word = txt[i:i + length]
    matched_word_list.append(word)
    # i = i + length - 1
  return matched_word_list

 def is_contain(self, txt, match_type=MinMatchType):
  """
              
  :param txt:      
  :param match_type:     1：      ，2：      
  :return:     true，    false
  """
  flag = False
  for i in range(len(txt)):
   match_flag = self.check_match_word(txt, i, match_type)
   if match_flag > 0:
    flag = True
  return flag

 def replace_match_word(self, txt, replace_char='*', match_type=MinMatchType):
  """
        
  :param txt:      
  :param replace_char:       ，             ， "     "，   "  "，    *，    "   **"
  :param match_type:     1：      ，2：      
  :return:           
  """
  tuple_set = self.get_match_word(txt, match_type)
  word_set = [i for i in tuple_set]
  result_txt = ""
  if len(word_set) > 0: #          ，         
   for word in word_set:
    replace_string = len(word) * replace_char
    txt = txt.replace(word, replace_string)
    result_txt = txt
  else: #         ，      
   result_txt = txt
  return result_txt


if __name__ == '__main__':
 dfa = DFAUtils(word_warehouse=word_warehouse)
 print('    ：', json.dumps(dfa.root, ensure_ascii=False))
 #       
 msg = msg
 print('    ：', dfa.is_contain(msg))
 print('     ：', dfa.get_match_word(msg))
 print('      ：', dfa.replace_match_word(msg))

방법 4:AC 자동 동기
AC 자동 동 기 는 선행 지식 이 필요 합 니 다.Trie 트 리(간단 한 소개:접두사 트 리,사전 트 리 라 고도 부 르 며 문자열 의 문 제 를 신속하게 처리 하고 문자열 의 정 보 를 신속하게 찾 을 수 있 습 니 다.)
자세 한 참조:
https://www.luogu.com.cn/blog/juruohyfhaha/trie-xue-xi-zong-jie
ac 자동 동 기 는 tire 트 리 를 바탕 으로 fail 지침 을 추가 하 는 것 입 니 다.현재 점 이 일치 하지 않 으 면 fail 지침 이 가리 키 는 곳 으로 지침 을 옮 깁 니 다.그러면 거 슬러 올 라 가지 않 고 길이 일치 할 수 있 습 니 다.
상세 한 일치 체 제 는 제 가 여기 서 긴 말 을 할 뿐 AC 자동 동기 에 대해 서 는 이 글 을 참고 할 수 있 습 니 다.
https://www.jb51.net/article/128711.htm
python 은 ahocorasick 모듈 을 이용 하여 빠르게 실현 할 수 있 습 니 다:

# python3 -m pip install pyahocorasick
import ahocorasick

def build_actree(wordlist):
 actree = ahocorasick.Automaton()
 for index, word in enumerate(wordlist):
  actree.add_word(word, (index, word))
 actree.make_automaton()
 return actree

if __name__ == '__main__':
 actree = build_actree(wordlist=wordlist)
 sent_cp = sent
 for i in actree.iter(sent):
  sent_cp = sent_cp.replace(i[1][1], "**")
  print("   ：",i[1][1])
 print("    ：",sent_cp)

물론 우 리 는 AC 자동 동 기 를 손 으로 쓸 수 있 고 구체 적 으로 참고 할 수 있다.

class TrieNode(object):
 __slots__ = ['value', 'next', 'fail', 'emit']

 def __init__(self, value):
  self.value = value
  self.next = dict()
  self.fail = None
  self.emit = None


class AhoCorasic(object):
 __slots__ = ['_root']

 def __init__(self, words):
  self._root = AhoCorasic._build_trie(words)

 @staticmethod
 def _build_trie(words):
  assert isinstance(words, list) and words
  root = TrieNode('root')
  for word in words:
   node = root
   for c in word:
    if c not in node.next:
     node.next[c] = TrieNode(c)
    node = node.next[c]
   if not node.emit:
    node.emit = {word}
   else:
    node.emit.add(word)
  queue = []
  queue.insert(0, (root, None))
  while len(queue) > 0:
   node_parent = queue.pop()
   curr, parent = node_parent[0], node_parent[1]
   for sub in curr.next.itervalues():
    queue.insert(0, (sub, curr))
   if parent is None:
    continue
   elif parent is root:
    curr.fail = root
   else:
    fail = parent.fail
    while fail and curr.value not in fail.next:
     fail = fail.fail
    if fail:
     curr.fail = fail.next[curr.value]
    else:
     curr.fail = root
  return root

 def search(self, s):
  seq_list = []
  node = self._root
  for i, c in enumerate(s):
   matched = True
   while c not in node.next:
    if not node.fail:
     matched = False
     node = self._root
     break
    node = node.fail
   if not matched:
    continue
   node = node.next[c]
   if node.emit:
    for _ in node.emit:
     from_index = i + 1 - len(_)
     match_info = (from_index, _)
     seq_list.append(match_info)
    node = self._root
  return seq_list


if __name__ == '__main__':
 aho = AhoCorasic(['foo', 'bar'])
 print aho.search('barfoothefoobarman')

이상 은 Python 을 사용 하여 민감 한 단 어 를 걸 러 내 는 네 가지 방법 입 니 다.앞의 두 가지 방법 은 비교적 간단 합 니 다.뒤의 두 가지 편향 알고리즘 은 먼저 알고리즘 이 구체 적 으로 실현 하 는 원 리 를 이해 한 다음 에 코드 를 알 아야 합 니 다.(DFA 는 비교적 자주 사용 되 는 여과 수단 으로 여러분 이 파악 하 시 기 를 권장 합 니 다~)
마지막 으로 민감 한 단어 라 이브 러 리 를 첨부 합 니 다.
https://github.com/qloog/sensitive_words
이상 은 Python 이 민감 한 단 어 를 걸 러 내 는 네 가지 방법 에 대한 상세 한 내용 입 니 다.python 민감 한 단어 여과 에 관 한 자 료 는 다른 관련 글 을 주목 하 십시오!