Une personne inexpérimentée en Python essaie de frapper 100 traitement du langage 05-06

C'est une continuation de ceci.

Une personne inexpérimentée en Python essaie de frapper 100 traitement du langage 00-04 https://qiita.com/earlgrey914/items/fe1d326880af83d37b22

Cliquez ici pour en savoir plus Une personne inexpérimentée en Python essaie de frapper 100 traitement du langage 07-09 https://qiita.com/earlgrey914/items/a7b6781037bc0844744b

5. 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".

Je me demande ce qu'est n-gramme ... J'en ai entendu parler. Vous ne pouvez pas résoudre ce problème si vous ne comprenez pas quelque chose à propos de n-gramme! D'abord à partir de là! !!

~ 2 minutes sur Google ~

N-gramme est une méthode de découpage de mots en langage naturel (texte) en unités de N caractères consécutifs ou N mots.

Référence
https://www.pytry3g.com/entry/N-gram

~~ Je vois. ~~ ~~ Ensuite, si 1 est passé, il sera séparé par un caractère, et si 2 est passé, il sera séparé par 2 caractères. ~~ ~~ Word bi-gram est un délimiteur mot par mot de 2 caractères ~~ ~~ Je me demande si le bi-gramme de caractères doit être séparé par deux caractères en unités de caractères. ~~ ~~ La réponse est donc ~~ ~~ ■ Bi-gramme de mots ~~ ~~["I", "am", "an", "NL", "Pe", "r"]~~ ~~ ■ Bi-gramme de caractères ~~ ~~["I ","ma","an","NL","Pe","r"]~~

Dois-je sortir ~~? Je suis désolé si je fais une erreur. Je vais le résoudre sur cette prémisse. ~~

Comme c'était généralement faux, j'ai jeté un coup d'œil au résultat de la réponse.

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

Cela semble correct s'il est sorti comme ça. Je vois.

Nous. Pour le moment, le mot bigramme a été créé.

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']]

Comme vous l'avez peut-être remarqué ici, j'ai commencé à voir diverses parties qui n'étaient pas bonnes pour écrire le code.

• La dénomination des variables est trop appropriée. L'anglais et le japonais sont mélangés, et certains utilisent des variables à un seul caractère telles que «s» et «i», tandis que d'autres utilisent des noms de variables tels que «compteur». «Ici, il est écrit comme« tango_bigram »qui est un cas de serpent, mais avant (Pratique 4), il est écrit comme« Liste d'ichimozi »dans le cas de chameau, et il est disjoint.
• La règle de saut de ligne est un mystère. La règle de mettre un espace demi-largeur est un mystère.

Je veux résoudre ce problème à l'avenir, mais je ferme encore les yeux maintenant. J'écris tout seul. Eh bien, finalement, le code que j'ai écrit devra être corrigé par moi-même comme "Je ne peux pas le voir".

Dans l'exercice précédent, nous avons utilisé ʻappend () pour ajouter à la liste, mais ici nous avons utilisé ʻextend (). Si vous voulez mettre plusieurs éléments dans la liste à la fois, vous pouvez utiliser ʻextend () . Il semble y avoir une notation qui utilise + =commel + = [1, 2, 3], mais l'impression est que ʻextend () est plus facile à comprendre.

URL de référence
https://qiita.com/tag1216/items/416314cc75a099ad6149

alors, J'ai également écrit le bigramme du personnage avec un sentiment similaire.

enshu05.py

s = "I am an NLPer"

tango_bigram= []
moji_bigram = []

def bigram(s):
    tango_counter = 0
    moji_counter = 0
    
    #Traitement de gramme de texte
    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

    #Traitement des grammes de caractères
    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'])

La lisibilité est une poubelle! !! !! Et bien non. ** Convention de Python selon laquelle "les fonctions doivent être écrites au-dessus du traitement des appels de fonction"? Je n'y suis pas habitué ... **

** Personnellement, Python est typé dynamiquement et à cause des délimiteurs de bloc indentés. J'ai l'impression que c'est facile à écrire mais difficile à lire. ** ** C'est peut-être parce que j'ai l'habitude de bloquer les délimiteurs en utilisant {} dans des langages statiquement typés comme Java ... Java est également beaucoup moins lisible si l'indentation est appropriée.

Une petite pause

Existe-t-il un moyen de donner un bon nom de variable? Quand je l'ai googlé, il y avait un article comme celui-ci.
URL de référence
https://qiita.com/Ted-HM/items/7dde25dcffae4cdc7923

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.

** D'une manière ou d'une autre, le japonais est difficile. ** ** Je sais pour le moment. Le décodage du japonais est difficile avant le programme.

Au moment où j'ai vu ce problème, j'ai pensé: "Hein? Un ensemble? Puis-je importer et utiliser une telle bibliothèque calculable?" Le N-gramme que j'ai mentionné plus tôt est aussi une bibliothèque, n'est-ce pas?

L'auteur pense que ** "Je dois le faire moi-même" est "quelque chose auquel je suis le seul à pouvoir penser" **, donc si quelqu'un a fait quelque chose, je pense qu'il vaut mieux l'utiliser. ing.

Cependant, cette fois, le but est ** d'apprendre **, donc je vais le faire moi-même.

Il est facile d'obtenir deux bigrammes à cordes avec un petit ajustement de la fonction bigramme dans l'exercice 05. (La portée de la fonction bigram et de moji_bigram était déraisonnable, je l'ai donc corrigée.)

para.py

str_paradise = "paraparaparadise"
str_paragraph = "paragraph"

def bigram(s):

    moji_bigram = []
    moji_counter = 0

    #Traitement des grammes de caractères
    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']

Alors, comment trouvez-vous l'ensemble? Si vous recherchez sur Google, comme "Calcul d'ensemble Python" Il semble que vous devriez utiliser un type d'ensemble au lieu d'un type liste.

<URL de référence> https://note.nkmk.me/python-set/

Qu'est-ce qu'un type d'ensemble? Si vous pensez

・ Aucun élément en double ・ Les éléments sont en panne

Et cela. C'est parfait. <URL de référence> https://note.nkmk.me/python-set/

C'est terminé rapidement.

enshu06.py

str_paradise = "paraparaparadise"
str_paragraph = "paragraph"

#Une fonction qui renvoie une grande liste de caractères
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

#Une fonction qui convertit une liste en un ensemble
def listToSet(list):
    moji_bigram_set = {}
    moji_bigram_set = set(list)
    return moji_bigram_set

#Créer une liste de bigrammes
str_paradise_list = bigram(str_paradise)
str_paragraph_list = bigram(str_paragraph)

#Convertir la liste bigram pour définir et supprimer les doublons
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("Ensemble de somme")
print(paradise_set_X | paragraph_set_Y)

print("Ensemble de produits")
print(paradise_set_X & paragraph_set_Y)

print("Ensemble de différences")
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'}
Ensemble de somme
{'ap', 'ar', 'gr', 'pa', 'di', 'ph', 'is', 'ag', 'ra', 'se', 'ad'}
Ensemble de produits
{'ra', 'pa', 'ap', 'ar'}
Ensemble de différences
{'is', 'di', 'se', 'ad'}

Ouais, c'est facile. Il est difficile de vérifier s'il y a une réponse ...

Continuez demain! !! !! !!

Il a fallu 2 heures du 05 au 06! !! !! !! !! !! !! !! !! !! !! !! !! !! !! (important)