¿Cómo encontrar todas las apariciones de una subcadena?

No hay una función de cadena incorporada simple que haga lo que está buscando, pero podría usar la más poderosa expresiones regulares:

import re
[m.start() for m in re.finditer('test', 'test test test test')]
#[0, 5, 10, 15]

Si desea encontrar coincidencias superpuestas, mirar hacia el futuro lo haré:

[m.start() for m in re.finditer('(?=tt)', 'ttt')]
#[0, 1]

Si desea buscar todo inverso sin superposiciones, puede combinar una búsqueda anticipada positiva y negativa en una expresión como esta:

search = 'tt'
[m.start() for m in re.finditer('(?=%s)(?!.{1,%d}%s)' % (search, len(search)-1, search), 'ttt')]
#[1]

re.finditer devuelve un generador, para que puedas cambiar el [] en lo anterior a () para obtener un generador en lugar de una lista, lo que será más eficiente si solo está iterando los resultados una vez.

>>> help(str.find)
Help on method_descriptor:

find(...)
    S.find(sub [,start [,end]]) -> int

Por lo tanto, podemos construirlo nosotros mismos:

def find_all(a_str, sub):
    start = 0
    while True:
        start = a_str.find(sub, start)
        if start == -1: return
        yield start
        start += len(sub) # use start += 1 to find overlapping matches

list(find_all('spam spam spam spam', 'spam')) # [0, 5, 10, 15]

No se requieren cadenas temporales o expresiones regulares.

Aquí hay una forma (muy ineficiente) de obtener todos (es decir, incluso superpuestos) coincide con:

>>> string = "test test test test"
>>> [i for i in range(len(string)) if string.startswith('test', i)]
[0, 5, 10, 15]

Nuevamente, hilo antiguo, pero aquí está mi solución usando un generador y claro str.find.

def findall(p, s):
    '''Yields all the positions of
    the pattern p in the string s.'''
    i = s.find(p)
    while i != -1:
        yield i
        i = s.find(p, i+1)

Ejemplo

x = 'banananassantana'
[(i, x[i:i+2]) for i in findall('na', x)]

devoluciones

[(2, 'na'), (4, 'na'), (6, 'na'), (14, 'na')]

Puedes usar re.finditer() para coincidencias que no se superponen.

>>> import re
>>> aString = 'this is a string where the substring "is" is repeated several times'
>>> print [(a.start(), a.end()) for a in list(re.finditer('is', aString))]
[(2, 4), (5, 7), (38, 40), (42, 44)]

pero no se trabajar para:

In [1]: aString="ababa"

In [2]: print [(a.start(), a.end()) for a in list(re.finditer('aba', aString))]
Output: [(0, 3)]

Ven, volvamos juntos.

def locations_of_substring(string, substring):
    """Return a list of locations of a substring."""

    substring_length = len(substring)    
    def recurse(locations_found, start):
        location = string.find(substring, start)
        if location != -1:
            return recurse(locations_found + [location], location+substring_length)
        else:
            return locations_found

    return recurse([], 0)

print(locations_of_substring('this is a test for finding this and this', 'this'))
# prints [0, 27, 36]

No es necesario utilizar expresiones regulares de esta forma.

Si solo está buscando un solo carácter, esto funcionaría:

string = "dooobiedoobiedoobie"
match = 'o'
reduce(lambda count, char: count + 1 if char == match else count, string, 0)
# produces 7

También, trabaja para

string = "test test test test"
match = "test"
len(string.split(match)) - 1
# produces 4

