Question

我想弄清楚字符串中出现字符串的次数。例如：

nStr = '000123000123'

假设我想要找到的字符串是123.显然它在nStr中出现了两次但是我在将这个逻辑实现到Python时遇到了麻烦。我现在得到了什么：

pattern = '123'
count = a = 0
while pattern in nStr[a:]:
    a = nStr[a:].find(pattern)+1
    count += 1
return count

它应该返回的答案是2.我现在陷入无限循环。

我刚才意识到数量是一个更好的方法，但出于好奇，有没有人看到类似于我已经得到的方法呢？

Answer 1

使用str.count：

>>> nStr = '000123000123'
>>> nStr.count('123')
2

代码的工作版本：

nStr = '000123000123'
pattern = '123'
count =0
flag=True
start=0
while flag:
    a = nStr.find(pattern,start)  # find() returns -1 if the word is not found, 
                                  #start i the starting index from the search starts(default value is 0)
    if a==-1:          #if pattern not found set flag to False
        flag=False
    else:               # if word is found increase count and set starting index to a+1
        count+=1        
        start=a+1
print(count)

Answer 2

此处显示的count()和这些方法的问题是重叠子字符串的情况。

例如："aaaaaa".count("aaa")返回2

如果您希望它返回4 [(aaa)aaa, a(aaa)aa, aa(aaa)a, aaa(aaa)]，您可以尝试这样的事情：

def my_count(string, substring):
    string_size = len(string)
    substring_size = len(substring)
    count = 0
    for i in xrange(0,string_size-substring_size+1):
        if string[i:i+substring_size] == substring:
            count+=1
    return count

my_count("aaaaaa", "aaa")
# 4

不知道是否有更好的方法，但发布只是为了澄清count()的工作方式。

Answer 3

import re

pattern = '123'

n =re.findall(pattern, string)

我们可以说子串'pattern'在'string'中出现len（n）次。

Answer 4

如果您正在寻找如何解决重叠案例的问题。

s = 'azcbobobegghaklbob'
str = 'bob'
results = 0
sub_len = len(str) 
for i in range(len(s)):
    if s[i:i+sub_len] == str: 
        results += 1
print (results)

将导致3，因为：[azc（bob）obegghaklbob] [azcbo（bob）egghaklbob] [azcbobobegghakl（bob）]

Answer 5

我很新，但是我认为这是一个很好的解决方案？也许？

def count_substring(str, sub_str):
    count = 0
    for i, c in enumerate(str):
        if sub_str == str[i:i+2]:
            count += 1
    return count

Answer 6

string.count（substring）在重叠时无效。

我的方法：

def count_substring(string, sub_string):

    length = len(string)
    counter = 0
    for i in range(length):
        for j in range(length):
            if string[i:j+1] == sub_string:
                counter +=1
    return counter

Answer 7

每次循环都不会更改a。你应该把：

a += nStr[a:].find(pattern)+1

...而不是：

a = nStr[a:].find(pattern)+1

Answer 8

def count_substring(string, substring):
         c=0
         l=len(sub_string)
         for i in range(len(string)):
                 if string [i:i+l]==sub_string:
                          c=c+1
         return c
string=input().strip()
sub_string=input().strip()

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

Answer 9

如@JoãoPesce和@gaurav所述，count()在子字符串重叠的情况下不起作用，请尝试一下...

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

Answer 10

通常，我使用枚举来解决此类问题：

def count_substring(string, sub_string):
        count = 0
        for i, j in enumerate(string):
            if sub_string in string[i:i+3]:
                count = count + 1
        return count

Answer 11

def countOccurance(str,pat):
    count=0
    wordList=str.split()
    for word in wordList:
        if pat in word:
            count+=1
    return count

Answer 12

def count（sub_string，string）：

count = 0
ind = string.find(sub_string)

while True:
    if ind > -1:
        count += 1
        ind = string.find(sub_string,ind + 1)
    else:
        break
return count

确定Python中字符串中出现子字符串的次数

12 个答案: