Compter le nombre d'occurrences d'un substrat donné dans une chaîne

string.count(substring) , comme dans:

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

mise à jour : comme signalé dans les commentaires, c'est la façon de faire pour non cumul occurrences. Si vous avez besoin de compter les ocurrences qui se chevauchent, vous feriez mieux de vérifier les réponses à: " Python regex Trouvez toutes les correspondances qui se chevauchent? ", ou juste vérifier mon autre réponse ci-dessous.

selon ce que vous voulez vraiment dire, je propose les solutions suivantes:

1) vous voulez dire une liste de sous-chaînes séparées par des espaces et vous voulez savoir quel est le numéro de position de la sous-chaîne parmi toutes les sous-chaînes:

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

2) vous voulez dire la position de la sous-chaîne dans la chaîne:

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

3) vous voulez dire le (non-chevauchement) compte de l'apparence d'une corde de su-B:

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

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

la meilleure façon de trouver une sous-chaîne qui se chevauche dans une chaîne donnée est d'utiliser l'expression régulière python qui trouvera toutes les correspondances qui se chevauchent en utilisant la bibliothèque des expressions régulières. Voici comment le faire à gauche est le substrat et à droite vous trouverez la chaîne correspondant à

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

vous pouvez compter la fréquence de deux façons:

1. en utilisant le nombre() dans str:

   A. compte b)

2. ou, vous pouvez utiliser:

   len(A. split (b))-1

où " a "est la chaîne et" b " le substrat dont la fréquence doit être calculée.

la meilleure réponse actuelle impliquant la méthode count ne compte pas vraiment pour les événements se chevauchant et ne se soucie pas des sous-chaînes vides aussi bien. Exemple:

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

la première réponse devrait être 2 et non 1 , si l'on considère les substrats qui se chevauchent. En ce qui concerne la deuxième réponse, il est préférable qu'une sous-chaîne vide renvoie 0 comme asnwer.

le code suivant s'occupe de ces choses.

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

Maintenant, quand nous l'exécuter:

>>>num_of_patterns('caatatab', 'ata') #overlapping
2
>>>num_of_patterns('caatatab', '') #empty string
0
>>>num_of_patterns('abcdabcva','ab') #normal
2

pour trouver les occurences de chevauchement d'un substrat dans une chaîne en Python 3, cet algorithme fera:

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  

j'ai moi-même vérifié cet algorithme et ça a marché.

la question n'est pas très claire, mais je vais répondre à ce que vous êtes, en apparence, en train de demander.

une chaîne S, qui est longue de l caractères, et où S[1] est le premier caractère de la chaîne et S[L] est le dernier caractère, a les sous-chaînes suivantes:

• à La chaîne vide ". Il est l'un de ces.
• pour chaque valeur A de 1 À L, pour chaque valeur B de A à L, la chaîne S[a]..S [B] (inclusif.) Il y a L + L-1 + L-2 + ... 1 de ces chaînes, pour un total de 0.5*L*(L+1).
• notez que le second poste comprend S[1]..S[L], c'est-à-dire toute la chaîne originale S.

ainsi, il y a 0.5*L*(L+1) + 1 substrats dans une chaîne de longueur L. rendre cette expression en Python, et vous avez le nombre de substrats présents dans la chaîne.

je maintiendrai ma réponse acceptée comme la" façon simple et évidente de le faire " - cependant, cela ne couvre pas les événements qui se chevauchent. En trouvant ces peut être fait naïvement, avec de multiples vérification des tranches, - comme dans: sum ("GCAAAAAGH" [i:].startswith ("AAA") for i in range (Len ("GCAAAAAGH"))

(ce qui donne 3) - cela peut être fait en utilisant des expressions régulières, comme on peut le voir sur Python regex trouver toutes les correspondances qui se chevauchent? - et il peut également faire pour le golf de code fin - C'est mon compte "fait à la main" pour superposer des courants de motifs dans une chaîne qui essaie de ne pas être extrêmement naïve (au moins il ne crée pas de nouveaux objets de chaîne à chaque interaction):

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

occurrences chevauchantes:

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

résultats:

my maaather lies over the oceaaan
6
4
2

pour le nombre de recouvrement nous pouvons utiliser:

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

pour les cas ne se chevauchant pas, nous pouvons utiliser la fonction count ():

string.count(sub_string)

si vous voulez connaître le nombre de sous-chaînes à l'intérieur d'une chaîne, veuillez utiliser le code ci-dessous. Le code est facile à comprendre, c'est pourquoi j'ai sauté le commentaires. :)

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

Une façon est d'utiliser re.subn . Par exemple, pour compter le nombre de occurrences de 'hello' dans n'importe quel mélange de cas, vous pouvez faire:

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

Que Diriez-vous d'une doublure Avec une compréhension de liste? Techniquement ses 93 caractères longs, épargnez-moi le purisme de PEP-8. Le regex.la réponse de findall est la plus lisible si c'est un morceau de code de haut niveau. Si vous construisez quelque chose de bas niveau et que vous ne voulez pas de dépendances, celui-ci est plutôt maigre et méchant. Je donne la réponse qui se recoupe. Évidemment, il suffit d'utiliser count comme la réponse la plus élevée s'il n'y a pas de chevauchement.

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

Je ne suis pas sûr que ce soit quelque chose déjà regardé, mais j'ai pensé à cela comme une solution pour un mot qui est "jetable":

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

print count

Où mot est le mot que vous êtes à la recherche dans et terme est le terme que vous cherchez

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)

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

trouve le nombre de fois que sub string se trouve dans l'index string and displays.

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)

ci-dessous la logique fonctionnera pour toutes les chaînes de caractères et les caractères spéciaux

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