【问题标题】:How can this Python Scrabble word finder be made faster?如何使这个 Python Scrabble 单词查找器变得更快?
【发布时间】:2012-05-05 05:51:48
【问题描述】:

我没有真正需要改进它,这只是为了好玩。现在,在大约 20 万字的列表中,它需要大约一秒钟的时间。

我已经尽我所能地尝试优化它(使用生成器而不是列表推导产生了很大的不同),但我已经没有想法了。

你有吗?

#!/usr/bin/env python
# let's cheat at scrabble

def count_letters(word):
  count = {} 
  for letter in word:
    if letter not in count: count[letter] = 0
    count[letter] += 1 
  return count 

def spellable(word, rack):
    word_count = count_letters(word)
    rack_count  = count_letters(rack)
    return all( [word_count[letter] <= rack_count[letter] for letter in word] )  

score = {"a": 1, "c": 3, "b": 3, "e": 1, "d": 2, "g": 2, 
         "f": 4, "i": 1, "h": 4, "k": 5, "j": 8, "m": 3, 
         "l": 1, "o": 1, "n": 1, "q": 10, "p": 3, "s": 1, 
         "r": 1, "u": 1, "t": 1, "w": 4, "v": 4, "y": 4, 
         "x": 8, "z": 10}

def score_word(word):
  return sum([score[c] for c in word])

def word_reader(filename):
  # returns an iterator
  return (word.strip() for word in  open(filename)) 

if __name__ == "__main__":
  import sys
  if len(sys.argv) == 2: 
    rack = sys.argv[1].strip()
  else:
    print """Usage: python cheat_at_scrabble.py <yourrack>"""
    exit()

  words = word_reader('/usr/share/dict/words')
  scored =  ((score_word(word), word) for word in words if set(word).issubset(set(rack)) and len(word) > 1 and spellable(word, rack))

  for score, word in sorted(scored):
    print str(score), '\t', word

【问题讨论】:

  • 您错过了spellable 末尾的列表理解。既然如此,它可能会产生关键的不同:带有生成器表达式的all 将在找到不正确的表达式时立即停止。
  • 您是否对代码进行了分析?
  • rack_count = count_letters(rack) - 你正在为每个word 计算这个。尝试之前计算一次,然后重复使用。
  • 您可以更好地准备您的数据。为每个单词存储一些附加信息,例如字母计数。
  • 大家好,感谢您的建议。我做了两个建议的更改,并看到了轻微的改进(十分之一秒左右)。我很惭愧地承认我从来没有学会分析 Python,我会搜索有关如何做到这一点的信息。

标签: python optimization


【解决方案1】:

在不偏离基本代码的情况下,这里有一些相当简单的优化:

首先,将您的单词阅读器更改为:

def word_reader(filename, L):
  L2 = L+2
  # returns an iterator
  return (word.strip() for word in open(filename) \
          if len(word) < L2 and len(word) > 2)

并将其称为

words = word_reader('/usr/share/dict/words', len(rack))

这是我建议的所有更改中最大的改进。在我们在这个过程中走得太远之前,它会消除太长或太短的单词。请记住,word 在我的比较中没有去除换行符。我假设 '\n' 行分隔符。此外,列表中的最后一个单词可能存在问题,因为它的末尾可能没有新行,但在我的计算机上,最后一个单词是 études,无论如何我们的方法都找不到。当然,您可以事先从原始字典中创建自己的字典,删除那些无效的字典:那些长度不正确或字母超出 a-z 的字典。

接下来,Ferran 为机架组建议了一个变量,这是个好主意。但是,从每个单词中制作一个集合,你也得到了相当大的减速。完全使用这些装置的目的是清除许多根本没有任何镜头的装置,从而加快速度。但是,我发现在调用可拼写之前检查单词的第一个字母是否在机架中会更快:

rackset = frozenset(rack)
scored =  [(score_word(word), word) for word in words if word[0] in rackset \
           and spellable(word, rack)]

但是,这必须伴随对可拼写的更改。我将其更改为以下内容:

def spellable(word, rack):
    return all( [rack.count(letter) >= word.count(letter) \
                 for letter in set(word)] )

即使没有在上一步中进行更改,也比您当前拥有的更快。

通过上述三个更改,代码比我的简单测试快了大约 3 倍。

