文のリストの単語をトークン化するPython

Question

現在、次のようなリストを含むファイルがあります

example = ['Mary had a little lamb' , 
           'Jack went up the hill' , 
           'Jill followed suit' ,    
           'i woke up suddenly' ,
           'it was a really bad dream...']

「例」はそのような文のリストであり、出力を次のように見せたいです。

mod_example = ["'Mary' 'had' 'a' 'little' 'lamb'" , 'Jack' 'went' 'up' 'the' 'hill' ....]など。 mod_exampleの文（forループを使用して一度に）の各単語を参照文と比較できるように、トークン化された各単語で文を分離する必要があります。

私はこれを試しました：

for sentence in example:
    text3 = sentence.split()
    print text3 

そして、次の出力を取得しました：

['it', 'was', 'a', 'really', 'bad', 'dream...']

すべての文でこれを取得するにはどうすればよいですか上書きし続けます。そしてはい、私のアプローチが正しいかどうかも言及しますか？これは、トークン化された単語を含む文のリストである必要があります。

Answer 1

NLTKでWordトークナイザ（ http://nltk.org/api/nltk.tokenize.html ）をリスト内包表記で使用できます。 http：//docs.python。 org/2/tutorial/datastructures.html＃list-comprehensions

>>> from nltk.tokenize import Word_tokenize
>>> example = ['Mary had a little lamb' , 
...            'Jack went up the hill' , 
...            'Jill followed suit' ,    
...            'i woke up suddenly' ,
...            'it was a really bad dream...']
>>> tokenized_sents = [Word_tokenize(i) for i in example]
>>> for i in tokenized_sents:
...     print i
... 
['Mary', 'had', 'a', 'little', 'lamb']
['Jack', 'went', 'up', 'the', 'hill']
['Jill', 'followed', 'suit']
['i', 'woke', 'up', 'suddenly']
['it', 'was', 'a', 'really', 'bad', 'dream', '...']

Answer 2

リスト「例」を分解する

first_split = []

for i in example:

    first_split.append(i.split())

First_splitリストの要素を分解する

second_split = []

for j in first_split:

    for k in j:

        second_split.append(k.split())

Second_splitリストの要素を分解し、コーダーが出力をどのように必要とするかを最終リストに追加します

final_list = []

for m in second_split:

    for n in m:

        if(n not in final_list):

            final_list.append(n)

print(final_list)   

Answer 3

Nltk（ @ alvasが示唆するように ）と再帰関数を使用して、任意のオブジェクトを取得し、各strをトークン化できます。

from nltk.tokenize import Word_tokenize
def tokenize(obj):
    if obj is None:
        return None
    Elif isinstance(obj, str): # basestring in python 2.7
        return Word_tokenize(obj)
    Elif isinstance(obj, list):
        return [tokenize(i) for i in obj]
    else:
        return obj # Or throw an exception, or parse a dict...

使用法：

data = [["Lorem ipsum dolor. Sit amet?", "Hello World!", None], ["a"], "Hi!", None, ""]
print(tokenize(data))

出力：

[[['Lorem', 'ipsum', 'dolor', '.', 'Sit', 'amet', '?'], ['Hello', 'World', '!'], None], [['a']], ['Hi', '!'], None, []]

Answer 4

私にとって、あなたが何をしようとしているのかはわかりません。

これはどう

exclude = set(['Mary', 'Jack', 'Jill', 'i', 'it'])

mod_example = []
for sentence in example:
    words = sentence.split()
    # Optionally sort out some words
    for Word in words:
        if Word in exclude:
            words.remove(Word)
    mod_example.append('\'' + '\' \''.join(words) + '\'')

print mod_example

どの出力

["'had' 'a' 'little' 'lamb'", "'went' 'up' 'the' 'hill'", "'followed' 'suit'", 
"'woke' 'up' 'suddenly'", "'was' 'a' 'really' 'bad' 'dream...'"]
>>> 

編集：OPによって提供された詳細情報に基づく別の提案

example = ['Area1 Area1 street one, 4454 hikoland' ,
           'Area2 street 2, 52432 hikoland, area2' ,
           'Area3 ave three, 0534 hikoland' ]

mod_example = []
for sentence in example:
    words = sentence.split()
    # Sort out some words
    col1 = words[0]
    col2 = words[1:]
    if col1 in col2:
        col2.remove(col1)
    Elif col1.lower() in col2:
        col2.remove(col1.lower())
    mod_example.append(col1 + ': ' + ' '.join(col2))

アウトプット

>>>> print mod_example
['Area1: street one, 4454 hikoland', 'Area2: street 2, 52432 hikoland,', 
'Area3: ave three, 0534 hikoland']
>>> 

Answer 5

私はこのスクリプトを作成して、すべての人にトークン化の方法を理解してもらい、自然言語処理のエンジンを自分で構築できるようにします。

import re
from contextlib import redirect_stdout
from io import StringIO

example = 'Mary had a little lamb, Jack went up the hill, Jill followed suit, i woke up suddenly, it was a really bad dream...'

def token_to_sentence(str):
    f = StringIO()
    with redirect_stdout(f):
        regex_of_sentence = re.findall('([\w\s]{0,})[^\w\s]', str)
        regex_of_sentence = [x for x in regex_of_sentence if x is not '']
        for i in regex_of_sentence:
            print(i)
        first_step_to_sentence = (f.getvalue()).split('\n')
    g = StringIO()
    with redirect_stdout(g):
        for i in first_step_to_sentence:
            try:
                regex_to_clear_sentence = re.search('\s([\w\s]{0,})', i)
                print(regex_to_clear_sentence.group(1))
            except:
                print(i)
        sentence = (g.getvalue()).split('\n')
    return sentence

def token_to_words(str):
    f = StringIO()
    with redirect_stdout(f):
        for i in str:
            regex_of_Word = re.findall('([\w]{0,})', i)
            regex_of_Word = [x for x in regex_of_Word if x is not '']
            for Word in regex_of_Word:
                print(regex_of_Word)
        words = (f.getvalue()).split('\n')

別のプロセスを作成し、段落からプロセスを再開して、ワードプロセッシングについて誰もがより理解できるようにします。処理する段落は：

example = 'Mary had a little lamb, Jack went up the hill, Jill followed suit, i woke up suddenly, it was a really bad dream...'

段落を文にトークン化する：

sentence = token_to_sentence(example)

結果は：

['Mary had a little lamb', 'Jack went up the hill', 'Jill followed suit', 'i woke up suddenly', 'it was a really bad dream']

単語にトークン化する：

words = token_to_words(sentence)

結果は：

