Python 重复出现的字符串计数

计算给定字符串（包括Python中的重叠）出现次数的最佳方法是什么？这是一种方式：

def function(string, str_to_search_for):
      count = 0
      for x in xrange(len(string) - len(str_to_search_for) + 1):
           if string[x:x+len(str_to_search_for)] == str_to_search_for:
                count += 1
      return count


function('1011101111','11')

此方法返回5

Python中有更好的方法吗？

这可能更快，因为它在C中进行比较：

def occurrences(string, sub):
    count = start = 0
    while True:
        start = string.find(sub, start) + 1
        if start > 0:
            count+=1
        else:
            return count

这可能会更快，因为它在C中进行比较：

def occurrences(string, sub):
    count = start = 0
    while True:
        start = string.find(sub, start) + 1
        if start > 0:
            count+=1
        else:
            return count

def count_重叠（字符串，查找）：
开始=0
匹配项=0
尽管如此：
start=string.find（查找，开始）
如果开始<0：
打破
开始+=1
匹配项+=1
复赛
打印计数重叠（'abrabra'，'abra'）

def计数重叠（字符串，查找）：
开始=0
匹配项=0
尽管如此：
start=string.find（查找，开始）
如果开始<0：
打破
开始+=1
匹配项+=1
复赛
打印计数重叠（'abrabra'，'abra'）

如果您不想将整个匹配列表加载到内存中，这绝不会是一个问题！如果您真的愿意，您可以这样做：

>>> sum(1 for _ in re.finditer('(?=11)', text))
5

作为一个函数（

re.escape

确保子字符串不会干扰正则表达式）：

def出现次数（文本，子项）： 返回len（re.findall（'（？={0}）'.format（re.escape（sub）），text）） >>>事件（文本“11”） 5. 如果您不想将整个匹配列表加载到内存中，这绝不会是一个问题！如果您真的愿意，您可以这样做：

>>> sum(1 for _ in re.finditer('(?=11)', text))
5

作为一个函数（

re.escape

确保子字符串不会干扰正则表达式）：

def出现次数（文本，子项）： 返回len（re.findall（'（？={0}）'.format（re.escape（sub）），text）） >>>事件（文本“11”） 5.

---

如果要计算长度为5的置换计数（如果需要调整不同的长度）：

---

如果要计算长度为5的置换计数（如果需要调整不同的长度）：

---

我对课程中鲍勃的问题的回答是：

s = 'azcbobobegghaklbob'
total = 0
for i in range(len(s)-2):
    if s[i:i+3] == 'bob':
        total += 1
print 'number of times bob occurs is: ', total

---

我对课程中鲍勃的问题的回答是：

s = 'azcbobobegghaklbob'
total = 0
for i in range(len(s)-2):
    if s[i:i+3] == 'bob':
        total += 1
print 'number of times bob occurs is: ', total

---

函数，该函数将两个字符串作为输入，并计算子字符串在字符串中出现的次数，包括重叠。为了检查sub是否是子字符串，我在操作符中使用了

def count_Occurrences(string, sub):
    count=0
    for i in range(0, len(string)-len(sub)+1):
        if sub in string[i:i+len(sub)]:
            count=count+1
    print 'Number of times sub occurs in string (including overlaps): ', count

函数，该函数将两个字符串作为输入，并计算子字符串在字符串中出现的次数，包括重叠。为了检查sub是否是子字符串，我在

操作符中使用了

def count_Occurrences(string, sub):
    count=0
    for i in range(0, len(string)-len(sub)+1):
        if sub in string[i:i+len(sub)]:
            count=count+1
    print 'Number of times sub occurs in string (including overlaps): ', count

这是我的edX MIT“find bob”*解决方案（*查找名为s的字符串中的“bob”出现次数），基本上统计给定子字符串的重叠出现次数：

s = 'azcbobobegghakl'
count = 0

while 'bob' in s:
    count += 1 
    s = s[(s.find('bob') + 2):]

print "Number of times bob occurs is: {}".format(count)

这是我的edX MIT“find bob”*解决方案（*查找名为s的字符串中的“bob”出现次数），基本上统计给定子字符串的重叠出现次数：

s = 'azcbobobegghakl'
count = 0

while 'bob' in s:
    count += 1 
    s = s[(s.find('bob') + 2):]

print "Number of times bob occurs is: {}".format(count)

对于一个重复的，我决定用3乘3来计算，并比较字符串

counted = 0

for i in range(len(string)):

    if string[i*3:(i+1)*3] == 'xox':
       counted = counted +1

print counted

对于一个重复的，我决定用3乘3来计算，并比较字符串

counted = 0

for i in range(len(string)):

    if string[i*3:(i+1)*3] == 'xox':
       counted = counted +1

print counted

Python的
str.count
计算不重叠的子字符串：

In [3]: "ababa".count("aba")
Out[3]: 1

这里有几种计算重叠序列的方法，我相信还有很多：）

前瞻正则表达式

生成所有子字符串
Python的
str.count
计算不重叠的子字符串：

