def sliding(a, n):
    return (a[i:i+n] for i in xrange(len(a) - n + 1))

def substring_count(a, b):
    return sum(s == b for s in sliding(a, len(b)))

assert list(sliding('abcde', 3)) == ['abc', 'bcd', 'cde']    
assert substring_count('ababaa', 'aba') == 2

这能奏效吗？

def count(string, substring):
    n = len(substring)
    cnt = 0
    for i in range(len(string) - n):
        if string[i:i+n] == substring:
            cnt += 1
    return cnt

print count('ababaa', 'aba') # 2

我不知道是否有更有效的解决方案，但这应该是可行的。

count = len(set([string.find('aba',x) for x in range(len(string)) if string.find('aba',x) >= 0]))

在这里，使用re.finditer（）是实现所需功能的最佳方法。

import re 

def get_substring_count(s, sub_s):
    return sum(1 for m in re.finditer('(?=%s)' % sub_s, s))

get_substring_count('ababaa', 'aba')

# 2 as response

以下是您可以使用的函数：

def count(haystack, needle):
    return len([x for x in [haystack[i:j+1] for i in xrange(len(haystack)) for j in xrange(i,len(haystack))] if x == needle])

然后：

>>> count("ababaa", "aba")
2

在切片字符串中循环

def count_substring(string, sub_string):
    l = len(sub_string)
    n = len(string)
    count = sum(1 for i in range(n-l+1) if string[i:i+l].count(sub_string)>0 )
    return count

另一种考虑的方法是利用计数器容器。虽然对于较短的字符串，接受的答案最快，但如果在长字符串中搜索相对较短的子字符串，则计数器方法开始占据优势。此外，如果您需要重构它以对同一主字符串执行多个子字符串计数查询，那么计数器方法开始看起来更有吸引力
例如，使用timeit搜索长度为3的子字符串会得到以下结果：；
主串长度/接受答案/计数器方法
6个字符/4.1us/7.4us
50个字符/24.4us/25us
150个字符/70.7us/64.9us
1500个字符/723us/614us

from collections import Counter

def count_w_overlap(search_string, main_string):
    #Split up main_string into all possible overlap possibilities
    search_len = len(search_string)
    candidates = [main_string[i:i+search_len] for i in range(0, len(main_string) - search_len + 1)]
    #Create the Counter container
    freq_count = Counter(candidates)
    return freq_count[search_string]

暴力手段是正义的

n = len(needle)
count = sum(haystack[i:i+n] == needle for i in range(len(haystack)-n+1))

（这是因为在python中 True 及 False 它们相当于数字 1 及 0 用于大多数用途，包括数学）。
使用regexp可以

count = len(re.findall(needle[:1]+"(?="+re.escape(needle[1:])+")",
                       haystack))

（即使用 a(?=ba) 而不是 aba 也要查找重叠的匹配项）