Comment trouver toutes les occurrences d'une sous-chaîne?

Python a string.find()et string.rfind()pour obtenir l'index d'une sous-chaîne dans une chaîne.

Je me demande s'il y a quelque chose comme string.find_all()qui peut retourner tous les index trouvés (pas seulement le premier depuis le début ou le premier depuis la fin).

Par exemple:

string = "test test test test"

print string.find('test') # 0
print string.rfind('test') # 15

#this is the goal
print string.find_all('test') # [0,5,10,15]

Il n'y a pas de fonction de chaîne intégrée simple qui fait ce que vous cherchez, mais vous pouvez utiliser les expressions régulières les plus puissantes :

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

Si vous voulez trouver des correspondances qui se chevauchent, lookahead le fera:

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

Si vous voulez une recherche inversée sans chevauchements, vous pouvez combiner l'anticipation positive et négative en une expression comme celle-ci:

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

re.finditerrenvoie un générateur , vous pouvez donc changer le []dans ce qui précède pour ()obtenir un générateur au lieu d'une liste qui sera plus efficace si vous parcourez les résultats une seule fois.

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

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

Ainsi, nous pouvons le construire nous-mêmes:

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]

Aucune chaîne ou expression régulière temporaire n'est requise.

Voici un moyen (très inefficace) d'obtenir toutes les correspondances (c'est-à-dire même les chevauchements):

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

Encore une fois, vieux fil, mais voici ma solution en utilisant un générateur et simple 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)

Exemple

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

Retour

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

Vous pouvez utiliser re.finditer()pour des correspondances qui ne se chevauchent pas.

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

mais ne fonctionnera pas pour:

In [1]: aString="ababa"

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

Venez, laissez-nous récurer ensemble.

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]

Pas besoin d'expressions régulières de cette façon.

Si vous cherchez juste un seul personnage, cela fonctionnerait:

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

Aussi,

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

Mon intuition est qu'aucune de celles-ci (en particulier # 2) n'est terriblement performante.

c'est un vieux fil mais je me suis intéressé et je voulais partager ma solution.

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

Il devrait renvoyer une liste de positions où la sous-chaîne a été trouvée. Veuillez commenter si vous voyez une erreur ou une marge d'amélioration.

Cela fait l'affaire pour moi en utilisant 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()))

Ce fil est un peu vieux mais cela a fonctionné pour moi:

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)

Tu peux essayer :

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

0
5
10
15

Quelles que soient les solutions fournies par d'autres, elles sont entièrement basées sur la méthode disponible find () ou sur toute méthode disponible.

Quel est l'algorithme de base de base pour trouver toutes les occurrences d'une sous-chaîne dans une chaîne?

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

Vous pouvez également hériter de la classe str dans une nouvelle classe et utiliser cette fonction ci-dessous.

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

Appel de la méthode

newstr.find_all ('Trouvez-vous cette réponse utile? alors votez pour ceci!', 'ceci')

Cette fonction ne regarde pas toutes les positions à l'intérieur de la chaîne, elle ne gaspille pas les ressources de calcul. Mon essai:

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

pour l'utiliser, appelez-le comme ceci:

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

Lorsque vous recherchez une grande quantité de mots clés dans un document, utilisez le flashtext

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 s'exécute plus rapidement que regex sur une grande liste de mots de recherche.

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)

C'est la solution d'une question similaire de hackerrank. J'espère que cela pourrait vous aider.

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

Production:

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

En découpant, nous trouvons toutes les combinaisons possibles et les ajoutons dans une liste et trouvons le nombre de fois où cela se produit en utilisant la countfonction

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

veuillez regarder ci-dessous le code

#!/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 voie pythonique serait:

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

Vous pouvez facilement utiliser:

string.count('test')!

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

À votre santé!