寻找更好的算法

由于您真正要做的是寻找字谜,因此使用字谜字典是有意义的。字谜词典将字典中的每个单词都提取出来,如果它们是字谜,则将它们分组。例如,“takes”和“skate”是彼此的字谜,因为它们在排序时都等于“aekst”。我创建了一个字谜字典作为文本文件,其格式为每行构成一个条目。每个条目都有字谜的排序版本的排序版本,然后是字谜本身。例如,我使用的条目是

aekst skate takes

然后我可以只取机架字母的组合,并在 anagram 字典中对每个字母进行二分搜索,看看是否有匹配项。对于 7 个字母的机架,最多有 120 个唯一的有效拼字字母组合。执行二进制搜索是 O(log(N)) 所以这会非常快。

我分两部分实现算法。第一个制作字谜字典,第二个是真正的拼字游戏作弊程序。

Anagram 字典创建者代码

f = open('/usr/share/dict/words')
d = {}
lets = set('abcdefghijklmnopqrstuvwxyz\n')
for word in f:
  if len(set(word) - lets) == 0 and len(word) > 2 and len(word) < 9:
    word = word.strip()
    key = ''.join(sorted(word))
    if key in d:
      d[key].append(word)
    else:
      d[key] = [word]
f.close()
anadict = [' '.join([key]+value) for key, value in d.iteritems()]
anadict.sort()
f = open('anadict.txt','w')
f.write('\n'.join(anadict))
f.close()

拼字游戏作弊码

from bisect import bisect_left
from itertools import combinations
from time import time

def loadvars():
  f = open('anadict.txt','r')
  anadict = f.read().split('\n')
  f.close()
  return anadict

scores = {"a": 1, "c": 3, "b": 3, "e": 1, "d": 2, "g": 2, 
         "f": 4, "i": 1, "h": 4, "k": 5, "j": 8, "m": 3, 
         "l": 1, "o": 1, "n": 1, "q": 10, "p": 3, "s": 1, 
         "r": 1, "u": 1, "t": 1, "w": 4, "v": 4, "y": 4, 
         "x": 8, "z": 10}

def score_word(word):
  return sum([scores[c] for c in word])

def findwords(rack, anadict):
  rack = ''.join(sorted(rack))
  foundwords = []
  for i in xrange(2,len(rack)+1):
    for comb in combinations(rack,i):
      ana = ''.join(comb)
      j = bisect_left(anadict, ana)
      if j == len(anadict):
        continue
      words = anadict[j].split()
      if words[0] == ana:
        foundwords.extend(words[1:])
  return foundwords

if __name__ == "__main__":
  import sys
  if len(sys.argv) == 2:
    rack = sys.argv[1].strip()
  else:
    print """Usage: python cheat_at_scrabble.py <yourrack>"""
    exit()
  t = time()
  anadict = loadvars()
  print "Dictionary loading time:",(time()-t)
  t = time()
  foundwords = set(findwords(rack, anadict))
  scored = [(score_word(word), word) for word in foundwords]
  scored.sort()
  for score, word in scored:
    print "%d\t%s" % (score,word)
  print "Time elapsed:", (time()-t)

字谜词典创建器在我的机器上大约需要半秒时间。在创建字典后,运行拼字游戏作弊程序的速度比 OP 的代码快 15x,在我进行上述更改后,它比 OP 的代码快 5 倍。此外,加载字典的启动时间比实际从机架中搜索单词的时间要长得多,因此这是一次进行多个搜索的更好方法。

【讨论】:

  • 你也可以在 python 中创建一个实际的字典结构,然后腌制它。这样你只需要加载泡菜,然后查找基本上是 O(1)。
【解决方案2】:

您可以使用 /usr/dict/share/words 字典已排序的事实,以允许您跳过字典中的大量单词而根本不考虑它们。

例如,假设一个字典单词以“A”开头,而您的机架中没有“A”。您可以在单词列表中对以“B”开头的第一个单词进行二进制搜索,并跳过其间的所有单词。在大多数情况下,这会产生很大的不同 - 您可能会跳过一半的单词。

