Это еще один пример использования 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

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

Выше кода просто повторяется по всей строке один раз и продолжает проверять, начинается ли какая-либо строка с конкретной подсчитанной подстрокой.

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

Это может быть самым простым способом.

Для дублированного вопроса я решил посчитать его 3 на 3 и сравнить строку, например.

counted = 0

for i in range(len(string)):

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

print counted

Вот мое решение edx MIT «find bob» * (* найти количество вхождений «bob» в строке с именем s), которая в основном подсчитывает перекрывающиеся вхождения данной подстанции:

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)

Вы также можете попробовать использовать новый модуль регулярного выражения Python , который поддерживает совпадающие совпадения.

import regex as re

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

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

Если строки велики, вы хотите использовать Rabin-Karp , в итоге:

• развертки окна размера подстроки, перемещение по строке
• хэш с O (1) служебными данными для добавления и удаления (т. е. перемещение на 1 символ)
• , реализованного в C или полагающегося на pypy

def count_overlaps (string, look_for):
    start   = 0
    matches = 0

    while True:
        start = string.find (look_for, start)
        if start < 0:
            break

        start   += 1
        matches += 1

    return matches

print count_overlaps ('abrabra', 'abra')

Функция, которая принимает в качестве входных данных две строки и подсчитывает, сколько раз субподходит в строке, включая перекрытия. Чтобы проверить, является ли sub подстрокой, я использовал оператор in.

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

sum([ 1 for _ in range(len(string)-len(str_to_search_for)+1) if string[_:_+len(str_to_search_for)] == str_to_search_for])

В понимании списка мы перемещаем большую строку по одной позиции за раз с скользящим окном длины меньшей строки. Мы можем вычислить скользящее число, вычитая длину меньшей строки из большей строки. Для каждого слайда мы сравниваем ту часть большей строки с нашей меньшей строкой и генерируем 1 в списке, если совпадение найдено. Сумма всех этих 1 в списке даст нам общее количество найденных совпадений.

Это можно решить с помощью регулярного выражения.

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

Если вы хотите подсчитать количество перестановок длины 5 (отрегулируйте, если хотите для разных длин):

def MerCount(s):
  for i in xrange(len(s)-4):
    d[s[i:i+5]] += 1
return d

>>> import re
>>> text = '1011101111'
>>> len(re.findall('(?=11)', text))
5

Если вы не хотите загружать весь список совпадений в память, это никогда не будет проблемой! вы можете сделать это, если хотите:

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

Как функция (re.escape, убедитесь, что подстрока не мешает регулярному выражению):

>>> def occurrences(text, sub):
        return len(re.findall('(?={0})'.format(re.escape(sub)), text))

>>> occurrences(text, '11')
5

Как найти шаблон в другой строке с перекрытием

Эта функция (другое решение!) получает шаблон и текст. Возвращает список со всей подстрокой, расположенной в их и их положениях.

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

Мой ответ на вопрос bob о курсе:

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 = "bobobob"
sub = "bob"
ln = len(sub)
print(sum(sub == s[i:i+ln] for i in xrange(len(s)-(ln-1))))

Учитывая

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

или перейти к генераторам:

import itertools as it


iter_ = (sequence[i:] for i, _ in enumerate(sequence))
windows = zip(*(it.islice(iter_, None, len(sub))))
sum(x == tuple(sub) for x in windows)

Альтернатива

Вы можете использовать more_itertools.locate :

import more_itertools as mit


len(list(mit.locate(sequence, pred=lambda *args: args == tuple(sub), window_size=len(sub))))
# 5

Альтернатива, очень близкая к принятому ответу, но использующая while в качестве теста if вместо включения if внутри цикла:

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

Это позволяет избежать while True: и является немного чище по-моему