blocks|key|461266|text|s+=+'arunununghhjj'
sb+=+'nun'
results+=+0
sub_len+=+len(sb)
for+i+in+range(len(s)):
++++if+s[i:i%2Bsub_len]+==+sb:
++++++++results+%2B=+1
print+results|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|461267|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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
</code></pre>

blocks|key|461355|text|我将保留我接受的答案作为“简单和明显的方法来做这件事”-但是，这不包括重叠的情况。通过多次检查切片，可以很容易地找到这些片段-如:+sum("GCAAAAAGH"i:.startswith("AAA")+for+i+in+range(len(“GCAAAAAGH”)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|461356|(结果为3)+-可以通过技巧使用正则表达式来实现，可以在Python+regex+find+all+overlapping+matches?上看到-它也可以用于精细的代码打球-这是我对字符串中重叠模式的“手工”计数，它尽量不是非常幼稚(至少它不会在每次交互时创建新的字符串对象)：|offset|length|461357|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+%2B=+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))|code-block|syntax|javascript|461358|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/5616822/python-regex-find-all-overlapping-matches^0|0|S|16|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

I will keep my accepted answer as the "simple and obvious way to do it" - however, that does not cover overlapping occurrences. 
Finding out those can be done naively, with multiple checking of the slices - as in:
 sum("GCAAAAAGH"[i:].startswith("AAA") for i in range(len("GCAAAAAGH")))

(which yields 3) - it can be done by trick use of regular expressions, as can be seen at <a href="https://stackoverflow.com/questions/5616822/python-regex-find-all-overlapping-matches">Python regex find all overlapping matches?</a> - and it can also make for fine code golfing -
This is my "hand made" count for overlappingocurrences of patterns in a string which tries not to be extremely naive (at least it does not create new string objects at each interaction):

<pre><code>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))
</code></pre>

blocks|key|461376|text|string="abc"
mainstr="ncnabckjdjkabcxcxccccxcxcabc"
count=0
for+i+in+range(0,len(mainstr)):
++++k=0
++++while(k<len(string)):
++++++++if(string[k]==mainstr[i%2Bk]):
++++++++++++k%2B=1
++++++++else:
++++++++++++break+++
++++if(k==len(string)):
++++++++count%2B=1;+++
print(count)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|461377|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

blocks|key|676668|text|目前涉及方法count的最佳答案并不真正计入重叠出现的次数，也不关心空子字符串。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|676669|>>>+a+=+'caatatab'
>>>+b+=+'ata'
>>>+print(a.count(b))+#overlapping
1
>>>print(a.count(''))+#empty+string
9|code-block|syntax|javascript|676670|如果我们考虑重叠的子串，第一个答案应该是2而不是1。至于第二个答案，如果空子串返回0作为输入，效果会更好。|676671|下面的代码负责处理这些事情。|676672|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+%2B=+1+%2B+astr[ind%2B1:].index(pattern)
++++++++++++count+%2B=+1
++++++++except:
++++++++++++break
++++return+count|676673|现在当我们运行它时：|676674|>>>num_of_patterns('caatatab',+'ata')+#overlapping
2
>>>num_of_patterns('caatatab',+'')+#empty+string
0
>>>num_of_patterns('abcdabcva','ab')+#normal
2|676675|entityMap^0|6|5|0|0|K|1|O|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|17|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|U|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|V|$]]

The current best answer involving method <code>count</code> doesn't really count for overlapping occurrences and doesn't care about empty sub-strings as well.
For example:
 

<pre class="lang-python prettyprint-override"><code>&gt;&gt;&gt; a = 'caatatab'
&gt;&gt;&gt; b = 'ata'
&gt;&gt;&gt; print(a.count(b)) #overlapping
1
&gt;&gt;&gt;print(a.count('')) #empty string
9
</code></pre>

The first answer should be <code>2</code> not <code>1</code>, if we consider the overlapping substrings.
As for the second answer it's better if an empty sub-string returns 0 as the asnwer.

The following code takes care of these things.

<pre class="lang-python prettyprint-override"><code>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
</code></pre>

Now when we run it:

<pre class="lang-python prettyprint-override"><code>&gt;&gt;&gt;num_of_patterns('caatatab', 'ata') #overlapping
2
&gt;&gt;&gt;num_of_patterns('caatatab', '') #empty string
0
&gt;&gt;&gt;num_of_patterns('abcdabcva','ab') #normal
2
</code></pre>