【讨论】:

  • 好主意。 OP 可以遍历字典一次,并存储一个指向每个字母的第一个单词的指针。 OP 将跳过 26 个字母中的至少 19 个。
  • 一次考虑 N 个字母可能会做得更好 - 也就是说:“如果单词的前 N ​​个字母不在机架中,则跳到字典中以开头的第一个单词不同的 N 字母组合”。我猜最佳值大约是 N=2 或 N=3...
【解决方案3】:
import trie


def walk_trie(trie_node, rack, path=""):
    if trie_node.value is None:
        yield path
    for i in xrange(len(rack)):
        sub_rack = rack[:i] + rack[i+1:]
        if trie_node.nodes.has_key(rack[i]):
            for word in walk_trie(trie_node.nodes[rack[i]], sub_rack, path+rack[i]):
                yield word


if __name__ == "__main__":
    print "Generating trie... "

    # You might choose to skip words starting with a capital
    # rather than lower-casing and searching everything. Capitalised
    # words are probably pronouns which aren't allowed in Scrabble

    # I've skipped words shorter than 3 characters.
    all_words = ((line.strip().lower(), None) for line in open("/usr/share/dict/words") if len(line.strip()) >= 3)
    word_trie = trie.Trie(mapping=all_words)
    print "Walking Trie... "
    print list(walk_trie(word_trie.root, "abcdefg"))

生成 trie 需要一点时间,但是一旦生成,获取单词列表应该比遍历列表要快得多。

如果有人知道序列化 trie 的方法,那将是一个很好的补充。

只是为了证明生成 trie 是需要时间的......

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    98333    5.344    0.000    8.694    0.000 trie.py:87(__setitem__)
   832722    1.849    0.000    1.849    0.000 trie.py:10(__init__)
   832721    1.501    0.000    1.501    0.000 {method 'setdefault' of 'dict' objects}
    98334    1.005    0.000    1.730    0.000 scrabble.py:16(<genexpr>)
        1    0.491    0.491   10.915   10.915 trie.py:82(extend)
   196902    0.366    0.000    0.366    0.000 {method 'strip' of 'str' objects}
    98333    0.183    0.000    0.183    0.000 {method 'lower' of 'str' objects}
    98707    0.177    0.000    0.177    0.000 {len}
   285/33    0.003    0.000    0.004    0.000 scrabble.py:4(walk_trie)
      545    0.001    0.000    0.001    0.000 {method 'has_key' of 'dict' objects}
        1    0.001    0.001   10.921   10.921 {execfile}
        1    0.001    0.001   10.920   10.920 scrabble.py:1(<module>)
        1    0.000    0.000    0.000    0.000 trie.py:1(<module>)
        1    0.000    0.000    0.000    0.000 {open}
        1    0.000    0.000    0.000    0.000 trie.py:5(Node)
        1    0.000    0.000   10.915   10.915 trie.py:72(__init__)
        1    0.000    0.000    0.000    0.000 trie.py:33(Trie)
        1    0.000    0.000   10.921   10.921 <string>:1(<module>)
        1    0.000    0.000    0.000    0.000 {method 'split' of 'str' objects}
        1    0.000    0.000    0.000    0.000 trie.py:1(NeedMore)
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

【讨论】:

    【解决方案4】:

    您可以将更多列表转换为生成器:

    all( [word_count[letter] <= rack_count[letter] for letter in word] )  
    ...
    sum([score[c] for c in word])
    

    all( word_count[letter] <= rack_count[letter] for letter in word ) 
    ...
    sum( score[c] for c in word )
    

    在循环中,不是每次迭代都创建rask set,而是可以提前创建,它可以是frozenset。

    rack_set = frozenset(rack)
    scored =  ((score_word(word), word) for word in words if set(word).issubset(rask_set) and len(word) > 1 and spellable(word, rack))
    

    rack_count 字典也可以做到这一点。不需要在每次迭代时都创建它。

    rack_count  = count_letters(rack)
    

    【讨论】:

      【解决方案5】:

      更好地组织您的数据。您可以使用这些字母计数向量(好吧,“向量”)预先构建一个树结构,并将其保存到文件中,而不是阅读线性字典并进行比较。

      【讨论】:

        猜你喜欢
        • 2016-12-25
        • 2014-11-29
        • 1970-01-01
        • 2019-10-11
        • 2021-11-03
        • 2017-11-18
        • 1970-01-01
        • 2020-08-06
        • 1970-01-01
        相关资源
        最近更新 更多