100 coups de traitement du langage ~ Chapitre 1

Je veux faire du python, mais je ne sais pas par où commencer Nous allons procéder avec 100 language processing knock 2015 L'environnement est Windows 10, python 3.6.0

00. Ordre inverse des chaînes

Obtenez une chaîne avec les caractères de la chaîne "souligné" disposés en sens inverse (de la fin au début).

00.py


string = "stressed"
print(string[::-1])
#Implémenté en tranches
# string[Position de départ:Position finale:Nombre d'étapes]
#Les positions de début et de fin sont comptées à partir de la fin en spécifiant un nombre négatif
#Vous pouvez également faire ce qui suit
print(string[-1::-1])

Implémenté avec slice

01. «Patatokukashi»

Retirez les 1er, 3ème, 5ème et 7ème caractères de la chaîne de caractères "Patatokukashi" et obtenez la chaîne de caractères concaténée.

01.py


string = "Patatoku Kashii"
print(string[::2])
#Identique à 00, 2 chacun en spécifiant le pas de tranche

En utilisant des étapes comme 00

02. "Patcar" + "Tax" = "Patatokukasie"

Obtenez la chaîne de caractères "Patatokukashi" en reliant alternativement les caractères "Pattocar" + "Tax" depuis le début.

02.py


string1 = "Voiture Pat"
string2 = "Taxi"
string3 = ""
i = 0
while i < len(string1):
    string3 += string1[i] + string2[i]
    i+=1
print(string3)

Un peu subtile ... Seule la même longueur de caractère peut être connectée

03. Taux circonférentiel

Décomposez la phrase "Maintenant, j'ai besoin d'un verre, alcoolique bien sûr, après les lourdes conférences sur la mécanique quantique." En mots et créez une liste du nombre de caractères (alphabétiques) dans chaque mot par ordre d'apparition.

03.py


import re #Utilisation d'expressions régulières
from collections import defaultdict #Pour compter les caractères

string = "Now I need a drink, alcoholic of course, after the heavy lectures involving quantum mechanics."

# ,Quand.Liste par mot après suppression
words_list = re.sub('[,.]','',string).split()

#Initialisation du compteur
counter = defaultdict(int)

#Compter à partir du premier mot / lettre
for word in words_list:
	for c in word:
		counter[c] += 1

#Parce que c'est un type de dictionnaire(lettre,Numéro de compte)Convertir en type de liste tuple
count_list = dict(counter).items()

print(count_list)

Il y a trop de traitement de conversion de type dans l'ensemble ... Je veux le réduire un peu plus.

04. Symbole d'élément

Décomposez la phrase "Salut, il a menti parce que le bore ne pouvait pas oxyder le fluor. De nouvelles nations pourraient également signer une clause de sécurité de paix. Arthur King Can." Le premier mot est le premier caractère, les autres mots sont les deux premiers caractères, et le tableau associatif (type de dictionnaire ou type de carte) de la chaîne de caractères extraite à la position du mot (quel nombre de mots depuis le début) est créé. Créez-le.

04.py


import re #Utilisation d'expressions régulières

elements = "Hi He Lied Because Boron Could Not Oxidize Fluorine. New Nations Might Also Sign Peace Security Clause. Arthur King Can."
mono_words = [1, 5, 6, 7, 8, 9, 15, 16, 19]
shortened_elements = {}

# .Liste par mot après suppression
elements_list = elements.replace('.','').split()

#Tout en explorant la liste de mots des éléments un par un
#Vérifiez s'il s'agit d'une expression à un caractère définie
#Entrez le nom abrégé de l'élément et le numéro depuis le début dans le dictionnaire d'éléments
#Vous pouvez obtenir un itérateur en utilisant enumerate
for i,e in enumerate(elements_list):
    count = i + 1
    if(count in mono_words):
        shortened_elements[e[:1]] = count
    else:
        shortened_elements[e[:2]] = count

print(shortened_elements)
  1. n-gram Créez une fonction qui crée un n-gramme à partir d'une séquence donnée (chaîne, liste, etc.). Utilisez cette fonction pour obtenir le mot bi-gramme et la lettre bi-gramme à partir de la phrase "Je suis un PNL".

Bi-gramme de caractères? Bi-gramme de mots?

Le mot bi-gramme de "Je suis un PNL" {‘I am’,’am an’,’an NLPer’} Avec le caractère bi-gramme {‘I a’,’a m ‘,’m a’,’a n’,’n N’,’N L’,’L P’,’P e’,’e r’}

Devrait être le résultat

05.py


import re #Utilisation d'expressions régulières

#Chaîne de caractères et liste préparées sous forme de séquence
sentence_string = "I am an NLPer"
sentence_list = sentence_string.split()