Mi corazonada es que ninguno de estos (especialmente el # 2) tiene un desempeño terrible.

Este es un hilo antiguo, pero me interesé y quería compartir mi solución.

def find_all(a_string, sub):
    result = []
    k = 0
    while k < len(a_string):
        k = a_string.find(sub, k)
        if k == -1:
            return result
        else:
            result.append(k)
            k += 1 #change to k += len(sub) to not search overlapping results
    return result

Debería devolver una lista de posiciones donde se encontró la subcadena. Por favor comente si ve un error o margen de mejora.

Esto me hace el truco usando re.finditer

import re

text = 'This is sample text to test if this pythonic '\
       'program can serve as an indexing platform for '\
       'finding words in a paragraph. It can give '\
       'values as to where the word is located with the '\
       'different examples as stated'

#  find all occurances of the word 'as' in the above text

find_the_word = re.finditer('as', text)

for match in find_the_word:
    print('start {}, end {}, search string \'{}\''.
          format(match.start(), match.end(), match.group()))

Este hilo es un poco viejo pero esto funcionó para mí:

numberString = "onetwothreefourfivesixseveneightninefiveten"
testString = "five"

marker = 0
while marker < len(numberString):
    try:
        print(numberString.index("five",marker))
        marker = numberString.index("five", marker) + 1
    except ValueError:
        print("String not found")
        marker = len(numberString)

Puedes probar :

>>> string = "test test test test"
>>> for index,value in enumerate(string):
    if string[index:index+(len("test"))] == "test":
        print index

0
5
10
15

Cualesquiera que sean las soluciones proporcionadas por otros, se basan completamente en el método disponible find () o cualquier método disponible.

¿Cuál es el algoritmo básico central para encontrar todas las apariciones de una subcadena en una cadena?

def find_all(string,substring):
    """
    Function: Returning all the index of substring in a string
    Arguments: String and the search string
    Return:Returning a list
    """
    length = len(substring)
    c=0
    indexes = []
    while c < len(string):
        if string[c:c+length] == substring:
            indexes.append(c)
        c=c+1
    return indexes

También puede heredar la clase str a la nueva clase y puede usar esta función a continuación.

class newstr(str):
def find_all(string,substring):
    """
    Function: Returning all the index of substring in a string
    Arguments: String and the search string
    Return:Returning a list
    """
    length = len(substring)
    c=0
    indexes = []
    while c < len(string):
        if string[c:c+length] == substring:
            indexes.append(c)
        c=c+1
    return indexes

Llamar al método

newstr.find_all ('¿Te parece útil esta respuesta? ¡Entonces vota esto!', 'esto')

Cuando busque una gran cantidad de palabras clave en un documento, utilice flashtexto

from flashtext import KeywordProcessor
words = ['test', 'exam', 'quiz']
txt = 'this is a test'
kwp = KeywordProcessor()
kwp.add_keywords_from_list(words)
result = kwp.extract_keywords(txt, span_info=True)

Flashtext se ejecuta más rápido que las expresiones regulares en una gran lista de palabras de búsqueda.

Esta función no examina todas las posiciones dentro de la cadena, no desperdicia recursos de cálculo. Mi intento:

def findAll(string,word):
    all_positions=[]
    next_pos=-1
    while True:
        next_pos=string.find(word,next_pos+1)
        if(next_pos<0):
            break
        all_positions.append(next_pos)
    return all_positions

para usarlo llámalo así:

result=findAll('this word is a big word man how many words are there?','word')

src = input() # we will find substring in this string
sub = input() # substring

res = []
pos = src.find(sub)
while pos != -1:
    res.append(pos)
    pos = src.find(sub, pos + 1)

Esta es la solución a una pregunta similar de hackerrank. Espero que esto pueda ayudarte.

import re
a = input()
b = input()
if b not in a:
    print((-1,-1))
else:
    #create two list as
    start_indc = [m.start() for m in re.finditer('(?=' + b + ')', a)]
    for i in range(len(start_indc)):
        print((start_indc[i], start_indc[i]+len(b)-1))

Salida:

aaadaa
aa
(0, 1)
(1, 2)
(4, 5)

def find_index(string, let):
    enumerated = [place  for place, letter in enumerate(string) if letter == let]
    return enumerated

por ejemplo:

find_index("hey doode find d", "d") 

devoluciones:

[4, 7, 13, 15]

No es exactamente lo que pidió OP, pero también podría usar el función dividida para obtener una lista de dónde están todas las subcadenas no ocurrir. OP no especificó el objetivo final del código, pero si su objetivo es eliminar las subcadenas de todos modos, esto podría ser una simple frase. Probablemente hay formas más eficientes de hacer esto con cadenas más grandes; las expresiones regulares serían preferibles en ese caso

# Extract all non-substrings
s = "an-example-string"
s_no_dash = s.split('-')
# >>> s_no_dash
# ['an', 'example', 'string']

# Or extract and join them into a sentence
s_no_dash2 = ' '.join(s.split('-'))
# >>> s_no_dash2
# 'an example string'

Hice un breve vistazo de otras respuestas, así que me disculpo si esto ya está ahí.

def count_substring(string, sub_string):
    c=0
    for i in range(0,len(string)-2):
        if string[i:i+len(sub_string)] == sub_string:
            c+=1
    return c

if __name__ == '__main__':
    string = input().strip()
    sub_string = input().strip()
    
    count = count_substring(string, sub_string)
    print(count)

si solo quieres usar numpy aquí hay una solución

import numpy as np

S= "test test test test"
S2 = 'test'
inds = np.cumsum([len(k)+len(S2) for k in S.split(S2)[:-1]])- len(S2)
print(inds)

Al dividir encontramos todas las combinaciones posibles y las agregamos en una lista y encontramos el número de veces que ocurre usando count función

s=input()
n=len(s)
l=[]
f=input()
print(s[0])
for i in range(0,n):
    for j in range(1,n+1):
        l.append(s[i:j])
if f in l:
    print(l.count(f))

por favor mire el código a continuación

#!/usr/bin/env python
# coding:utf-8
'''黄哥Python'''


def get_substring_indices(text, s):
    result = [i for i in range(len(text)) if text.startswith(s, i)]
    return result


if __name__ == '__main__':
    text = "How much wood would a wood chuck chuck if a wood chuck could chuck wood?"
    s = 'wood'
    print get_substring_indices(text, s)

La forma pitónica sería:

mystring = 'Hello World, this should work!'
find_all = lambda c,s: [x for x in range(c.find(s), len(c)) if c[x] == s]

# s represents the search string
# c represents the character string

find_all(mystring,'o')    # will return all positions of 'o'

[4, 7, 20, 26] 
>>> 

Puedes usar fácilmente:

string.count('test')!

https://www.programiz.com/python-programming/methods/string/count

¡Aclamaciones!