我试图在主字符串中找到所有出现的子字符串（所有长度）。我的函数接受一个字符串，然后返回每个子字符串的字典（当然不止一次）和它出现的次数（字典的格式：{substring: # of occurrences, ...}）。我正在使用collections.Counter(s)来帮助我。
这是我的功能：
from collections import Counter
def patternFind(s):
patterns = {}
for index in range(1, len(s)+1)[::-1]:
d = nChunks(s, step=index)
parts = dict(Counter(d))
patterns.update({elem: parts[elem] for elem in parts.keys() if parts[elem] > 1})
return patterns
def nChunks(iterable, start=0, step=1):
return [iterable[i:i+step] for i in range(start, len(iterable), step)]
我有一个字符串data，大约有2500个随机字母（按随机顺序排列）。但是，有2个字符串插入其中（随机点）。说这个字符串是'TEST'。 data.count('TEST')会返回2.但是，patternFind(data)['TEST']会给我一个KeyError。因此，我的程序没有检测到它中的两个字符串。
我做错了什么？谢谢！
编辑：我创建测试实例的方法：
def createNewTest():
n = randint(500, 2500)
x, y = randint(500, n), randint(500, n)
s = ''
for i in range(n):
s += choice(uppercase)
if i == x or i == y: s += "TEST"
return s
答案 0 :(得分：4)
除了您描述的count()方法之外，正则表达式是一种显而易见的替代方法
import re
needle = r'TEST'
haystack = 'khjkzahklahjTESTkahklaghTESTjklajhkhzkhjkzahklahjTESTkahklagh'
pattern = re.compile(needle)
print len(re.findall(pattern, haystack))
如果您需要构建子字符串的字典，可能只能使用这些字符串的子集来完成此操作。假设您知道needle中要查找的data，那么您只需要data的子串字典，其长度与needle相同。这非常快。
from collections import Counter
needle = "TEST"
def gen_sub(s, len_chunk):
for start in range(0, len(s)-len_chunk+1):
yield s[start:start+len_chunk]
data = 'khjkzahklahjTESTkahklaghTESTjklajhkhzkhjkzahklahjTESTkahklaghTESz'
parts = Counter([sub for sub in gen_sub(data, len(needle))])
print parts[needle]
如果你需要计算所有可能的子串，这可行，但速度非常慢：
from collections import Counter
def gen_sub(s):
for start in range(0, len(s)):
for end in range(start+1, len(s)+1):
yield s[start:end]
data = 'khjkzahklahjTESTkahklaghTESTjklajhkhz'
parts = Counter([sub for sub in gen_sub(data)])
print parts['TEST']
答案 1 :(得分：3)
虽然jurgenreza已经解释了为什么你的程序不起作用，但解决方案仍然很慢。如果您只检查知道s重复的子字符串s[:-1]，则可以获得更快的解决方案（通常快一百倍以上）：
from collections import defaultdict
def pfind(prefix, sequences):
collector = defaultdict(list)
for sequence in sequences:
collector[sequence[0]].append(sequence)
for item, matching_sequences in collector.items():
if len(matching_sequences) >= 2:
new_prefix = prefix + item
yield (new_prefix, len(matching_sequences))
for r in pfind(new_prefix, [sequence[1:] for sequence in matching_sequences]):
yield r
def find_repeated_substrings(s):
s0 = s + " "
return pfind("", [s0[i:] for i in range(len(s))])
如果你想要一个字典，你可以这样称呼：
result = dict(find_repeated_substrings(s))
在我的机器上，对于2247个元素的运行，它需要0.02秒，而原始（纠正的）解决方案需要12.72秒。
（请注意，这是一个相当天真的实现;使用索引而不是子串应该更快。）
编辑：以下变体适用于其他序列类型（不仅仅是字符串）。此外，它不需要哨兵元素。
from collections import defaultdict
def pfind(s, length, ends):
collector = defaultdict(list)
if ends[-1] >= len(s):
del ends[-1]
for end in ends:
if end < len(s):
collector[s[end]].append(end)
for key, matching_ends in collector.items():
if len(matching_ends) >= 2:
end = matching_ends[0]
yield (s[end - length: end + 1], len(matching_ends))
for r in pfind(s, length + 1, [end + 1 for end in matching_ends if end < len(s)]):
yield r
def find_repeated_substrings(s):
return pfind(s, 0, list(range(len(s))))
这仍然存在很长的子串将超过递归深度的问题。您可能想要捕获异常。
答案 2 :(得分：2)
在这里你可以找到一个解决方案，它使用string.find()周围的递归包装器来搜索主字符串中子字符串的所有出现。
collectallchuncks()函数将所有子字符串作为键返回defaultdict，并为每个子字符串返回在主字符串中找到子字符串的所有索引的列表。
import collections
# Minimum substring size, may be 1
MINSIZE = 3
# Recursive wrapper
def recfind(p, data, pos, acc):
res = data.find(p, pos)
if res == -1:
return acc
else:
acc.append(res)
return recfind(p, data, res+1, acc)
def collectallchuncks(data):
res = collections.defaultdict(str)
size = len(data)
for base in xrange(size):
for seg in xrange(MINSIZE, size-base+1):
chunk = data[base:base+seg]
if data.count(chunk) > 1:
res[chunk] = recfind(chunk, data, 0, [])
return res
if __name__ == "__main__":
data = 'khjkzahklahjTESTkahklaghTESTjklajhkhzkhjkzahklahjTESTkahklaghTESz'
allchuncks = collectallchuncks(data)
print 'TEST', allchuncks['TEST']
print 'hklag', allchuncks['hklag']
编辑：如果你只需要主字符串中每个子字符串的出现次数，就可以轻松获得它去掉递归函数：
import collections
MINSIZE = 3
def collectallchuncks2(data):
res = collections.defaultdict(str)
size = len(data)
for base in xrange(size):
for seg in xrange(MINSIZE, size-base+1):
chunk = data[base:base+seg]
cnt = data.count(chunk)
if cnt > 1:
res[chunk] = cnt
return res
if __name__ == "__main__":
data = 'khjkzahklahjTESTkahklaghTESTjklajhkhzkhjkzahklahjTESTkahklaghTESz'
allchuncks = collectallchuncks2(data)
print 'TEST', allchuncks['TEST']
print 'hklag', allchuncks['hklag']
答案 3 :(得分：2)
问题出在您的nChunks功能中。它没有给你所有必要的块。
让我们考虑一个测试字符串：
s='1test2345test'
对于大小为4的块，您的nChunks函数会提供此输出：
>>>nChunks(s, step=4)
['1tes', 't234', '5tes', 't']
但你真正想要的是：
>>>def nChunks(iterable, start=0, step=1):
return [iterable[i:i+step] for i in range(len(iterable)-step+1)]
>>>nChunks(s, step=4)
['1tes', 'test', 'est2', 'st23', 't234', '2345', '345t', '45te', '5tes', 'test']
你可以看到这种方式有两个'test'块，你的patternFind(s)就像魅力一样：
>>> patternFind(s)
{'tes': 2, 'st': 2, 'te': 2, 'e': 2, 't': 4, 'es': 2, 'est': 2, 'test': 2, 's': 2}