blocks|key|676765|text|要在Python+3中查找字符串中的子字符串的重叠出现，此算法将执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|676766|def+count_substring(string,sub_string):
++++l=len(sub_string)
++++count=0
++++for+i+in+range(len(string)-len(sub_string)%2B1):
++++++++if(string[i:i%2Blen(sub_string)]+==+sub_string+):++++++
++++++++++++count%2B=1
++++return+count++|code-block|syntax|javascript|676767|我自己检查了这个算法，它起作用了。|676768|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

To find overlapping occurences of a substring in a string in Python 3, this algorithm will do:

<pre><code>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 
</code></pre>

I myself checked this algorithm and it worked.

blocks|key|676852|text|如果你想知道任何字符串中的子字符串的数量，请使用下面的代码。代码很容易理解，这就是我跳过注释的原因。:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|676853|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%2B1
++++answer=answer%2B1
++++index=string.find(sub_string,start,length)
print+answer|code-block|syntax|javascript|676854|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to find out the count of substring inside any string; please use below code.
The code is easy to understand that's why i skipped the comments. :)

<pre><code>string=raw_input()
sub_string=raw_input()
start=0
answer=0
length=len(string)
index=string.find(sub_string,start,length)
while index&lt;&gt;-1:
 start=index+1
 answer=answer+1
 index=string.find(sub_string,start,length)
print answer
</code></pre>

blocks|key|461742|text|对于重叠计数，我们可以使用use：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|461743|def+count_substring(string,+sub_string):
++++count=0
++++beg=0
++++while(string.find(sub_string,beg)!=-1)+:
++++++++count=count%2B1
++++++++beg=string.find(sub_string,beg)
++++++++beg=beg%2B1
++++return+count|code-block|syntax|javascript|461744|对于不重叠的情况，我们可以使用count()函数：|461745|string.count(sub_string)|461746|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

For overlapping count we can use use:

<pre><code>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
</code></pre>

For non-overlapping case we can use count() function:

<pre><code>string.count(sub_string)
</code></pre>

blocks|key|461804|text|import+re
d+=+[m.start()+for+m+in+re.finditer(seaching,+string)]+
print+(d)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|461805|这将查找在字符串中找到的子字符串的次数，并显示索引。|unstyled|461806|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>import re
d = [m.start() for m in re.finditer(seaching, string)] 
print (d)
</code></pre>

This finds the number of times sub string found in the string and displays index.

blocks|key|676999|text|在给定字符串中查找重叠子字符串的最好方法是使用python正则表达式，它将使用正则表达式库查找所有的重叠匹配。下面是如何执行此操作左侧是子字符串，右侧是要匹配的字符串|type|unstyled|depth|inlineStyleRanges|entityRanges|data|677000|print+len(re.findall('(?=aa)','caaaab'))
3|code-block|syntax|javascript|677001|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The best way to find overlapping sub-string in a given string is to use the python regular expression it will find all the overlapping matching using the regular expression library. Here is how to do it left is the substring and in right you will provide the string to match

<pre><code>print len(re.findall('(?=aa)','caaaab'))
3
</code></pre>

blocks|key|677049|text|一种方法是使用re.subn。例如，要计算在任何混合情况下出现'hello'的次数，您可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|677050|import+re
_,+count+=+re.subn(r'hello',+'',+astring,+flags=re.I)
print('Found',+count,+'occurrences+of+"hello"')|code-block|syntax|javascript|677051|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3.6/library/re.html#re.subn^0|7|7|V|7|7|7|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

One way is to use <a href="https://docs.python.org/3.6/library/re.html#re.subn" rel="nofollow noreferrer"><code>re.subn</code></a>. For example, to count the number of
occurrences of <code>'hello'</code> in any mix of cases you can do:

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

blocks|key|461940|text|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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|461941|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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)
</code></pre>

blocks|key|677102|text|使用列表理解的一行代码怎么样？从技术上讲，它有93个字符，让我省去PEP-8的纯粹主义。如果regex.findall是一段高级代码，那么它的可读性是最好的。如果你正在构建一些低层次的东西，并且不想要依赖关系，那么这个是非常简陋的。我给出了重叠的答案。显然，如果没有重叠，只需使用count+like最高分答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|677103|def+count_substring(string,+sub_string):
++++return+len([i+for+i+in+range(len(string))+if+string[i:i%2Blen(sub_string)]+==+sub_string])|code-block|syntax|javascript|677104|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

How about a one-liner with a list comprehension? Technically its 93 characters long, spare me PEP-8 purism. The regex.findall answer is the most readable if its a high level piece of code. If you're building something low level and don't want dependencies, this one is pretty lean and mean. I'm giving the overlapping answer. Obviously just use count like the highest score answer if there isn't overlap.

