Ich werde jede Funktion so detailliert schreiben, dass sie stirbt. Ich werde auch schreiben, welche Art von Idee zu einem solchen Code geführt hat: Faust:
str = "stressed"
reverse_str = str[::-1]
print(reverse_str)
Kommentar Das Wissen über "Slices" wird bei diesem Problem verwendet. Slice ist ein Mechanismus, der einen Teil einer Sequenz (Zeichenfolge, Liste, Tapple usw.) ausschneidet und eine Kopie zurückgibt.
str[n] #Extrahieren Sie das n-te Zeichen von str
str[start:stop:step]
#start...Von welcher Nummer?
#stop...Endpunkt(+Geben wir einen Wert von 1 an!)
#step...Wie viele Stücke überspringst du?
str = "Patatoku Kashii"
print(str[1::2])
Kommentar: Sie können das in 00 erhaltene Slice-Wissen verwenden. str [Vom ersten Zeichen: (Da es leer ist, bis zum Ende): Überspringen 2] Wenn im Slice kein Wert eingegeben wird, wird dies als Ende interpretiert.
str1 = "Pat Auto"
str2 = "Taxi"
ans = ""
for i in range(len(str1)):
ans += str1[i]
ans += str2[i]
print(ans)
Kommentar: range () ... Erstellt ein Bereichstypobjekt mit aufeinanderfolgenden numerischen Werten von der Startnummer bis zur Endnummer, die im Argument als Elemente angegeben ist. Das Format der Bereichsfunktion ist wie folgt.
range(stop)
range(start, stop[,step])
range(5)
--> 0 1 2 3 4
range(0, 5)
--> 0 1 2 3 4
range(4,7)
--> 4 5 6
range(0, 5, 1)
--> 0 1 2 3 4
range(0, 10, 2)
--> 0 2 4 6 8
str = "Now I need a drink, alcoholic of course, after the heavy lectures involving quantum mechanics."
ans = str.replace(",","").replace(".", "").split(" ")
print(ans)
Kommentar: Sie müssen lediglich replace () und split () verstehen. Funktion ersetzen .... ersetzen ("Zeichenfolge, die Sie entfernen möchten", "was zu ersetzen ist") split function .... split ("Warum den ganzen Satz teilen") → Liste wird zurückgegeben
s = 'one two one two one'
print(s.replace(' ', '-'))
====> one-two-one-two-one
print(s.split(" "))
====> ['one', 'two', 'one', 'two', 'one']
#Eine Funktion, die bestimmt, ob das erste Zeichen oder die ersten beiden Zeichen abgerufen werden sollen
def extWord(i, word):
if i in [1,5,6,7,8,9,15,16,19]
return (word[0], i)
else:
return (word[:2], i)
str = 'Hi He Lied Because Boron Could Not Oxidize Fluorine. New Nations Might Also Sign Peace Security Clause. Arthur King Can.'
text = str.replace('.', '').replace(',' '')
ans = []
Kommentar: Zunächst eine Erläuterung der Aufzählungsfunktion ... Eine Funktion, mit der der Elementindex und das Element gleichzeitig abgerufen werden können. Wird oft für Anweisungen verwendet. enumerate(iterable, start)
x = ['a','b','c','d','e','f','g','h']
for a,b in enumerate(x):
print(a,b, end=" ")
==========> 0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h
#Der Index wird der ersten Variablen und das Element der zweiten Variablen zugewiesen.
Erklärung zu extWord (): Nach Index klassifizieren → Die Idee, die Aufzählungsfunktion zu verwenden. Wenn Sie die Aufzählungsfunktion verwenden möchten, geben Sie das Argument so an, dass es zu extWord ('index', 'element') wird. Der Rest ist nur eine bedingte Verzweigung mit der if-Anweisung. Erklärung zu ans = [extWord (i, w) für i, w in enumerate (text.split ())]: Wenn Sie es zum ersten Mal sehen, erhalten Sie wahrscheinlich "Was?". Dies ist jedoch eine Liste. Die folgenden beiden Notationen ergeben das gleiche Ergebnis
ans = [extWord(i, w) for i, w in enumerate(text.split())]
ans = []
for i, w in enumerate(text.split()):
ans.append = extWord(i, w)
Erklärung zu dict (): dict () ist eine integrierte Funktion, die das, was Sie in das Argument eingegeben haben, in einen Wörterbuchtyp umwandelt 05 n-gram Zunächst werde ich erklären, was n-Gramm ist.
Kurz gesagt, "n-Gramm" repräsentiert eine Gruppe von n aufeinanderfolgenden Wörtern oder Buchstaben. Schauen wir uns ein konkretes Beispiel an!
Polizeikasten vor dem Kameari Park, Katsushika Ward
Diese 1-In Gramm
['Dies', 'Chi', 'Et al.', 'Kuzu', 'Dekoration', 'Station', 'Schildkröte', 'Ja', 'Öffentlichkeit', 'Garten', 'Bisherige', 'Fraktion', 'aus', 'Platz']
2-gram
['Hier', 'Blick', 'Kuzu', 'Katsushika', 'Dekorativer Bereich', 'Ward Schildkröte', 'Kameari', 'Öffentlichkeit', 'Park', 'Vor dem Garten', 'Ehemalige Fraktion', 'Versand', 'Quelle']
3-gram
['Hier', 'Chirakuzu', 'Katsushika', 'Katsushika', 'Zierschildkröte', 'Ward Kameari', 'Kameari', 'Ja Park', 'Vor dem Park', 'Sonomae-Fraktion', 'Vorheriger Versand', 'Polizeistation']
Basierend auf
def n_gram(target, n):
return [target[index: index + n] for index in range(len(target) - n + 1)]
str = 'I am an NLPer'
for i in range(1,4)
print(n_gram(str, i))
print(n_gram(str.split(' '), i))
Kommentar:
def n_gram(target, n):
return [target[index: index + n] for index in range(len(target) - n + 1)]
Ich spreche endlich darüber. n_gram ('gewünschte Zeichenkette', welches Gramm möchten Sie?) Die Liste enthält 2 Zeilen
list = [target[index: index + n] for index in range(len(target) - n + 1)]
list = []
for index in range(len(target) - n + 1) #Ich möchte die Rückseite angeben. Das heißt, wenn es kleiner als die letzten n Zeichen wird, kann es nicht durchgeführt werden, also hören Sie dort auf
list.append(target[index: index + n])
Es ist leicht zu verstehen, dass die Liste enthalten ist, wenn sie durch einen normalen Satz geheilt ist.
def n_gram(target, n):
return {target[idx:idx + n] for idx in range(len(target) - n + 1)}
str1 = "paraparaparadise"
str2 = "paragraph"
X = n_gram(str1, 2)
Y = n_gram(str2, 2)
#Summensatz von X und Y.
union_set = X | Y # X.union(Y)Aber ja
print(union_set)
#Produktset
intersection_set = X & Y # X.intersection(Y)Aber ja
print(intersection_set)
#Differenz gesetzt
difference_set = X - Y # X.difference(Y)Aber ja
print(difference_set)
#Ist se in X und Y enthalten
print('se' in (X & Y))
Es gibt nichts Besonderes zu erklären. Ich hoffe, Sie können es verstehen, wenn Sie die Kommentare lesen.
def make_sentence(x, y, z):
sentence = str(x) + "von Zeit" + y + "Ist" + str(z)
return sentence
print(make_sentence(12, "Temperatur", 22.4))
Auch dafür gibt es keine besondere Erklärung.
def cipher(sentence):
sentence = [chr(219 - ord(x)) if x.islower() else x for x in sentence]
return ''.join(sentence)
x = 'Hey! Are ready ?? 123456'
print('Klartext', x)
x = cipher(x)
print('Geheimtext', x)
x = cipher(x)
print('Entschlüsselter Text', x)
Kommentar: Heilen Sie zunächst die Listeneinbeziehung mit einem normalen Satz
def cipher(sentence):
sentence = [chr(219 - ord(x)) if x.islower() else x for x in sentence]
return ''.join(sentence)
#Zwei sind gleich
def chiper(sentence):
sentence = []
for x in sentence:
if x.islower:
sentence.append(char(219 - ord(x)))
else:
sentence.append(x)
return ''.join(sentence)
Erklärung zu islower (): islower-Funktion ... Gibt True zurück, wenn alle alphabetischen Zeichen niedriger sind, andernfalls False. Erklärung zu join (): join ist eine Methode von str, die iterable mit einem String verbindet
list = ['a','b','c','d','e,'f]
x = ''.join(list)
====> abcdef
x = ','.join(list)
====> a,b,c,d,e,f
Erklärung der Verschlüsselung / Entschlüsselung: Achten Sie auf den Teil chr (219-ord (x)). Beachten Sie, dass der x-Wert von chr (x) zum ursprünglichen Wert zurückkehrt, wenn Sie dies zweimal tun. Lassen Sie uns tatsächlich Ihre Lieblingsnummer eingeben!
Recommended Posts