计算字符串中子字符串出现的次数-IT科技

摘要：问题描述：如何计算 Python 字符串中给定子字符串出现的次数？例如：>>> 'foo bar foo'.numberOfOccurrences('foo') 2 要获取子字符串的索引，请参阅如何查找子字符串的所有出现位置？。解决方案 1：string.count(substring)，例...

问题描述：

如何计算 Python 字符串中给定子字符串出现的次数？

例如：

>>> 'foo bar foo'.numberOfOccurrences('foo')
2

要获取子字符串的索引，请参阅如何查找子字符串的所有出现位置？。

解决方案 1：

string.count(substring)，例如：

>>> "abcdabcva".count("ab")
2

这是针对非重叠出现的。如果您需要计算重叠出现的次数，您最好查看此处的

答案，或者直接查看下面我的其他答案。

解决方案 2：

s = 'arunununghhjj'
sb = 'nun'
results = 0
sub_len = len(sb)
for i in range(len(s)):
    if s[i:i+sub_len] == sb:
        results += 1
print results

解决方案 3：

根据您的真实意思，我建议以下解决方案：

您的意思是用空格分隔的子字符串列表，并且想知道所有子字符串中的子字符串位置编号是多少：

s = 'sub1 sub2 sub3'
s.split().index('sub2')
>>> 1

您的意思是字符串中子字符串的字符位置：

s.find('sub2')
>>> 5

您的意思是子字符串出现的（不重叠的）次数：

s.count('sub2')
>>> 1
s.count('sub')
>>> 3

解决方案 4：

在给定字符串中查找重叠子字符串的最佳方法是使用正则表达式。使用lookahead，它将使用正则表达式库的查找所有重叠匹配项findall()。这里，左边是子字符串，右边是要匹配的字符串。

>>> len(re.findall(r'(?=aa)', 'caaaab'))
3

解决方案 5：

您可以使用两种方式计算频率：

使用：count()str

a.count(b)

或者，您可以使用：

len(a.split(b))-1

其中a是字符串，b是要计算频率的子字符串。

解决方案 6：

为了在 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

我自己检查过这个算法并且它是有效的。

解决方案 7：

场景 1：句子中出现单词。例如：str1 = "This is an example and is easy"。单词“is”的出现。str2 = "is"

count = str1.count(str2)

场景 2：句子中出现模式。

string = "ABCDCDC"
substring = "CDC"

def count_substring(string,sub_string):
    len1 = len(string)
    len2 = len(sub_string)
    j =0
    counter = 0
    while(j < len1):
        if(string[j] == sub_string[0]):
            if(string[j:j+len2] == sub_string):
                counter += 1
        j += 1

    return counter

谢谢！

解决方案 8：

当前涉及方法的最佳答案count实际上不计算重叠出现，也不关心空子字符串。例如：

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

如果考虑重叠子字符串，第一个答案应该是2“否” 1。至于第二个答案，如果空子字符串返回 0 作为答案，则更好。

以下代码负责处理这些事情。

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

解决方案 9：

问题不是很清楚，但我会回答你表面上想问的问题。

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

空字符串 ''。有一个这样的。
对于从 1 到 L 的每个值 A，对于从 A 到 L 的每个值 B，字符串 S[A]..S[B]（含）。这些字符串共有 L + L-1 + L-2 + ... 1 个，总共 0.5L(L+1)。
注意第二项包括S[1]..S[L]，即整个原始字符串S。

因此，长度为 L 的字符串中有 0.5L(L+1) + 1 个子字符串。在 Python 中呈现该表达式，即可得到字符串中存在的子字符串的数量。

解决方案 10：

一种方法是使用。例如，要计算任意组合情况下re.subn出现的次数，您可以执行以下操作：'hello'

import re
_, count = re.subn(r'hello', '', astring, flags=re.I)
print('Found', count, 'occurrences of "hello"')

解决方案 11：

一行带有列表推导的程序怎么样？从技术上讲，它有 93 个字符长，别再说 PEP-8 纯粹主义了。如果是高级代码，regex.findall 答案是最易读的。如果您正在构建一些低级的东西并且不想要依赖项，那么这个答案非常精简。我给出的是重叠答案。显然，如果没有重叠，只需使用 count 作为最高分数答案。

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

解决方案 12：

如果您想计算所有子字符串（包括重叠的），那么请使用此方法。

import re
def count_substring(string, sub_string):
    regex = '(?='+sub_string+')'
    # print(regex)
    return len(re.findall(regex,string))

解决方案 13：

我将保留我接受的答案作为“简单而明显的方法”，但是，它不涵盖重叠事件。找出这些可以通过多次检查切片来完成 - 如下所示：

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