<pre><code>def count_substring(string, sub_string):
 return len([i for i in range(len(string)) if string[i:i+len(sub_string)] == sub_string])
</code></pre>

blocks|key|462044|text|下面的逻辑将适用于所有字符串和特殊字符|type|unstyled|depth|inlineStyleRanges|entityRanges|data|462045|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"))|code-block|syntax|javascript|462046|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Below logic will work for all string &amp; special characters

<pre class="lang-py prettyprint-override"><code>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"))
</code></pre>

blocks|key|462071|text|冒着被否决的风险，因为2%2B其他人已经提供了这个解决方案。我甚至选了他们中的一个。但对于新手来说，我的可能是最容易理解的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|462072|def+count_substring(string,+sub_string):
++++slen++=+len(string)
++++sslen+=+len(sub_string)
++++range_s+=+slen+-+sslen+%2B+1
++++count+=+0
++++for+i+in+range(range_s):
++++++++if+(string[i:i%2Bsslen]+==+sub_string):
++++++++++++count+%2B=+1
++++return+count|code-block|syntax|javascript|462073|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Risking a downvote because 2+ others have already provided this solution. I even upvoted one of them. But mine is probably the easiest for newbies to understand.

<pre><code>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
</code></pre>

blocks|key|677209|text|您可以使用startswith方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|677210|def+count_substring(string,+sub_string):
++++x+=+0
++++for+i+in+range(len(string)):
++++++++if+string[i:].startswith(sub_string):
++++++++++++x+%2B=+1
++++return+x|code-block|syntax|javascript|677211|entityMap|0|LINK|mutability|MUTABLE|url|https://www.tutorialspoint.com/python/string_startswith.htm^0|5|A|5|A|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

You could use the <a href="https://www.tutorialspoint.com/python/string_startswith.htm" rel="nofollow noreferrer"><code>startswith</code></a> method:

<pre class="lang-py prettyprint-override"><code>def count_substring(string, sub_string):
 x = 0
 for i in range(len(string)):
 if string[i:].startswith(sub_string):
 x += 1
 return x
</code></pre>

blocks|key|462130|text|场景1:句子中出现一个单词。例如：str1+=+"This+is+an+example+and+is+easy"。"is“这个词的出现。让str2+=+"is"|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|462131|count+=+str1.count(str2)|code-block|syntax|javascript|462132|场景2:句子中出现模式。|462133|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%2Blen2]+==+sub_string):
++++++++++++++++counter+%2B=+1
++++++++j+%2B=+1

++++return+counter|462134|谢谢!|462135|entityMap^0|H|13|1X|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

Scenario 1: Occurrence of a word in a sentence.
eg: <code>str1 = "This is an example and is easy"</code>. The occurrence of the word "is". lets <code>str2 = "is"</code>

<pre><code>count = str1.count(str2)
</code></pre>

Scenario 2 : Occurrence of pattern in a sentence.

<pre><code>string = "ABCDCDC"
substring = "CDC"

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

 return counter
</code></pre>

Thanks!

blocks|key|462159|text|对于带有空格分隔的简单字符串，使用Dict会非常快，请参见以下代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|462160|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]%2B=1
++++++++except+KeyError:
++++++++++++x[st]+=+1
++++return+x[sbstr]

s+=+'foo+bar+foo+test+one+two+three+foo+bar'
getStringCount(s,'foo')|code-block|syntax|javascript|462161|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For a simple string with space delimitation, using Dict would be quite fast, please see the code as below

<pre><code>def getStringCount(mnstr:str, sbstr:str='')-&gt;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')
</code></pre>

blocks|key|677322|text|以下是Python+3中的解决方案，不区分大小写：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|677323|s+=+'foo+bar+foo'.upper()
sb+=+'foo'.upper()
results+=+0
sub_len+=+len(sb)
for+i+in+range(len(s)):
++++if+s[i:i%2Bsub_len]+==+sb:
++++++++results+%2B=+1
print(results)|code-block|syntax|javascript|677324|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's the solution in Python 3 and case insensitive:

<pre><code>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)
</code></pre>

blocks|key|677328|text|j+=+0
++++while+i+<+len(string):
++++++++sub_string_out+=+string[i:len(sub_string)%2Bj]
++++++++if+sub_string+==+sub_string_out:
++++++++++++count+%2B=+1
++++++++i+%2B=+1
++++++++j+%2B=+1
++++return+count|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|677329|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>j = 0
 while i &lt; 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
</code></pre>

blocks|key|462306|text|#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)%2B1):
++++for+j+in+range(len(p)):
++++++++if+s[i%2Bj]==p[j]:
++++++++++++if+c<len(p):
++++++++++++++++c=c%2B1
++++++++++++++++if+c==len(p):
++++++++++++++++++++counter%2B=1
++++++++++++++++++++c=0
++++++++++++++++++++break
++++++++++++++++continue
++++++++else:
++++++++++++break
print('number+of+occurences+of+the+substring+in+the+main+string+is:+',counter)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|462307|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#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&lt;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)
</code></pre>

blocks|key|678009|text|s+=+input('enter+the+main+string:+')
p=input('enter+the+substring:+')
l=[]
for+i+in+range(len(s)):
++++l.append(s[i:i%2Blen(p)])
print(l.count(p))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|678010|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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))
</code></pre>

blocks|key|462372|text|如果你想计算所有的子串(包括重叠的)，那么使用这个方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|462373|import+re
def+count_substring(string,+sub_string):
++++regex+=+'(?='%2Bsub_string%2B')'
++++#+print(regex)
++++return+len(re.findall(regex,string))|code-block|syntax|javascript|462374|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to count all the sub-string (including overlapped) then use this method.

<pre class="lang-py prettyprint-override"><code>import re
def count_substring(string, sub_string):
 regex = '(?='+sub_string+')'
 # print(regex)
 return len(re.findall(regex,string))
</code></pre>

blocks|key|462420|text|这里有一个解决方案，既适用于非重叠事件，也适用于重叠事件。需要说明的是:重叠子字符串的最后一个字符与其第一个字符相同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|462421|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+%2B=+1
++++++++try:
++++++++++++_st+=+_st[start+%2B+len(sub)+-+1:]
++++++++++++start+=+_st.index(sub)
++++++++except+(ValueError,+IndexError):
++++++++++++return+cnt

++++return+cnt|code-block|syntax|javascript|462422|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a solution that works for both non-overlapping and overlapping occurrences. To clarify: an overlapping substring is one whose last character is identical to its first character.

<pre><code>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
</code></pre>

blocks|key|462445|text|def+count_substring(string,+sub_string):
++++inc+=+0
++++for+i+in+range(0,+len(string)):
++++++++slice_object+=+slice(i,len(sub_string)%2Bi)
++++++++count+=+len(string[slice_object])
++++++++if(count+==+len(sub_string)):
++++++++++++if(sub_string+==+string[slice_object]):
++++++++++++++++inc+=+inc+%2B+1
++++return+inc

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

++++count+=+count_substring(string,+sub_string)
++++print(count)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|462446|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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)
</code></pre>

blocks|key|678123|text|如果你想计算整个字符串，这是可行的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|678124|stri_count="If+you're+looking+to+count+the+whole+string+this+can+works"
print(len(stri_count))|code-block|syntax|javascript|678125|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you're looking to count the whole string this can works.

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

blocks|key|678142|text|def+count_substring(string,+sub_string):
++++counterList=[+1+for+i+in+range(len(string)-len(sub_string)%2B1)+if+string[i:i%2Blen(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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|678143|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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)
</code></pre>

blocks|key|678175|text|如果您正在寻找一种适用于所有情况的power解决方案，则此函数应该有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|678176|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)%2Bi]:
++++++++++++ans+%2B=+1
++++return+ans|code-block|syntax|javascript|678177|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you're looking for a power solution that works every case this function should work:

<pre><code>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
</code></pre>

blocks|key|678189|text|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%2Bm]==sub_string:
++++++++++++count=count%2B1
++++++++l=l%2B1
++++return+count

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

++++count+=+count_substring(string,+sub_string)
++++print(count)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|678190|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def count_substring(string, sub_string):
 k=len(string)
 m=len(sub_string)
 i=0
 l=0
 count=0
 while l&lt;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)
</code></pre>

How can I count the number of times a given substring is present within a string in Python?

For example:

<pre><code>&gt;&gt;&gt; 'foo bar foo'.numberOfOccurrences('foo')
2
</code></pre>

Count number of occurrences of a substring in a string

Python

在Python中，如何计算给定子字符串在字符串中出现的次数？例如：>>> 'foo bar foo'.numberOfOccurrences('foo')2

问统计子串在字符串中出现的次数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问统计子串在字符串中出现的次数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问统计子串在字符串中出现的次数
EN