在Python 3中，要查找字符串中子字符串的重叠情况，该算法将执行以下操作:

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

我亲自检查了这个算法，它是有效的。

使用Python 3.8中引入的赋值操作符，我们可以编写一个简短的函数，在循环中使用str.find()来查找字符串中目标子字符串的重叠实例。已经有一些其他的解决方案使用相同的方法，但这个更短，更快。

赋值表达式不仅用于在last-found实例之后的字符处开始下一个查找操作，还为while循环提供了终端表达式。Str.find()如果没有找到子字符串，则返回-1，在此基础上加上1将得到0，这是false，因此在没有找到更多匹配时退出循环。

# count overlapping occurrences of a substring in a string
def count_overlapping(haystack, needle, start=0, count=0):
    while start := haystack.find(needle, start) + 1:
        count += 1
    return count

print(count_overlapping("moomoooo", "oo"))    # 4

为了进一步优化性能，我们可以查阅草堆。在循环外找到一次，并将其存储在一个局部变量中。这将是更快时，有超过一对夫妇的比赛。

# count overlapping occurrences of a substring in a string
def count_overlapping(haystack, needle, start=0, count=0):
    haystack_find = haystack.find
    while start := haystack_find(needle, start) + 1:
        count += 1
    return count

目前涉及方法计数的最佳答案并不能真正计算重叠出现的次数，也不关心空子字符串。 例如:

>>> a = 'caatatab'
>>> b = 'ata'
>>> print(a.count(b)) #overlapping
1
>>>print(a.count('')) #empty string
9

如果我们考虑重叠的子字符串，第一个答案应该是2而不是1。 对于第二个答案，如果空子字符串返回0作为asnwer会更好。

下面的代码处理这些事情。

def num_of_patterns(astr,pattern):
    astr, pattern = astr.strip(), pattern.strip()
    if pattern == '': return 0

    ind, count, start_flag = 0,0,0
    while True:
        try:
            if start_flag == 0:
                ind = astr.index(pattern)
                start_flag = 1
            else:
                ind += 1 + astr[ind+1:].index(pattern)
            count += 1
        except:
            break
    return count

现在当我们运行它时:

>>>num_of_patterns('caatatab', 'ata') #overlapping
2
>>>num_of_patterns('caatatab', '') #empty string
0
>>>num_of_patterns('abcdabcva','ab') #normal
2

如果你正在寻找一个适用于所有情况的幂解，这个函数应该工作:

def count_substring(string, sub_string):
    ans = 0
    for i in range(len(string)-(len(sub_string)-1)):
        if sub_string == string[i:len(sub_string)+i]:
            ans += 1
    return ans

重叠出现:

def olpcount(string,pattern,case_sensitive=True):
    if case_sensitive != True:
        string  = string.lower()
        pattern = pattern.lower()
    l = len(pattern)
    ct = 0
    for c in range(0,len(string)):
        if string[c:c+l] == pattern:
            ct += 1
    return ct

test = 'my maaather lies over the oceaaan'
print test
print olpcount(test,'a')
print olpcount(test,'aa')
print olpcount(test,'aaa')

结果:

my maaather lies over the oceaaan
6
4
2

在Python 3中，要查找字符串中子字符串的重叠情况，该算法将执行以下操作:

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

我亲自检查了这个算法，它是有效的。