[PYTHON] Créez un bot qui stimule les tendances Twitter

Avez-vous un moment où vous souhaitez booster la tendance Twitter?

Dans un tel cas, créons un Bot qui tweete automatiquement en générant des phrases à partir d'une balise spécifique en Python.

Cette fois, je vais omettre la partie de la récupération de phrases sur Twitter et la création de phrases. De plus, je l'ai mis à jour environ 3 fois, Le tout premier est facile, je vais donc l'expliquer.

Effectuer une analyse de syntaxe

Tout d'abord, nous devons extraire la nomenclature du japonais. Cette fois, nous utiliserons une bibliothèque d'analyse syntaxique appelée janome.

janome est un outil qui décompose le japonais en syntaxe

from janome.tokenizer import Tokenizer

tokenizer = Tokenizer()

sentence = 'L'invité d'aujourd'hui était M. Wada.'

for token in tokenizer.tokenize(sentence):
    print(token)
    
#Nom du jour,Avocat possible,*,*,*,*,aujourd'hui,Hongjitsu,Hongjitsu
#Mots auxiliaires,syndicat,*,*,*,*,de,Non,Non
#Nomenclature des invités,Général,*,*,*,*,Les invités,Les invités,Les invités
#Est un assistant,Assistance,*,*,*,*,Est,C,sensationnel
#Wada substantif,Nomenclature propriétaire,Nom d'une personne,Nom de famille,*,*,Wada,Wada,Wada
#San substantif,suffixe,Nom d'une personne,*,*,*,M.,Soleil,Soleil
#Deshi verbe auxiliaire,*,*,*,Mort spéciale,Type continu,est,Deci,Deci
#Verbe auxiliaire,*,*,*,Spécial,Forme basique,Ta,Ta,Ta
#.. symbole,Phrase,*,*,*,*,。,。,。

Il décompose le japonais comme ça.

Rechercher les doublons

Vous pouvez décomposer un tweet avec cela, mais cela peut provoquer du bruit.

Par conséquent, ne faites une phrase que lorsque la même nomenclature existe dans plusieurs tweets.

Certaines personnes aiment ça.

Tout d'abord, il existe une classe pour l'extraction des doublons.

class DuplicateChecker:
    
    def __init__(self, tokenier: Tokenizer):
        self.twitt_nouns = []
        self.tokenier = tokenier

    def extract_duplications(self) -> [str]:
        return [x for x in set(self.twitt_nouns) if self.twitt_nouns.count(x) > 1]

    def input_twitt(self, twitt: str):
        tokens = self.tokenier.tokenize(twitt)
        
        nouns = []
        buffer = None
        for token in tokens:
            if token.part_of_speech.count("nom"):
                if buffer is None: 
                    buffer = ""
                buffer += token.surface
            else:
                if buffer is not None:
                    nouns.append(buffer)
                buffer = None
                    
                    
        self.twitt_nouns.extend(nouns)

Maintenant, lorsque je vérifie les doublons, cela ressemble à ceci:

tokenier = Tokenizer()
duplicateChecker = DuplicateChecker(tokenier)

duplicateChecker.input_twitt("J'ai senti la possibilité du motif rayé")
duplicateChecker.input_twitt('Je sens seulement la possibilité')
duplicateChecker.input_twitt('Ressentez la possibilité')

nouns = duplicateChecker.extract_duplications()
nouns # ["possibilité"]

(La production a également été vérifiée par l'utilisateur.)

Génération de déclaration

Faites une phrase à partir de la dernière nomenclature extraite. (Cette fois est appropriée.)

class SentenceGenerator:
    
    def __init__(self, nouns:[str]):
        self.nouns = nouns
        self.senence_base = ["{}Est de l'herbe", "{}important", "{}", "{}Hey", "{}だHey", "{}!"]
        
    def generate(self) -> str:
        index:int = int(random.uniform(0, 200)) % len(self.senence_base)
        sentence = self.senence_base[index].format(self.nouns[0])
        return sentence

Une fois exécuté, cela ressemble à ceci.

Résumé

Cette fois, j'ai essayé de faire quelque chose d'une simplicité déraisonnable. S'il y a une réponse, j'écrirai comment je l'ai mise à jour.