#N avec le nombre n et la séquence comme arguments-fonction gramme
def n_gram(n,sequence):

    #Liste des valeurs de retour
    ngram = []

    #Pour effectuer un traitement commun pour les chaînes de caractères et les listes
    #Se convertit en une liste caractère par caractère si une chaîne est donnée en argument
    # ,Quand.Quandスペースを削除
    if isinstance(sequence, str):
        sequence = list(re.sub('[,. ]','',sequence))

    # n-processus de création de gramme
    #Position de i dans la déclaration+Trancher l'argument n
    #La fin de for est de la longueur de la liste moins n au point où 1 est ajouté
    for i in range(len(sequence)-n+1):
        ngram.append(sequence[i:i+n])

    return ngram

#Mot bi-gram
print(n_gram(2,sentence_list))
#Personnage bi-gram
print(n_gram(2,sentence_string))

06. Réunion

Trouvez l'ensemble des bi-grammes de caractères contenus dans «paraparaparadise» et «paragraphe» comme X et Y, respectivement, et trouvez l'ensemble de somme, l'ensemble de produits et l'ensemble de différences de X et Y, respectivement. En outre, découvrez si le bi-gram'se'est inclus dans X et Y.

06.py


import re #Utilisation d'expressions régulières

#Chaîne de caractères et liste préparées sous forme de séquence
X = "paraparaparadise"
Y = "paragraph"

# n-Réutilisation de la fonction gramme 05
def n_gram(n,sequence):

    ngram = []

    if isinstance(sequence, str):
        sequence = list(re.sub('[,. ]','',sequence))

    for i in range(len(sequence)-n+1):
        #La pièce étant passée à 05, la liste de la liste n'a pas pu être convertie au type d'ensemble décrit plus loin
        #Le traitement de conversion est mis dans le type taple
        ngram.append(tuple(sequence[i:i+n]))

    return ngram

# X,Y bi-Création de Gram
#Défini comme type d'ensemble pour le calcul d'ensemble
X = set(n_gram(2,X))
Y = set(n_gram(2,Y))

#Ensemble de somme
print(X | Y)
#Ensemble de produits
print(X & Y)
#Ensemble de différences
print(X - Y)
print(Y - X)
# 'se'Vérifier si
if ('s','e') in X & Y:
    print("'se'Est inclus dans X et Y")
else:
    print("'se'N'est pas inclus dans X ou Y")

07. Génération de déclaration par modèle

Implémentez une fonction qui prend les arguments x, y, z et renvoie la chaîne "y at x is z". De plus, définissez x = 12, y = "température", z = 22,4 et vérifiez le résultat de l'exécution.

07.py


def tostr(x,y,z):
    return ("%s temps%s est%s" % (x,y,z))

print( tostr(12,"Température",22.4))

08. Cryptographie

Implémentez le chiffrement de fonction qui convertit chaque caractère de la chaîne de caractères donnée selon les spécifications suivantes.

Remplacer par (219 --character code) caractères si minuscules Afficher les autres caractères tels quels Utilisez cette fonction pour crypter / décrypter les messages en anglais.

08.py


import re #Utilisation d'expressions régulières

def cipher(str):
    #Lister une fois et traiter caractère par caractère
    str = list(str)
    re_str = []
    for s in str:
        if re.search('[a-z]',s):
            #Le caractère Eiko est 97 dans le code de caractère~122 Dans le processus suivant, un->z,b->y,c->x...z->Converti comme un
            re_str.append(chr(219-ord(s)))
        else:
            re_str.append(s)
    return "".join(re_str)

test_str = "I am a esaka!!"

print(cipher(test_str))
#résultat:I zn z vhzpz!!
print(cipher(cipher(test_str)))
#résultat:I am a esaka!!
  1. Typoglycemia Créez un programme qui réorganise aléatoirement l'ordre des autres caractères, en laissant le premier et le dernier caractère de chaque mot pour la chaîne de mots séparés par des espaces. Cependant, les mots d'une longueur de 4 ou moins ne sont pas réorganisés. Donnez une phrase en anglais appropriée (par exemple, "Je ne pouvais pas croire que je pouvais réellement comprendre ce que je lisais: le pouvoir phénoménal de l'esprit humain.") Et vérifiez le résultat de l'exécution.

09.py


import random #Utilisation du traitement des nombres aléatoires

def rand_str(str):
    #Liste séparée par des espaces
    str = str.split(' ')
    re_str = []
    for i,s in enumerate(str):
        if len(s) > 4 and i != 0 and i != len(str)-1:
            re_str.append("".join(random.sample(s,len(s))))
        else:
            re_str.append(s)
    #La valeur de retour consiste à remplacer le mot par un espace
    return " ".join(re_str)

test_str = "I couldn't believe that I could actually understand what I was reading : the phenomenal power of the human mind ."

print(rand_str(test_str))
#résultat: I tdcuon'l evibele that I ludoc ltyucala andnetrsdu what I was drienag : the lnpaeneohm erpow of the uahmn mind .

