Определение того, сколько раз подстрока встречается в строке в Python

Я пытаюсь выяснить, сколько раз строка возникает в строке. Например:

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. Я застрял в бесконечном цикле на данный момент.

Мне просто стало известно, что счет - это намного лучший способ сделать это, но из любопытства, кто-нибудь видит способ сделать это, похожее на то, что у меня уже есть?

Ответ 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)

Ответ 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().

Ответ 3

import re

pattern = '123'

n =re.findall(pattern, string)

Можно сказать, что подстрока 'pattern' появляется в ln (n) раз в 'string'.

Ответ 4

string.count(подстрока) не полезна в случае перекрытия.

Мой подход:

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

Ответ 5

Вы не меняете с каждой петлей. a Вы должны поставить:

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

...вместо:

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

Ответ 6

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)

Ответ 7

Как упоминали @João Pesce и @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

Ответ 8

В случае, если вы ищете, как решить эту проблему для перекрывающихся случаев.

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

Ответ 9

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