Python unerfahrene Person versucht, 100 Sprachverarbeitung 05-06 zu klopfen

Dies ist eine Fortsetzung davon.

Python unerfahrene Person versucht, 100 Sprachverarbeitung 00-04 zu klopfen https://qiita.com/earlgrey914/items/fe1d326880af83d37b22

Klicken Sie hier für mehr Python unerfahrene Person versucht, 100 Sprachverarbeitung 07-09 zu klopfen https://qiita.com/earlgrey914/items/a7b6781037bc0844744b

5. n-gram

Erstellen Sie eine Funktion, die aus einer bestimmten Sequenz (Zeichenfolge, Liste usw.) ein n-Gramm erstellt. Verwenden Sie diese Funktion, um das Wort Bi-Gramm und den Buchstaben Bi-Gramm aus dem Satz "Ich bin ein NLPer" zu erhalten.

Ich frage mich, was n-Gramm ist ... Ich habe etwas darüber gehört. Sie können dieses Problem nur lösen, wenn Sie etwas über n-Gramm verstehen! Zuerst von dort! !!

~ 2 Minuten gegoogelt ~

N-Gramm ist eine Methode zum Ausschneiden von Wörtern in natürlicher Sprache (Text) in Einheiten von N aufeinanderfolgenden Zeichen oder N Wörtern.

Referenz
https://www.pytry3g.com/entry/N-gram

~~ Ich verstehe. ~~ ~~ Wenn dann 1 übergeben wird, wird es durch ein Zeichen getrennt, und wenn 2 übergeben wird, wird es durch 2 Zeichen getrennt. ~~ ~~ Wort-Bi-Gramm ist ein wortweises Trennzeichen mit 2 Zeichen ~~ ~~ Ich frage mich, ob das Zeichen-Bi-Gramm durch zwei Zeichen in Zeicheneinheiten getrennt werden soll. ~~ ~~ Die Antwort lautet also ~~ ~~ ■ Wort-Bi-Gramm ~~ ~~["I", "am", "an", "NL", "Pe", "r"]~~ ~~ ■ Zeichen-Bi-Gramm ~~ ~~["I ","ma","an","NL","Pe","r"]~~

Soll ich ~~ ausgeben? Es tut mir leid, wenn ich einen Fehler mache. Ich werde es unter dieser Voraussetzung lösen. ~~

Da es normalerweise falsch war, warf ich einen Blick auf das Ausgabeergebnis der Antwort.

[['I', 'am'], ['am', 'an'], ['an', 'NLPer']]
['I ', ' a', 'am', 'm ', ' a', 'an', 'n ', ' N', 'NL', 'LP', 'Pe', 'er']

Es scheint in Ordnung zu sein, wenn es so ausgegeben wird. Das war's.

Wir. Vorerst wurde das Wort Bigram geschaffen.

enshu05.py

s = "I am an NLPer"

tango_bigram= []

def bigram(s):
    counter = 0
    list = s.split()

    for i in list:
        if counter < len(list)-1:
            tango_bigram.extend([[list[counter],list[counter+1]]])
            counter += 1
            
    return tango_bigram

print(bigram(s))

[['I', 'am'], ['am', 'an'], ['an', 'NLPer']]

Wie Sie vielleicht hier bemerkt haben, sah ich verschiedene Teile, die nicht zum Schreiben des Codes geeignet waren.

--Variable Benennung ist zu angemessen. Englisch und Japanisch sind gemischt, einige verwenden einstellige Variablen wie "s" und "i" und einige verwenden Variablennamen wie "counter". ――Hier wird es als "Tango_Bigramm" geschrieben, was ein Schlangenfall ist, aber vor (Übung 4) wird es als "IchimoziList" im Kamelfall geschrieben und ist unzusammenhängend.

• Die Zeilenvorschubregel ist ein Rätsel. Die Regel, einen Raum mit halber Breite zu platzieren, ist ein Rätsel.

Ich möchte es in Zukunft reparieren, aber ich schließe immer noch meine Augen. Ich schreibe nur alleine. Nun, irgendwann muss der Code, den ich geschrieben habe, von mir selbst als "Ich kann ihn nicht sehen" korrigiert werden.

In der vorherigen Übung haben wir "append ()" verwendet, um die Liste zu erweitern, aber hier haben wir "extens ()" verwendet. Wenn Sie mehrere Elemente gleichzeitig in die Liste aufnehmen möchten, können Sie "extens ()" verwenden. Es scheint eine Notation zu geben, die "+ =" verwendet, wie "l + = [1, 2, 3]", aber der Eindruck ist, dass "expand ()" leichter zu verstehen ist.

Referenz-URL
https://qiita.com/tag1216/items/416314cc75a099ad6149

damit, Ich habe auch den Charakter Bigram mit einem ähnlichen Gefühl geschrieben.

enshu05.py

s = "I am an NLPer"

tango_bigram= []
moji_bigram = []

def bigram(s):
    tango_counter = 0
    moji_counter = 0
    
    #Textverarbeitung
    list = s.split()
    for i in list:
        if tango_counter < len(list)-1:
            tango_bigram.extend([[list[tango_counter],list[tango_counter+1]]])
            tango_counter += 1

    #Zeichengrammverarbeitung
    for i in s:
        if moji_counter < len(s)-1:
            moji_bigram.append(s[moji_counter] + s[moji_counter+1])
            moji_counter += 1
    return tango_bigram,moji_bigram