correction

J'ai mal compris que je ne trierais pas uniquement le premier et le dernier mot d'une chaîne donnée. C'est le début et la fin de * chaque mot *. Est-ce ceci qui était populaire il y a quelque temps?

C'est pourquoi je l'ai corrigé ci-dessous

09.py


import random #Utilisation du traitement des nombres aléatoires

def rand_str(str):
    #Liste séparée par des espaces
    str = str.split(' ')
    re_str = []
    for i,s in enumerate(str):
        if len(s) > 4:
            re_str.append(s[0]+"".join(random.sample(s[1:-1],len(s)-2))+s[-1])
        else:
            re_str.append(s)
    #La valeur de retour consiste à remplacer le mot par un espace
    return " ".join(re_str)

test_str = "I couldn't believe that I could actually understand what I was reading : the phenomenal power of the human mind ."
test_str2 = "Tant que vous avez le texte de Saisho et Saigo, le Junban sera foiré, mais en partant de l'idée que vous pouvez le lire correctement, que diriez-vous de remplacer le Junban du texte à dessein? Vous le lirez correctement, non?"

print(rand_str(test_str))
#résultat: I cnlu'dot belevie that I colud allctauy udeatsnnrd what I was radineg : the pehnomanel pwoer of the huamn mind .
print(rand_str(test_str2))
#résultat:Tant qu'il y a une épée et une épée, l'épée est foirée, mais l'épée est que vous pouvez la lire correctement. N'est-ce pas vrai?

Pour le moment, avec ça

Recommended Posts

100 coups de traitement du langage ~ Chapitre 1
Le traitement de 100 langues frappe le chapitre 2 (10 ~ 19)
100 traitements linguistiques frappent 03 ~ 05
100 coups de traitement linguistique (2020): 32
100 coups de traitement linguistique (2020): 35
100 coups de traitement linguistique (2020): 47
100 coups de traitement linguistique (2020): 39
100 coups de traitement linguistique (2020): 22
100 coups de traitement linguistique (2020): 26
100 coups de traitement linguistique (2020): 34
100 coups de traitement linguistique (2020): 42
100 coups de traitement linguistique (2020): 29
100 coups de traitement linguistique (2020): 49
Le traitement de 100 langues frappe 06 ~ 09
100 coups de traitement linguistique (2020): 43
100 coups de traitement linguistique (2020): 24
100 coups de traitement linguistique (2020): 45
100 coups de traitement linguistique (2020): 10-19
100 coups de traitement linguistique (2020): 30
100 coups de traitement linguistique (2020): 00-09
100 coups de traitement linguistique (2020): 31
100 coups de traitement linguistique (2020): 48
100 coups de traitement linguistique (2020): 44
100 coups de traitement linguistique (2020): 41
100 coups de traitement linguistique (2020): 37
100 coups de traitement linguistique (2020): 25
100 coups de traitement linguistique (2020): 23
100 coups de traitement linguistique (2020): 33
100 coups de traitement linguistique (2020): 20
100 coups de traitement linguistique (2020): 27
100 coups de traitement linguistique (2020): 46
100 coups de traitement linguistique (2020): 21
100 coups de traitement linguistique (2020): 36
[Traitement du langage 100 coups 2020] Chapitre 3: Expressions régulières
100 traitements du langage naturel frappent le chapitre 4 Commentaire
[Traitement du langage 100 coups 2020] Chapitre 6: Machine learning
[Traitement du langage 100 coups 2020] Chapitre 1: Mouvement préparatoire
[Traitement du langage 100 coups 2020] Chapitre 7: Vecteur Word
100 Language Processing Knock 2020: Chapitre 3 (expression régulière)
[Traitement du langage 100 coups 2020] Chapitre 8: Réseau neuronal
[Traitement du langage 100 coups 2020] Chapitre 2: Commandes UNIX
[Traitement du langage 100 coups 2020] Chapitre 9: RNN, CNN
[Traitement du langage 100 coups 2020] Chapitre 4: Analyse morphologique
100 coups de traitement du langage amateur: 41
100 coups de traitement du langage amateur: 71
100 coups de traitement du langage amateur: 56
100 coups de traitement du langage amateur: 24
100 coups de traitement du langage amateur: 50
100 coups de traitement du langage amateur: 59
100 coups de traitement du langage amateur: 70
100 coups de traitement du langage amateur: 62
100 coups de traitement du langage amateur: 60
100 Language Processing Knock 2020 Chapitre 1
100 coups de traitement du langage amateur: 92
100 coups de langue amateur: 30
100 coups de langue amateur: 06
100 coups de traitement du langage amateur: 84
100 coups de traitement du langage amateur: 81
100 coups de langue amateur: 33
100 coups de traitement du langage amateur: 46
100 coups de traitement du langage amateur: 88