计算子字符串在字符串中出现的次数

string.count(substring)，如在:

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

这是针对非重叠次事件。
如果你需要计算重叠出现的次数，你最好检查答案在这里，或只检查我的另一个答案如下.

根据你的真正意思，我提出以下解决方案:

1. 你的意思是一个空格分隔子字符串的列表，并想知道所有子字符串中的子字符串位置编号是什么:

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

2. You mean the char-position of the sub-string in the string:

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

3. You mean the (non-overlapping) counts of appearance of a su-bstring:

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

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

一个长度为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中呈现这个表达式，你就有了字符串中出现的子字符串的数量。

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

我将把我接受的答案作为“简单而明显的方法”——然而，这并不包括重叠的情况。 通过多次检查切片就可以简单地找出这些问题——比如: sum("GCAAAAAGH"[i:]. startwith ("AAA") for i in range(len("GCAAAAAGH")))

(它产生3)-它可以通过巧妙地使用正则表达式来实现，如在Python正则表达式找到所有重叠匹配?中所看到的那样-而且它还可以使代码打高尔夫- 这是我的“手工”计数的重叠的模式在一个字符串，试图不是非常幼稚(至少它不创建新的字符串对象在每次交互):

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

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

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


print count

哪里词是你要搜索的词，术语是你要找的词

重叠出现:

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

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)

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

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

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

在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

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

如果你想知道任何字符串内的子字符串的计数;请使用以下代码。 代码很容易理解，这就是我跳过注释的原因。:) < / p >

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

你可以用两种方法计算频率:

1. 使用str中的count():

   a.count(b) < / p >

2. 或者，你可以使用:

   len(a.split(b))-1 < / p >

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

对于重叠计数，我们可以使用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)

import re
d = [m.start() for m in re.finditer(seaching, string)]
print (d)

这将查找子字符串在字符串中被找到的次数并显示索引。

在给定字符串中查找重叠子字符串的最佳方法是使用python正则表达式，它将使用正则表达式库找到所有重叠匹配。这里是如何做到左边是子字符串，在右边你将提供字符串匹配

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

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

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("\n").split(" ").count("string")
Count = my_string.lower().strip("\n").split(" ").count("strings")
print("The number of occurance of word String is : " , Count)
print("The number of occurance of word Strings is : " , Count)

带列表理解的一行代码怎么样?从技术上讲，它有93个字符长，不需要PEP-8的纯粹性。正则表达式。Findall答案是最易读的，如果它是一段高级代码。如果您正在构建低级别的东西，并且不想要依赖关系，那么这个方法非常简洁。我给出了重叠的答案。很明显，如果没有重叠的话，使用最高分的答案。

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

下面的逻辑将适用于所有字符串&特殊字符

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

冒着被否决的风险，因为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

你可以使用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

count = str1.count(str2)

场景二:句子中出现句式。

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

谢谢!

对于一个有空格分隔的简单字符串，使用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')

下面是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)

j = 0
while i < len(string):
sub_string_out = string[i:len(sub_string)+j]
if sub_string == sub_string_out:
count += 1
i += 1
j += 1
return count

#counting occurence of a substring in another string (overlapping/non overlapping)
s = input('enter the main string: ')# e.g. 'bobazcbobobegbobobgbobobhaklpbobawanbobobobob'
p=input('enter the substring: ')# e.g. 'bob'


counter=0
c=0


for i in range(len(s)-len(p)+1):
for j in range(len(p)):
if s[i+j]==p[j]:
if c<len(p):
c=c+1
if c==len(p):
counter+=1
c=0
break
continue
else:
break
print('number of occurences of the substring in the main string is: ',counter)

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

如果你想计算所有的子字符串(包括重叠的)，那么使用这个方法。

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

这将列出字符串中所有出现的(也是重叠的)并对它们进行计数

def num_occ(str1, str2):
l1, l2 = len(str1), len(str2)
return len([str1[i:i + l2] for i in range(l1 - l2 + 1) if str1[i:i + l2] == str2])

例子:

str1 ='abcabcd'
str2 = 'bc'

将创建这个列表，但只保存大胆的值:

[ab， 公元前, ca, ab， 公元前, cd]

返回:

len([bc, bc])

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

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

如果你想数整个字符串，这是可行的。

stri_count="If you're looking to count the whole string this can works"
print(len(stri_count))

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


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


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

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

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