['Mary', 'had', 'a', 'little', 'lamb', 'Jack', 'went, 'up', 'the', 'hill', 'Jill', 'followed', 'suit', 'i', 'woke', 'up', 'suddenly', 'it', 'was', 'a', 'really', 'bad', 'dream']

これがどのように機能するかを説明します。

まず、正規表現を使用してすべての単語と単語を区切るスペースを検索し、句読点が見つかるまで停止します。正規表現は次のとおりです。

([\w\s]{0,})[^\w\s]{0,}

そのため、計算は括弧内の単語とスペースを取ります：

'(Mary had a little lamb),( Jack went up the hill, Jill followed suit),( i woke up suddenly),( it was a really bad dream)...'

結果はまだ明確ではなく、「None」文字が含まれています。そのため、このスクリプトを使用して 'None'文字を削除しました。

[x for x in regex_of_sentence if x is not '']

したがって、段落は文にトークン化されますが、明確な文ではない結果は次のとおりです。

['Mary had a little lamb', ' Jack went up the hill', ' Jill followed suit', ' i woke up suddenly', ' it was a really bad dream']

結果を見ると、スペースで始まるいくつかの文を示しています。スペースを開始せずに明確な段落を作成するには、次の正規表現を作成します。

\s([\w\s]{0,})

次のような明確な文になります：

['Mary had a little lamb', 'Jack went up the hill', 'Jill followed suit', 'i woke up suddenly', 'it was a really bad dream']

したがって、良い結果を得るには2つのプロセスを行う必要があります。

あなたの質問の答えはここから始まります...

文章を単語にトークン化するために、段落の反復を行い、この正規表現で反復している間に単語をキャプチャするために正規表現を使用しました。

([\w]{0,})

空の文字をもう一度クリアします：

[x for x in regex_of_Word if x is not '']

結果は単語のリストだけで本当に明確になります：

['Mary', 'had', 'a', 'little', 'lamb', 'Jack', 'went, 'up', 'the', 'hill', 'Jill', 'followed', 'suit', 'i', 'woke', 'up', 'suddenly', 'it', 'was', 'a', 'really', 'bad', 'dream']

将来、優れたNLPを作成するには、独自のフレーズデータベースを用意し、フレーズが文の中にあるかどうかを検索する必要があります。フレーズのリストを作成した後、残りの単語は単語です。

この方法を使用すると、実際にモジュールが不足している自分の言語（インドネシア語）で自分のNLPを構築できます。

編集：

言葉を比較したい質問がありません。だからあなたは比較する別の文を持っています...私はあなたにボーナスだけでなくボーナスを与えます、私はあなたにそれを数える方法を与えます。

mod_example = ["'Mary' 'had' 'a' 'little' 'lamb'" , 'Jack' 'went' 'up' 'the' 'hill']

この場合、実行する必要のある手順は次のとおりです。1. mod_exampleを反復する2.最初の文をmod_exampleの単語と比較する。 3.計算を行う

したがって、スクリプトは次のようになります。

import re
from contextlib import redirect_stdout
from io import StringIO

example = 'Mary had a little lamb, Jack went up the hill, Jill followed suit, i woke up suddenly, it was a really bad dream...'
mod_example = ["'Mary' 'had' 'a' 'little' 'lamb'" , 'Jack' 'went' 'up' 'the' 'hill']

def token_to_sentence(str):
    f = StringIO()
    with redirect_stdout(f):
        regex_of_sentence = re.findall('([\w\s]{0,})[^\w\s]', str)
        regex_of_sentence = [x for x in regex_of_sentence if x is not '']
        for i in regex_of_sentence:
            print(i)
        first_step_to_sentence = (f.getvalue()).split('\n')
    g = StringIO()
    with redirect_stdout(g):
        for i in first_step_to_sentence:
            try:
                regex_to_clear_sentence = re.search('\s([\w\s]{0,})', i)
                print(regex_to_clear_sentence.group(1))
            except:
                print(i)
        sentence = (g.getvalue()).split('\n')
    return sentence

def token_to_words(str):
    f = StringIO()
    with redirect_stdout(f):
        for i in str:
            regex_of_Word = re.findall('([\w]{0,})', i)
            regex_of_Word = [x for x in regex_of_Word if x is not '']
            for Word in regex_of_Word:
                print(regex_of_Word)
        words = (f.getvalue()).split('\n')

def convert_to_words(str):
    sentences = token_to_sentence(str)
    for i in sentences:
        Word = token_to_words(i)
    return Word

def compare_list_of_words__to_another_list_of_words(from_strA, to_strB):
        fromA = list(set(from_strA))
        for Word_to_match in fromA:
            totalB = len(to_strB)
            number_of_match = (to_strB).count(Word_to_match)
            data = str((((to_strB).count(Word_to_match))/totalB)*100)
            print('words: -- ' + Word_to_match + ' --' + '\n'
            '       number of match    : ' + number_of_match + ' from ' + str(totalB) + '\n'
            '       percent of match   : ' + data + ' percent')



#prepare already make, now we will use it. The process start with script below:

if __== '__main__':
    #tokenize paragraph in example to sentence:
    getsentences = token_to_sentence(example)

    #tokenize sentence to words (sentences in getsentences)
    getwords = token_to_words(getsentences)

    #compare list of Word in (getwords) with list of words in mod_example
    compare_list_of_words__to_another_list_of_words(getwords, mod_example)