print(bigram(s))

([['I', 'am'], ['am', 'an'], ['an', 'NLPer']], ['I ', ' a', 'am', 'm ', ' a', 'an', 'n ', ' N', 'NL', 'LP', 'Pe', 'er'])

Lesbarkeit ist Müll! !! !! Nun nein. ** Pythons Konvention, dass "Funktionen über der Verarbeitung von Funktionsaufrufen geschrieben werden müssen"? Ich bin nicht daran gewöhnt ... **

** Persönlich ist Python dynamisch typisiert und aufgrund eingerückter Blocktrennzeichen. Ich habe den Eindruck, dass es leicht zu schreiben, aber schwer zu lesen ist. ** ** ** Vielleicht liegt es daran, dass ich es gewohnt bin, Trennzeichen mit {}} in statisch typisierten Sprachen wie Java zu blockieren ... Java ist auch deutlich weniger lesbar, wenn der Einzug angemessen ist.

Eine kurze Pause

Gibt es eine Möglichkeit, einen guten Variablennamen anzugeben? Als ich es gegoogelt habe, gab es einen Artikel wie diesen.
Referenz-URL
https://qiita.com/Ted-HM/items/7dde25dcffae4cdc7923

06. Treffen

Suchen Sie den in "paraparaparadise" und "Absatz" enthaltenen Satz von Zeichen-Bi-Gramm als X bzw. Y und suchen Sie den Summensatz, den Produktsatz und den Differenzsatz von X bzw. Y. Finden Sie außerdem heraus, ob das Bi-Gramm in X und Y enthalten ist.

** Irgendwie ist Japanisch schwierig. ** ** ** Ich weiß es vorerst. Das Dekodieren von Japanisch ist vor dem Programm schwierig.

In dem Moment, als ich dieses Problem sah, dachte ich: "Eh? Ein Set? Kann ich eine Bibliothek importieren und verwenden, die solche Dinge berechnen kann?" Das N-Gramm, das ich zuvor erwähnt habe, ist auch eine Bibliothek, nicht wahr?

Der Autor ist der Meinung, dass ** "Sie müssen es selbst machen" "das ist, woran nur Sie denken können" ** in der Welt. Wenn also jemand etwas gemacht hat, sollten Sie es verwenden. ing.

Diesmal ist der Zweck jedoch ** Lernen **, also werde ich es selbst machen.

Es ist einfach, zwei String-Bigrams zu erhalten, indem Sie die Bigram-Funktion in Übung 05 ein wenig optimieren. (Der Umfang der bigram Funktion und moji_bigram war unvernünftig, also habe ich es behoben.)

para.py

str_paradise = "paraparaparadise"
str_paragraph = "paragraph"

def bigram(s):

    moji_bigram = []
    moji_counter = 0

    #Zeichengrammverarbeitung
    for i in s:
        if moji_counter < len(s)-1:
            moji_bigram.append(s[moji_counter]+s[moji_counter+1])
            moji_counter += 1

    return moji_bigram

print(bigram(str_paradise))
print(bigram(str_paragraph))

['pa', 'ar', 'ra', 'ap', 'pa', 'ar', 'ra', 'ap', 'pa', 'ar', 'ra', 'ad', 'di', 'is', 'se']
['pa', 'ar', 'ra', 'ag', 'gr', 'ra', 'ap', 'ph']

Wie finden Sie das Set? Wenn Sie es entsprechend googeln, wie "Python-Set-Berechnung" Es scheint, dass Sie einen festgelegten Typ anstelle eines Listentyps verwenden sollten.

str_paradise = "paraparaparadise"
str_paragraph = "paragraph"

#Eine Funktion, die eine Liste mit großen Zeichen zurückgibt
def bigram(s):
    moji_bigram = []
    moji_counter = 0

    for i in s:
        if moji_counter < len(s)-1:
            moji_bigram.append(s[moji_counter]+s[moji_counter+1])
            moji_counter += 1

    return moji_bigram

#Eine Funktion, die eine Liste in eine Menge konvertiert
def listToSet(list):
    moji_bigram_set = {}
    moji_bigram_set = set(list)
    return moji_bigram_set

#Erstellen Sie eine Liste von Bigram
str_paradise_list = bigram(str_paradise)
str_paragraph_list = bigram(str_paragraph)

#Konvertieren Sie die Bigram-Liste, um Duplikate festzulegen und zu entfernen
paradise_set_X = listToSet(str_paradise_list)
paragraph_set_Y = listToSet(str_paragraph_list)

print("paradise_set_X")
print(paradise_set_X)
print("paragraph_set_Y")
print(paragraph_set_Y)

print("Summensatz")
print(paradise_set_X | paragraph_set_Y)

print("Produktset")
print(paradise_set_X & paragraph_set_Y)

print("Differenz gesetzt")
print(paradise_set_X - paragraph_set_Y)

paradise_set_X
{'ap', 'ar', 'pa', 'di', 'is', 'ra', 'se', 'ad'}
paragraph_set_Y
{'ap', 'ar', 'pa', 'ph', 'ag', 'ra', 'gr'}
Summensatz
{'ap', 'ar', 'gr', 'pa', 'di', 'ph', 'is', 'ag', 'ra', 'se', 'ad'}
Produktset
{'ra', 'pa', 'ap', 'ar'}
Differenz gesetzt
{'is', 'di', 'se', 'ad'}