得出的结果为 3。

或者可以通过巧妙地使用正则表达式来完成，如在如何使用正则表达式查找所有重叠匹配中所见- 而且它也可以用于精细的代码高尔夫。

这是我“手工制作”的字符串中模式重叠出现次数的计数，它试图不要太天真（至少它不会在每次交互时创建新的字符串对象）：

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))

解决方案 14：

对于重叠计数我们可以使用：

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)

解决方案 15：

重叠发生：

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

解决方案 16：

您可以使用startswith以下方法：

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

解决方案 17：

以下是适用于非重叠和重叠情况的解决方案。澄清一下：重叠子字符串是指最后一个字符与第一个字符相同的子字符串。

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

解决方案 18：

如果您正在寻找一种适用于每种情况的电源解决方案，则此功能应该有效：

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

解决方案 19：

如果您想找出任何字符串中的子字符串数量；请使用以下代码。代码很容易理解，这就是我跳过注释的原因。:)

string=raw_input()
sub_string=raw_input()
start=0
answer=0
length=len(string)
index=string.find(sub_string,start,length)
while index<>-1:
    start=index+1
    answer=answer+1
    index=string.find(sub_string,start,length)
print answer

解决方案 20：

以下是 Python 3 中的解决方案（不区分大小写）：

s = 'foo bar foo'.upper()
sb = 'foo'.upper()
results = 0
sub_len = len(sb)
for i in range(len(s)):
    if s[i:i+sub_len] == sb:
        results += 1
print(results)

解决方案 21：

s = input('enter the main string: ')
p=input('enter the substring: ')
l=[]
for i in range(len(s)):
    l.append(s[i:i+len(p)])
print(l.count(p))

解决方案 22：

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)

解决方案 23：

def count_substring(string, sub_string):
    k=len(string)
    m=len(sub_string)
    i=0
    l=0
    count=0
    while l<k:
        if string[l:l+m]==sub_string:
            count=count+1
        l=l+1
    return count

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

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

解决方案 24：

已经有 2+ 个人提供了这个解决方案，我甚至对其中一个人投了赞成票，但我的可能是新手最容易理解的。

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

解决方案 25：

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

赋值表达式不仅用于在最后找到的实例之后的字符处启动下一个查找操作，它还提供循环的终止表达式while。str.find()如果未找到子字符串，则返回 -1，而将 1 加到结果中将得到 0，即为假，从而在找不到更多匹配项时退出循环。

# 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

为了进一步优化性能，我们可以在循环外部查找haystack.find一次并将其存储在局部变量中。当匹配次数超过一两次时，这会更快。

# 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

解决方案 26：

我不确定这是否已经被研究过，但我认为这是“一次性”一词的解决方案：

for i in xrange(len(word)):
if word[:len(term)] == term:
    count += 1
word = word[1:]

print count

其中word是您要搜索的单词，term是您要查找的术语

解决方案 27：

string="abc"
mainstr="ncnabckjdjkabcxcxccccxcxcabc"
count=0
for i in range(0,len(mainstr)):
    k=0
    while(k<len(string)):
        if(string[k]==mainstr[i+k]):
            k+=1
        else:
            break   
    if(k==len(string)):
        count+=1;   
print(count)

解决方案 28：

my_string = """Strings are amongst the most popular data types in Python. 
               We can create the strings by enclosing characters in quotes.
               Python treats single quotes the same as double quotes."""

Count = my_string.lower().strip("
").split(" ").count("string")
Count = my_string.lower().strip("
").split(" ").count("strings")
print("The number of occurance of word String is : " , Count)
print("The number of occurance of word Strings is : " , Count)

解决方案 29：

对于一个简单的带有空格分隔的字符串，使用 Dict 会非常快，请参见下面的代码

def getStringCount(mnstr:str, sbstr:str='')->int:
    """ Assumes two inputs string giving the string and 
        substring to look for number of occurances 
        Returns the number of occurances of a given string
    """
    x = dict()
    x[sbstr] = 0
    sbstr = sbstr.strip()
    for st in mnstr.split(' '):
        if st not in [sbstr]:
            continue
        try:
            x[st]+=1
        except KeyError:
            x[st] = 1
    return x[sbstr]

s = 'foo bar foo test one two three foo bar'
getStringCount(s,'foo')

解决方案 30：

以下逻辑适用于所有字符串和特殊字符

def cnt_substr(inp_str, sub_str):
    inp_join_str = ''.join(inp_str.split())
    sub_join_str = ''.join(sub_str.split())

    return inp_join_str.count(sub_join_str)

print(cnt_substr("the sky is   $blue and not greenthe sky is   $blue and not green", "the sky"))