J'ai écrit une classe qui facilite l'écriture en spécifiant les paroles de la partie lors de l'utilisation de Mecab avec python

Lorsque j'utilise mecab avec python, je dois le réécrire de différentes manières lorsque je veux spécifier les paroles de la partie et écrire librement, alors j'ai écrit la classe moi-même pour éliminer les inconvénients, je vais donc la publier.

import MeCab
import unicodedata
import re


class MecabParser():
    def __init__(self, word_classes=None, word_class_details=None):
        """
        Args:
            word_classes (list, optional):Désigner les paroles des parties en japonais. Defaults to None.
            word_class_details (list, optional):Spécifier les détails des paroles de la partie. Defaults to None.

Voir ci-dessous les mots de pièces définis par mecab
        https://taku910.github.io/mecab/posid.html
        """
        self._word_classes = word_classes
        self._word_class_details = word_class_details

    def _format_text(self, text):
        """
Formatage du texte avant de le mettre dans MeCab
        """
        text = re.sub(r'http(s)?://[\w/:%#\$&\?\(\)~\.=\+\-…]+', "", text)
        text = re.sub(r'[ -/:-@\[-~_]', "", text)  #Symbole demi-largeur
        text = re.sub(r'[︰-＠]', "", text)  #Symbole pleine largeur
        text = re.sub(r'\d', "", text)  #Nombres
        text = re.sub('\n', " ", text)  #Caractère de rupture
        text = re.sub('\r', " ", text)  #Caractère de rupture

        return text

    def parse(self, text, is_base=False):
        text = self._format_text(text)

        #Processus de conversion de code de caractère. S'il n'est pas converti, le point trouble et le point semi-trouble seront séparés.
        text = unicodedata.normalize('NFC', text)

        result = []
        tagger = MeCab.Tagger(
            '-d /usr/local/lib/mecab/dic/mecab-ipadic-neologd')
        #Vous pouvez éviter les erreurs de lecture de surface en analysant une fois avant parseToNode
        tagger.parse('')

        nodes = tagger.parseToNode(text)
        while nodes:
            wclass = nodes.feature.split(',')
            #Si aucune partie n'est spécifiée, tout sera séparé
            if not self._word_classes:
                result.append(wclass[6] if is_base else nodes.surface)
                nodes = nodes.next
                continue

            #Si les paroles des parties ne sont pas spécifiées, toutes les parties sont séparées.
            if not self._word_class_details:
                if wclass[0] in self._word_classes:
                    result.append(wclass[6] if is_base else nodes.surface)
                    nodes = nodes.next
                    continue

            #Séparé selon les spécifications détaillées des paroles de la partie
            if wclass[0] in self._word_classes and wclass[1] in self._word_class_details:
                result.append(wclass[6] if is_base else nodes.surface)
            nodes = nodes.next

        #Supprimer les premières et dernières chaînes vides
        if len(result) > 0:
            result.pop(0)
            result.pop(-1)

        return result

Je sauvegarde ceci dans un fichier appelé parser.py et je l'utilise. Le sentiment d'utilisation est le suivant, et il est relativement facile de diviser les mots en spécifiant la partie.

>>> from parser import MecabParser
>>> mp =  MecabParser(word_classes=['nom'], word_class_details=['Général','固有nom'])
>>> text = 'J'ai faim aujourd'hui, alors je suis venu manger l'un des meilleurs ramen du quartier.'
>>> mp.parse(text)
['estomac', 'quartier', 'Un article au monde', 'ramen']

Le dictionnaire utilise mecab-ipadic-neologd, les mots avec des fins modifiées sont restaurés dans leur forme d'origine et le texte est formaté à l'avance, donc j'espère que l'utilisateur pourra le modifier à son goût. pense.