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

if __name__ == '__main__':
    string = input().strip()
    sub_string = input().strip()

    count = count_substring(string, sub_string)
    print(count)

我将把我接受的答案作为“简单而明显的方法”，然而，它不包括重叠的情况。 通过多次检查切片就可以简单地找出这些问题——比如:

sum("GCAAAAAGH"[i:].startswith("AAA") for i in range(len("GCAAAAAGH")))

结果是3。

或者可以通过使用正则表达式来实现，如如何使用regex来查找所有重叠的匹配项中所示——它也可以用于良好的代码高尔夫。

这是我的“手工”计数模式重叠出现在一个字符串，它试图不是非常幼稚(至少它不会在每次交互时创建新的字符串对象):

def find_matches_overlapping(text, pattern):
    lpat = len(pattern) - 1
    matches = []
    text = array("u", text)
    pattern = array("u", pattern)
    indexes = {}
    for i in range(len(text) - lpat):
        if text[i] == pattern[0]:
            indexes[i] = -1
        for index, counter in list(indexes.items()):
            counter += 1
            if text[i] == pattern[counter]:
                if counter == lpat:
                    matches.append(index)
                    del indexes[index]
                else:
                    indexes[index] = counter
            else:
                del indexes[index]
    return matches
            
def count_matches(text, pattern):
    return len(find_matches_overlapping(text, pattern))

这里有一个解决方案，适用于非重叠和重叠的情况。为了澄清:重叠子字符串是指其最后一个字符与其第一个字符相同的子字符串。

def substr_count(st, sub):
    # If a non-overlapping substring then just
    # use the standard string `count` method
    # to count the substring occurences
    if sub[0] != sub[-1]:
        return st.count(sub)

    # Otherwise, create a copy of the source string,
    # and starting from the index of the first occurence
    # of the substring, adjust the source string to start
    # from subsequent occurences of the substring and keep
    # keep count of these occurences
    _st = st[::]
    start = _st.index(sub)
    cnt = 0

    while start is not None:
        cnt += 1
        try:
            _st = _st[start + len(sub) - 1:]
            start = _st.index(sub)
        except (ValueError, IndexError):
            return cnt

    return cnt

重叠出现:

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

对于重叠计数，我们可以使用use:

def count_substring(string, sub_string):
    count=0
    beg=0
    while(string.find(sub_string,beg)!=-1) :
        count=count+1
        beg=string.find(sub_string,beg)
        beg=beg+1
    return count

对于非重叠的情况，我们可以使用count()函数:

string.count(sub_string)

这个问题不是很清楚，但我可以回答你表面上的问题。

一个长度为L个字符的字符串S，其中S[1]是字符串的第一个字符，S[L]是最后一个字符，它有以下子字符串:

空字符串”。这里有一个。 对于从1到L的每一个值A，对于从A到L的每一个值B，字符串S[A]..S[B] (包容)。有L + L-1 + L-2 +…1个字符串，对于a 共0.5*L*(L+1)。 注意，第二项包括S[1]..S[L]， 即整个原始字符串S。

所以，在长度为L的字符串中有0.5*L*(L+1) +1个子字符串，在Python中呈现这个表达式，你就有了字符串中出现的子字符串的数量。