numero conte di occorrenze di una data sottostringa in una stringa

Question

Eventuali duplicati:
Basic indexing recurrences of a substring within a string (python)

Come posso contare il numero di volte in cui una data sottostringa è presente all'interno di una stringa in Python ?

Ad esempio:

>>> 'foo bar foo'.numberOfOccurrences('foo') 
2 

Answer 1

string.count(substring), come in:

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

aggiornamento: come sottolineato nelle osservazioni, questo è il modo per farlo per non sovrapposti occorrenze. Se hai bisogno di contare le occorrenze sovrapposte, è meglio controllare le risposte a: "Python regex find all overlapping matches?", o semplicemente controllare l'altra mia risposta sotto.

Answer 2

A seconda che cosa realmente significa, propongo le seguenti soluzioni:

1) Vuoi dire un elenco di spazi separati sotto-stringhe e volete sapere qual è il numero posizione sub-string tra tutte le sotto-stringhe:

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

2) Si intende il char posizione del sotto-stringa nella stringa:

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

3) Si intende il (non sovrapposti) conta di comparsa di un su-bstring:

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

Answer 3

La domanda non è molto chiaro, ma io risponderò quello che sei, in superficie, chiedendo.

Una stringa S, che è lunga L caratteri, e dove S [1] è il primo carattere della stringa e S [L] è l'ultimo carattere, ha le seguenti sottostringhe:

• Il nulla stringa "". C'è uno di questi.
• Per ogni valore A da 1 a L, per ogni valore B da A a L, la stringa S [A] .. S [B] (incluso). Ci sono L + L-1 + L-2 + ... 1 di queste stringhe, per un totale di 0,5 * L * (L + 1).
• Nota che la seconda voce include S [1] .. S [L], cioè l'intera stringa originale S.

così, ci sono 0,5 * L * (L + 1) + 1 sottostringhe all'interno di una stringa di lunghezza L. Renderizza quell'espressione in Python e hai il numero di sottostringhe presenti all'interno della stringa.

Answer 4

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 

Answer 5

terrò la mia risposta accettato come il "modo semplice e ovvio per farlo" - tuttavia, che non copre le occorrenze sovrapposte. Scoprire quelli che si possono fare in modo ingenuo, con il controllo multiplo delle sezioni - come in: sum ("GCAAAAAGH" [i:].startswith ("AAA") per i in range (len ("GCAAAAAGH"))

(che produce 3) - può essere fatto con l'uso di espressioni regolari, come si può vedere in Python regex find all overlapping matches? - e può anche fare per bene il golf codice - Questo è il mio "fatto a mano" conta per overlappingocurrences di modelli in una stringa, che cerca di non essere estremamente ingenuo (almeno non crea nuovi oggetti stringa ad ogni interazione):

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

Answer 6

Non sono sicuro se questo è già stato visto, ma ho pensato a questo come una soluzione per una parola che è "usa e getta":

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

print count 

Dove parola è la parola che si sta cercando e termine è il termine che si sta cercando

Answer 7

occorrenze sovrapposte:

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

Risultati:

my maaather lies over the oceaaan 
6 
4 
2 

Answer 8

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) 

Answer 9

La risposta migliore corrente che coinvolge il metodo count non conta realmente per le occorrenze che si sovrappongono e non si preoccupa anche delle sottostringhe vuote. Per esempio:

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

La prima risposta dovrebbe essere 2 non 1, se consideriamo le stringhe sovrapposte. Per quanto riguarda la seconda risposta è meglio se una sottostringa vuota restituisce 0 come asnwer.

Il seguente codice si occupa di queste cose.

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 

Ora, quando si eseguirlo:

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

Answer 10

Per trovare sovrapposizione occorrenze di una sottostringa in una stringa in Python 3, questo algoritmo farà:

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 

Io stesso controllato questo algoritmo e ha funzionato.

Answer 11

Se si desidera scoprire il conteggio della sottostringa all'interno di qualsiasi stringa; si prega di utilizzare sotto il codice. Il codice è facile da capire, ecco perché ho saltato i commenti. :)

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 

Answer 12

si può contare la frequenza utilizzando due modi:

1. Utilizzando il conteggio() in str:

   a.Count (b)

2. Oppure, è possibile utilizzare:

   len (a.split (b)) - 1

Dove 'a' è la stringa e 'b' è la stringa cui frequenza deve essere calcolato.

Answer 13

Per sovrapposizione conteggio possiamo utilizzare uso:

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 

per il caso di non sovrapposizione possiamo usare count) funzione (:

string.count(sub_string) 

Answer 14

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

Questo trova il numero di volte sottostringa trovato nella stringa e visualizza indice.

Answer 15

Il modo migliore per trovare sottostringa sovrapposta in una determinata stringa consiste nell'utilizzare l'espressione regolare python che troverà tutte le corrispondenze sovrapposte utilizzando la libreria di espressioni regolari. Ecco come farlo sinistra è la stringa e in destra fornire la stringa per abbinare

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

Answer 16

Un modo è quello di utilizzare re.subn. Ad esempio, per contare il numero di occorrenze di 'hello' in qualsiasi mix di casi si può fare:

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