J'écrirai chaque fonction qui sortira avec un tel détail qu'elle mourra. J'écrirai également quel genre d'idée a conduit à un tel code: poing:
str = "stressed"
reverse_str = str[::-1]
print(reverse_str)
Commentaire La connaissance des "tranches" est utilisée dans ce problème. Une tranche est un mécanisme qui découpe une partie d'une séquence (chaîne, liste, taple, etc.) et renvoie une copie.
str[n] #Extraire le nième caractère de str
str[start:stop:step]
#start...De quel numéro?
#stop...point final(+Spécifions une valeur de 1!)
#step...Combien de morceaux sautez-vous?
str = "Patatoku Kashii"
print(str[1::2])
Commentaire: Vous pouvez utiliser la connaissance de tranche obtenue en 00. str [Du premier caractère: (Puisqu'il est vide, jusqu'à la fin): Ignorer 2] Lorsqu'aucune valeur n'est entrée dans la tranche, elle est interprétée comme la fin.
str1 = "Voiture Pat"
str2 = "Taxi"
ans = ""
for i in range(len(str1)):
ans += str1[i]
ans += str2[i]
print(ans)
Commentaire: range () ... Crée un objet de type plage qui a des valeurs numériques consécutives du numéro de début au numéro de fin spécifié dans l'argument en tant qu'éléments. Le format de la fonction de plage est le suivant.
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)
Commentaire: Tout ce que vous avez à faire est de comprendre replace () et split (). remplacer la fonction .... remplacer ("chaîne de caractères à supprimer", "quoi remplacer") split function .... split ("Pourquoi diviser la phrase entière") → La liste est retournée
s = 'one two one two one'
print(s.replace(' ', '-'))
====> one-two-one-two-one
print(s.split(" "))
====> ['one', 'two', 'one', 'two', 'one']
#Une fonction qui détermine s'il faut récupérer le premier caractère ou les deux premiers caractères
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 = []
Commentaire: Tout d'abord, une explication de la fonction énumérer ... Une fonction qui peut récupérer l'index de l'élément et l'élément en même temps. Souvent utilisé avec les instructions for. 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
#L'index est affecté à la première variable et l'élément est affecté à la deuxième variable.
Explication sur extWord (): Classer par index → L'idée d'utiliser la fonction énumérer. Donc, en gardant à l'esprit d'utiliser la fonction enumerate, spécifiez l'argument pour qu'il devienne extWord ('index', 'element'). Le reste n'est qu'un branchement conditionnel avec l'instruction if. Explication sur ans = [extWord (i, w) pour i, w dans enumerate (text.split ())]: Lorsque vous le voyez pour la première fois, vous obtiendrez probablement "Quoi?", Mais il s'agit d'une inclusion de liste. Les deux notations suivantes donnent le même résultat
ans = [extWord(i, w) for i, w in enumerate(text.split())]
ans = []
for i, w in enumerate(text.split()):
ans.append = extWord(i, w)
Explication sur dict (): dict () est une fonction intégrée qui transforme ce que vous mettez dans l'argument dans un type de dictionnaire 05 n-gram Tout d'abord, j'expliquerai ce qu'est le n-gramme.
En un mot, «n-gramme» représente un groupe de n mots ou lettres consécutifs. Regardons un exemple concret!
Box de police en face du parc Kameari, quartier Katsushika
Ce 1-En gramme
['Cette', 'Chi', 'Et al.', 'Kuzu', 'Décoration', 'quartier', 'tortue', 'Oui', 'Publique', 'Jardin', 'Avant', 'Faction', 'En dehors', 'Endroit']
2-gram
['Ici', 'Regard', 'Kuzu', 'Katsushika', 'Zone décorative', 'Tortue de Ward', 'Kameari', 'Publique', 'parc', 'Devant le jardin', 'Ancienne faction', 'Envoi', 'la source']
3-gram
['Ici', 'Chirakuzu', 'Katsushika', 'Katsushika', 'Tortue ornementale', 'Quartier Kameari', 'Kameari', 'Oui Park', 'Devant le parc', 'Faction Sonomae', 'Envoi précédent', 'Poste de police']
Basé sur ceci
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))
Commentaire:
def n_gram(target, n):
return [target[index: index + n] for index in range(len(target) - n + 1)]
Je parle enfin de ça. n_gram ('chaîne de caractères souhaitée', quel gramme voulez-vous?) 2 lignes sont incluses dans la liste
list = [target[index: index + n] for index in range(len(target) - n + 1)]
list = []
for index in range(len(target) - n + 1) #Je veux préciser le dos. Autrement dit, si cela devient inférieur aux n derniers caractères, cela ne peut pas être fait, alors arrêtez-vous là
list.append(target[index: index + n])
Il est facile de comprendre l'inclusion de la liste une fois qu'elle est corrigée par une phrase normale.
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)
#Ensemble somme de X et Y
union_set = X | Y # X.union(Y)Mais oui
print(union_set)
#Ensemble de produits
intersection_set = X & Y # X.intersection(Y)Mais oui
print(intersection_set)
#Jeu de différences
difference_set = X - Y # X.difference(Y)Mais oui
print(difference_set)
#Est-ce inclus dans X et Y
print('se' in (X & Y))
Il n'y a rien de spécial à expliquer à ce sujet. J'espère que vous pourrez le comprendre si vous lisez les commentaires.
def make_sentence(x, y, z):
sentence = str(x) + "de temps" + y + "Est" + str(z)
return sentence
print(make_sentence(12, "Température", 22.4))
Il n'y a pas non plus d'explication particulière à cela.
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('Texte brut', x)
x = cipher(x)
print('Cryptogramme', x)
x = cipher(x)
print('Texte décrypté', x)
Commentaire: Tout d'abord, corrigez l'inclusion de la liste avec une phrase normale
def cipher(sentence):
sentence = [chr(219 - ord(x)) if x.islower() else x for x in sentence]
return ''.join(sentence)
#Deux sont les mêmes
def chiper(sentence):
sentence = []
for x in sentence:
if x.islower:
sentence.append(char(219 - ord(x)))
else:
sentence.append(x)
return ''.join(sentence)
Explication sur islower (): islower function ... Renvoie True si tous les caractères alphabétiques sont inférieurs, False sinon. Explication sur join (): join est une méthode de str, qui joint itérable à une chaîne
list = ['a','b','c','d','e,'f]
x = ''.join(list)
====> abcdef
x = ','.join(list)
====> a,b,c,d,e,f
Explication du cryptage / décryptage: Faites attention à la partie chr (219-ord (x)). Notez que la valeur x de chr (x) revient à la valeur d'origine si vous le faites deux fois. Entrons en fait votre numéro préféré!
Recommended Posts