python - tamaño - Contar el número de apariciones de una subcadena dada en una cadena

string en python

Question

Posible duplicado:
Recurrencias de indexación básicas de una subcadena dentro de una cadena (python)

¿Cómo puedo contar el número de veces que una subcadena dada está presente dentro de una cadena en Python?

Por ejemplo:

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

Answer 1

Dependiendo de lo que realmente signifique, propongo las siguientes soluciones:

1) Te refieres a una lista de subcadenas separadas por espacios y quieres saber cuál es el número de posición de subcadena entre todas las subcadenas:

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

2) Te refieres a la posición char de la subcadena en la cadena:

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

3) Te refieres a los recuentos (no superpuestos) de apariencia de una su-bstring:

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

Answer 2

La mejor manera de encontrar una subcadena superpuesta en una cadena dada es usar la expresión regular de python, encontrará todas las coincidencias superpuestas utilizando la biblioteca de expresiones regulares. Aquí está cómo hacerlo a la izquierda es la subcadena y en la derecha le proporcionará la cadena para que coincida

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

Answer 3

La mejor respuesta actual que involucra el count métodos realmente no cuenta para las ocurrencias superpuestas y tampoco le preocupan las subcadenas vacías. Por ejemplo:

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

La primera respuesta debería ser 2 no 1 , si consideramos las subcadenas superpuestas. En cuanto a la segunda respuesta, es mejor si una subcadena vacía devuelve 0 como el asnwer.

El siguiente código se ocupa de estas cosas.

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

Ahora cuando lo ejecutamos:

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

Answer 4

La pregunta no es muy clara, pero responderé lo que eres, en la superficie, preguntando.

Una cadena S, que tiene L caracteres de longitud, y donde S [1] es el primer caracter de la cadena y S [L] es el último caracter, tiene las siguientes subcadenas:

• La cadena nula ''''. Hay uno de estos.
• Para cada valor A de 1 a L, para cada valor B de A a L, la cadena S [A] .. S [B] (inclusive). Hay L + L-1 + L-2 + ... 1 de estas cuerdas, para un total de 0.5 * L * (L + 1).
• Tenga en cuenta que el segundo elemento incluye S [1] .. S [L], es decir, toda la secuencia original S.

Entonces, hay 0.5 * L * (L + 1) + 1 subcadena dentro de una cadena de longitud L. Renderiza esa expresión en Python, y usted tiene el número de subcadenas presente dentro de la cadena.

Answer 5

Mantendré mi respuesta aceptada como la "forma simple y obvia de hacerlo", sin embargo, eso no cubre las ocurrencias superpuestas. Descubrirlas puede hacerse ingenuamente, con múltiples comprobaciones de las rebanadas, como en: sum ("GCAAAAAGH" [i:]. Startswith ("AAA") para i en rango (len ("GCAAAAAGH")))

(que rinde 3) - se puede hacer mediante el uso truco de expresiones regulares, como se puede ver en Python regex encontrar todas las coincidencias superpuestas? - y también puede hacer código de golf fino - Este es mi recuento "hecho a mano" para superponer surcos de patrones en una cadena que trata de no ser extremadamente ingenuo (al menos no crea nuevos objetos de cadena en cada interacción):

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

No estoy seguro de si esto ya se consideró, pero pensé en esto como una solución para una palabra que es "desechable":

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

Donde palabra es la palabra que está buscando y término es el término que está buscando

Answer 7

Ocurrencias superpuestas:

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

Resultados:

my maaather lies over the oceaaan
6
4
2

Answer 8

Para el recuento superpuesto, podemos usar el 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

Para el caso que no se superpone, podemos usar la función count ():

string.count(sub_string)

Answer 9

Para encontrar las ocurrencias superpuestas de una subcadena en una cadena en Python 3, este algoritmo hará:

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

Yo mismo revisé este algoritmo y funcionó.

Answer 10

Puede contar la frecuencia usando dos formas:

1. Usando el conteo () en str:

   cuenta (b)

2. O bien, puedes usar:

   len (a.split (b)) - 1

Donde ''a'' es la cadena y ''b'' es la subcadena cuya frecuencia debe calcularse.

Answer 11

Si quieres saber el número de subcadenas dentro de cualquier cadena; por favor use el siguiente código. El código es fácil de entender, es por eso que salté los comentarios. :)

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

Una forma es usar re.subn . Por ejemplo, para contar el número de ocurrencias de ''hello'' en cualquier combinación de casos que pueda hacer:

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

Answer 13

string.count(substring) , como en:

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

actualización : como se señaló en los comentarios, esta es la forma de hacerlo para las ocurrencias no superpuestas . Si necesita contar sucesos superpuestos, será mejor que compruebe las respuestas en: " Python regex encuentra todas las coincidencias superpuestas? ", O simplemente revise mi otra respuesta a continuación.

Answer 14

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

Encuentra la cantidad de veces que se encuentra la cadena secundaria en la cadena y muestra el índice.

Answer 15

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 16

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)