In [3]: "ababa".count("aba")
Out[3]: 1

这里有几种计算重叠序列的方法，我相信还有很多：）

前瞻正则表达式

生成所有子字符串
如何在另一个有重叠的字符串中查找模式
此函数（另一个解决方案！）接收模式和文本。返回包含位于中的所有子字符串及其位置的列表

def occurrences(pattern, text):
    """
    input: search a pattern (regular expression) in a text
    returns: a list of substrings and their positions 
    """
    p = re.compile('(?=({0}))'.format(pattern))
    matches = re.finditer(p, text)
    return [(match.group(1), match.start()) for match in matches]

print (occurrences('ana', 'banana'))
print (occurrences('.ana', 'Banana-fana fo-fana'))

[（'ana'，1），（'ana'，3）]

[（'Bana'，0），（'nana'，2），（'fana'，7），（'fana'，15）]

如何在另一个有重叠的字符串中查找模式
此函数（另一个解决方案！）接收模式和文本。返回包含位于中的所有子字符串及其位置的列表

def occurrences(pattern, text):
    """
    input: search a pattern (regular expression) in a text
    returns: a list of substrings and their positions 
    """
    p = re.compile('(?=({0}))'.format(pattern))
    matches = re.finditer(p, text)
    return [(match.group(1), match.start()) for match in matches]

print (occurrences('ana', 'banana'))
print (occurrences('.ana', 'Banana-fana fo-fana'))

[（'ana'，1），（'ana'，3）]

[（'Bana'，0），（'nana'，2），（'fana'，7），（'fana'，15）]

您还可以尝试使用，它支持重叠匹配

import regex as re

def count_overlapping(text, search_for):
    return len(re.findall(search_for, text, overlapped=True))

count_overlapping('1011101111','11')  # 5

您还可以尝试使用，它支持重叠匹配

import regex as re

def count_overlapping(text, search_for):
    return len(re.findall(search_for, text, overlapped=True))

count_overlapping('1011101111','11')  # 5

一个非常接近公认答案的备选方案，但使用
while
作为
if
测试，而不是将
if
包含在循环中：

def countSubstr(string, sub):
    count = 0
    while sub in string:
        count += 1
        string = string[string.find(sub) + 1:]
    return count;

这避免了
而不是True:
并且在我看来更干净了一点
这是一个非常接近公认答案的替代方案，但是使用
而不是
而不是将
如果
包含在循环中：

def countSubstr(string, sub):
    count = 0
    while sub in string:
        count += 1
        string = string[string.find(sub) + 1:]
    return count;

这避免了
而不是True:
，并且在我看来更干净了一点
如果字符串很大，您希望使用，总之：


子字符串大小的滚动窗口，在字符串上移动
用于添加和删除的开销为O（1）的散列（即按1个字符移动）
用C实现或依赖pypy
如果字符串较大，则概括地说，您希望使用：


子字符串大小的滚动窗口，在字符串上移动
用于添加和删除的开销为O（1）的散列（即按1个字符移动）
用C实现或依赖pypy
可以使用正则表达式解决

import re
def function(string, sub_string):
    match = re.findall('(?='+sub_string+')',string)
    return len(match)

这可以用正则表达式解决

import re
def function(string, sub_string):
    match = re.findall('(?='+sub_string+')',string)
    return len(match)

上面的代码只是在字符串中循环一次，并不断检查是否有任何字符串以正在计数的特定子字符串开头

上面的代码只在字符串中循环一次，并不断检查是否有任何字符串以正在计数的特定子字符串开头。
这是使用
str.find（）
的另一个示例，但许多答案使其变得比必要的更复杂：

def occurrences(text, sub):
    c, n = 0, text.find(sub)
    while n != -1:
        c += 1
        n = text.find(sub, n+1)
    return c

In []:
occurrences('1011101111', '11')

Out[]:
5

这是使用
str.find（）
的另一个例子，但许多答案使它变得比必要的更复杂：

def occurrences(text, sub):
    c, n = 0, text.find(sub)
    while n != -1:
        c += 1
        n = text.find(sub, n+1)
    return c

In []:
occurrences('1011101111', '11')

Out[]:
5

这可能是最简单的方法

这可能是最简单的方法。

sequence = '1011101111'
sub = "11"

代码

在这种情况下：

sum(x == tuple(sub) for x in zip(sequence, sequence[1:]))
# 5

更一般地说，这

windows = zip(*([sequence[i:] for i, _ in enumerate(sequence)][:len(sub)]))
sum(x == tuple(sub) for x in windows)
# 5


>>> s = 'bobob'
>>> s.replace('b', 'bb').count('bob')
2

>>> s = 'aaa'
>>> count('aa') # there must be two occurrences
1 
>>> s.replace('a', 'aa').count('aa')
3

def occurance_of_pattern(text, pattern):
    text_len , pattern_len = len(text), len(pattern)
    return sum(1 for idx in range(text_len - pattern_len + 1) if text[idx: idx+pattern_len] == pattern)