Wie finde ich alle Vorkommen eines Teilstrings?

Python hat string.find()und string.rfind()um den Index eines Teilstrings in einem String zu erhalten.

Ich frage mich, ob es so etwas gibt, string.find_all()das alle gefundenen Indizes zurückgeben kann (nicht nur den ersten vom Anfang oder den ersten vom Ende).

Zum Beispiel:

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]

Es gibt keine einfache integrierte Zeichenfolgenfunktion, die das tut, wonach Sie suchen, aber Sie könnten die leistungsstärkeren regulären Ausdrücke verwenden :

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

Wenn Sie überlappende Übereinstimmungen suchen möchten, führt Lookahead Folgendes aus :

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

Wenn Sie eine umgekehrte Suche ohne Überlappungen wünschen, können Sie positive und negative Lookahead zu einem Ausdruck wie diesem kombinieren:

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

re.finditerGibt einen Generator zurück , sodass Sie []die obigen Angaben ändern können (), um einen Generator anstelle einer Liste zu erhalten, die effizienter ist, wenn Sie die Ergebnisse nur einmal durchlaufen.

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

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

So können wir es selbst bauen:

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]

Keine temporären Zeichenfolgen oder regulären Ausdrücke erforderlich.

Hier ist ein (sehr ineffizienter) Weg, um alle (dh sogar überlappenden) Übereinstimmungen zu erhalten:

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

Wieder alter Thread, aber hier ist meine Lösung mit einem Generator und Plain 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)

Beispiel

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

kehrt zurück

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

Sie können re.finditer()für nicht überlappende Übereinstimmungen verwenden.

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

funktioniert aber nicht für:

In [1]: aString="ababa"

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

Komm, lass uns zusammen zurückkehren.

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]

Auf diese Weise sind keine regulären Ausdrücke erforderlich.

Wenn Sie nur nach einem einzelnen Charakter suchen, würde dies funktionieren:

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

Ebenfalls,

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

Meine Vermutung ist, dass keines von diesen (besonders # 2) schrecklich performant ist.

Dies ist ein alter Thread, aber ich wurde interessiert und wollte meine Lösung teilen.

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

Es sollte eine Liste der Positionen zurückgeben, an denen der Teilstring gefunden wurde. Bitte kommentieren Sie, wenn Sie einen Fehler oder Verbesserungsbedarf sehen.

Dies macht den Trick für mich mit 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()))

Dieser Thread ist etwas alt, aber das hat bei mir funktioniert:

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)

Du kannst es versuchen :

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

0
5
10
15

Unabhängig davon, welche Lösungen von anderen bereitgestellt werden, basieren sie vollständig auf der verfügbaren Methode find () oder verfügbaren Methoden.

Was ist der grundlegende Grundalgorithmus, um alle Vorkommen eines Teilstrings in einem String zu finden?

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

Sie können die Klasse str auch an eine neue Klasse erben und diese Funktion unten verwenden.

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

Methode aufrufen

newstr.find_all ('Findest du diese Antwort hilfreich? Dann stimme dem zu!', 'this')

Diese Funktion betrachtet nicht alle Positionen innerhalb der Zeichenfolge und verschwendet keine Rechenressourcen. Mein Versuch:

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

um es zu benutzen, nenne es so:

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

Verwenden Sie Flashtext, wenn Sie nach einer großen Anzahl von Schlüsselwörtern in einem Dokument suchen

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 wird in einer großen Liste von Suchwörtern schneller ausgeführt als Regex.

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)

Dies ist die Lösung einer ähnlichen Frage von Hackerrank. Ich hoffe das könnte dir helfen.

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

Ausgabe:

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

Durch Schneiden finden wir alle möglichen Kombinationen und fügen sie in eine Liste ein und ermitteln, wie oft sie mit der countFunktion auftreten

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

Bitte schauen Sie sich den folgenden Code an

#!/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)

Der pythonische Weg wäre:

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

Sie können leicht verwenden:

string.count('test')!

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

Prost!