-1

所以我认为这个标题会产生很好的搜索结果。无论如何，给定以下代码：它需要一个 yield word 作为来自 text_file_reader_gen() 的 word 并在 while 循环下迭代，直到给出异常的错误（有没有比 try except 更好的方法？）和联锁函数只是把它们混在一起。

def wordparser():
#word_freq={}
word=text_file_reader_gen()
word.next()
wordlist=[]
index=0
while True: #for word in ftext:
    try:
        #print 'entered try'
        current=next(word)
        wordlist.append(current) #Keep adding new words
        #word_freq[current]=1
        if len(wordlist)>2:
            while index < len(wordlist)-1:
                #print 'Before: len(wordlist)-1: %s || index: %s' %(len(wordlist)-1, index)
                new_word=interlock_2(wordlist[index],wordlist[index+1]) #this can be any do_something() function, irrelevant and working fine
                new_word2=interlock_2(wordlist[index+1],wordlist[index])
                print new_word,new_word2
                '''if new_word in word_freq:
                    correct_interlocked_words.append(new_word)
                if new_word2 in word_freq:
                    correct_interlocked_words.append(new_word2)'''
                index+=1
                #print 'After: len(wordlist)-1: %s || index: %s' %(len(wordlist)-1, index)
            '''if w not in word_freq:
                word_freq[w]=1
            else:
                word_freq[w]=+1'''
    except StopIteration,e:
        #print 'entered except'
        #print word_freq
        break
#return word_freq

text_file_reader_gen() 代码：

def text_file_reader_gen():
    path=str(raw_input('enter full file path \t:'))
    fin=open(path,'r')
    ftext=(x.strip() for x in fin)
    for word in ftext:
        yield word

Q1。是否可以迭代单词并同时将这些单词附加到字典word_freq中，同时枚举 word_freq 中的键，其中键是单词 & 仍在添加，而 for 循环运行和新单词是使用联锁功能进行混合，以便大多数这些迭代一次发生 - 类似于

while word.next() is not StopIteration: 
                word_freq[ftext.next()]+=1 if ftext not in word_freq #and
                for i,j in word_freq.keys():
                      new_word=interlock_2(j,wordlist[i+1])

我只想要一个非常简单的东西和一个哈希字典搜索，就像非常快，因为它从中获取单词的 txt 文件很长，它也可能有重复。

Q2。即兴创作这个现有代码的方法？Q3。有没有办法'for i,j in enumerate(dict.items())' 这样我就可以同时到达 dict[key] 和 dict[next_key]，尽管它们是无序的，但这也是无关紧要的。

更新：在这里查看答案后，这就是我想出的。它正在工作，但我对以下代码有疑问：

def text_file_reader_gen():
    path=str(raw_input('enter full file path \t:'))
    fin=open(path,'r')
    ftext=(x.strip() for x in fin)
    return ftext #yield?


def wordparser():
    wordlist=[]
    index=0
    for word in text_file_reader_gen():

有效，但如果我使用yield ftext，它不会。

Q4。基本区别是什么，为什么会发生这种情况？

4

2 回答 2

1

据我了解您的示例代码，您只是在数单词。将以下示例作为您可以构建的想法。

Q1。是和不是。并行运行并非易事。您可以使用线程（GIL 不允许您实现真正的并行性）或多处理，但我不明白您为什么需要这样做。

Q2。我不明白该text_file_reader_gen()功能的必要性。生成器是迭代器，您可以通过阅读for line in file.

def word_parser():

    path = raw_input("enter full file path\t: ")
    words = {}
    with open(path, "r") as f:
        for line in f:
            for word in line.split():
                try:
                    words[word] += 1
                except KeyError:
                    words[word] = 1

    return words

以上逐行遍历文件，在空格处分割每一行并计算单词。它不处理标点符号。

如果您的输入文件是自然语言，您可能需要查看NTLK 库。这是另一个使用集合库的示例。

import collections
import string

def count_words(your_input):
    result = {}
    translate_tab = string.maketrans("","")
    with open(your_input, "r") as f:
        for line in f:
            result.update(collections.Counter(x.translate(translate_tab, string.punctuation) for x in line.split()))

    return result

 # Test.txt contains 5 paragraphs of Lorem Ipsum from some online generator
 In [61]: count_words("test.txt")
 Out[61]: 
 {'Aenean': 1,
  'Aliquam': 1,
  'Class': 1,
  'Cras': 1,
  'Cum': 1,
  'Curabitur': 2,
  'Donec': 1,
  'Duis': 1,
  'Etiam': 2,
  'Fusce': 1,
  'In': 1,
  'Integer': 1,
  'Lorem': 1,
  ......
  }

该函数逐行遍历文件，创建一个collections.Counter对象——基本上是它的一个子类dict——用任何类似空格的东西分割每一行，用string.translate删除标点符号，最后用 Counter-dict 更新结果字典。计数器完成所有...计数。

Q3。不知道为什么或如何实现这一目标。

于 2013-04-26T12:53:40.573 回答
0

Q3。有没有办法'for i,j in enumerate(dict.items())' 这样我就可以同时到达 dict[key] 和 dict[next_key]

您可以获得迭代中的下一个项目。因此，您可以编写一个函数来将当前项目与下一个项目配对

像这样：

def with_next(thing):
    prev = next(thing)
    while True:
        try:
            cur = next(thing)
        except StopIteration, e:
            # There's no sane next item at the end of the iterable, so
            # use None.
            yield (prev, None)
            raise e
        yield (prev, cur)
        prev = cur

正如评论所说，在列表末尾（没有“下一个键”）做什么并不明显，所以它只是返回None

例如：

for curitem, nextitem in with_next(iter(['mouse', 'cat', 'dog', 'yay'])):
    print "%s (next: %s)" % (curitem, nextitem)

输出这个：

mouse (next: cat)
cat (next: dog)
dog (next: yay)
yay (next: None)

它适用于任何可迭代的（例如dict.iteritems()，dict.iterkeys()等enumerate）：

mydict = {'mouse': 'squeek', 'cat': 'meow', 'dog': 'woof'}
for cur_key, next_key in with_next(mydict.iterkeys()):
    print "%s (next: %s)" % (cur_key, next_key)

关于您的更新：

def text_file_reader_gen():
    path=str(raw_input('enter full file path \t:'))
    fin=open(path,'r')
    ftext=(x.strip() for x in fin)
    return ftext #yield?

Q4。[收益和回报之间]的基本区别是什么，为什么会发生这种情况？

yield并且return是非常不同的东西。

return从函数返回一个值，然后函数终止。

yield将函数转换为“生成器函数”。生成器函数不是返回单个对象并结束，而是输出一系列对象，每次yield调用一个对象。

这里有一堆解释生成器的好页面：

return 语句的工作方式与许多其他编程语言一样。官方教程之类的应该解释一下

于 2013-05-01T12:15:56.700 回答