Python найти все вхождения подстроки

Найти все вхождения подстроки в Python

Python имеет string.find() и string.rfind() , чтобы получить индекс подстроки в строке. Интересно, может быть, есть что-то вроде string.find_all() , которое может вернуть все основанные индексы (не только от начала или от конца до конца)? Например:

string = "test test test test" print string.find('test') # 0 print string.rfind('test') # 15 #that the goal print string.find_all('test') # [0,5,10,15] 

он должен вернуть «0». Конечно, в идеальном мире также должен быть ‘ttt’.rfind_all(‘tt’) , который должен возвращать’ 1 ‘

16 ответов

Нет простой встроенной строковой функции, которая делает то, что вы ищете, но вы можете использовать более мощные регулярные выражения:

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

Если вы хотите найти совпадающие совпадения, lookahead сделает это:

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

Если вы хотите получить обратное вскрытие без перекрытий, вы можете комбинировать положительные и отрицательные образы в виде следующего вида:

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

re.finditer возвращает генератор, поэтому вы можете изменить [] в приведенном выше re.finditer на () чтобы получить генератор вместо списка, который будет более эффективен, если вы будете только повторять результаты один раз.

Привет, относительно этого [m.start() for m in re.finditer(‘test’, ‘test test test test’)] , как мы можем искать test или text ? Становится ли это намного сложнее?

Вы хотите посмотреть на регулярные выражения в целом: docs.python.org/2/howto/regex.html . Решением вашего вопроса будет: [m.start () для m в re.finditer (‘te [sx] t’, ‘text test text test’)]

>>> help(str.find) Help on method_descriptor: find(. ) S.find(sub [,start [,end]]) -> int 

Таким образом, мы можем сами его построить:

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] 

Никаких временных строк или регулярных выражений не требуется.

Чтобы соответствовать поведению re.findall , я бы рекомендовал добавить len(sub) or 1 вместо len(sub) , иначе этот генератор никогда не завершится на пустой подстроке.

Здесь (очень неэффективный) способ получить все (т.е. даже совпадение):

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

Вы можете использовать re.finditer() для совпадающих совпадений.

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

но не будет работать:

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

Опять старый поток, но здесь мое решение использует генератор и обычный 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) 

Пример

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

Приходите, давайте возместим вместе.

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] 

Нет необходимости в регулярных выражениях таким образом.

Я только начал задаваться вопросом: «Есть ли причудливый способ найти подстроку внутри строки в Python?», А затем через 5 минут поиска в Google я нашел ваш код. Спасибо, что поделился.

Этот код имеет несколько проблем. Поскольку он работает с открытыми данными рано или поздно, вы столкнетесь с RecursionError если будет достаточно много вхождений. Другой — два одноразовых списка, которые он создает на каждой итерации только для добавления одного элемента, что очень неоптимально для функции поиска строк, которую можно вызывать много раз. Хотя иногда рекурсивные функции кажутся изящными и ясными, к ним следует относиться с осторожностью.

Это старый поток, но я заинтересовался и хотел поделиться своим решением.

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 

Он должен вернуть список позиций, в которых была найдена подстрока. Прокомментируйте, если вы видите ошибку или комнату для улучшения.

Если вы ищете только один символ, это будет работать:

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

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

Моя догадка заключается в том, что ни один из них (особенно # 2) не ужасен.

Этот поток немного стар, но это сработало для меня:

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) 

Это делает трюк для меня, используя 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())) 

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

Независимо от решений, предоставляемых другими, полностью зависит от доступного метода find() или любых доступных методов.

Каков основной базовый алгоритм для поиска всех вхождений подстрока в строке?

 def find_all (строка, подстрока): "" Функция: Возврат всего индекса подстроки в строку Аргументы: Строка и строка поиска Возврат: возврат списка "" length = len (подстрока) с = 0 indexes = [] в то время как c

Вы также можете наследовать класс str новому классу и можете использовать эту функцию ниже.

 class newstr (str): def find_all (строка, подстрока): "" Функция: Возврат всего индекса подстроки в строку Аргументы: Строка и строка поиска Возврат: возврат списка "" length = len (подстрока) с = 0 indexes = [] в то время как c

newstr.find_all ( "Вы находите этот ответ полезным?" это!", 'this')

Источник

Python: найти все вхождения в строке

1. Используйте функцию string.count() для поиска всех вхождений подстроки в строке в Python
2. Используйте понимание списка и startswith() , чтобы найти все вхождения подстроки в строке в Python
3. Используйте re.finditer() , чтобы найти все вхождения подстроки в строке в Python

Подстрока в Python - это набор символов, который встречается в другой строке. Работа с подстроками часто может быть проблематичной. Одна из таких проблем - найти все вхождения подстроки в определенной строке.

В этом руководстве будут рассмотрены различные методы поиска всех вхождений подстроки в строке в Python.

Используйте функцию string.count() для поиска всех вхождений подстроки в строке в Python

string.count() - это встроенная функция в Python, которая возвращает количество или количество вхождений подстроки в данной конкретной строке. Кроме того, в нем есть дополнительные параметры start и end для указания индексов начальной и конечной позиций.

Метод count() просматривает строку и возвращает количество раз, когда определенная подстрока встречалась в строке.

Следующий код использует функцию string.count() для поиска всех вхождений подстроки в строку.

#defining string and substring str1 = "This dress looks good; you have good taste in clothes." substr = "good"  #occurrence of word 'good' in whole string count1 = str1.count(substr) print(count1)  #occurrence of word 'good' from index 0 to 25 count2 = str1.count(substr,0,25) print(count2) 

Это простой метод, который работает в любом случае. Единственный недостаток этого метода заключается в том, что он не возвращает различные индексы, по которым подстрока встречается в строке.

Используйте понимание списка и startswith() , чтобы найти все вхождения подстроки в строке в Python

Этому методу нужны две вещи: понимание списка и метод startswith() .

Функция startswith() выполняет задачу получения начальных индексов подстроки, а понимание списка используется для итерации по всей целевой строке.

Следующий код использует понимание списка и startswith() для поиска всех вхождений подстроки в строку.

# defining string str1 = "This dress looks good; you have good taste in clothes."  # defining substring substr = "good"  # printing original string print("The original string is : " + str1)  # printing substring print("The substring to find : " + substr)  # using list comprehension + startswith() # All occurrences of substring in string res = [i for i in range(len(str1)) if str1.startswith(substr, i)]  # printing result print("The start indices of the substrings are : " + str(res)) 

The original string is : This dress looks good; you have good taste in clothes. The substring to find : good The start indices of the substrings are : [17, 34] 

Используйте re.finditer() , чтобы найти все вхождения подстроки в строке в Python

re.finditer() - это функция библиотеки регулярных выражений, которую Python предоставляет программистам для использования в своем коде. Это помогает в выполнении задачи поиска вхождения определенного шаблона в строке. Чтобы использовать эту функцию, нам нужно сначала импортировать библиотеку регулярных выражений re .

re.finditer() использует в своем синтаксисе параметры pattern и string . В этом случае шаблон относится к подстроке.

Следующий код использует функцию re.finditer() для поиска всех вхождений подстроки в строку.

import re  # defining string str1 = "This dress looks good; you have good taste in clothes."  #defining substring substr = "good"  print("The original string is: " + str1)  print("The substring to find: " + substr)  result = [_.start() for _ in re.finditer(substr, str1)]  print("The start indices of the substrings are : " + str(result)) 

The original string is: This dress looks good; you have good taste in clothes. The substring to find: good The start indices of the substrings are : [17, 34] 

Vaibhhav is an IT professional who has a strong-hold in Python programming and various projects under his belt. He has an eagerness to discover new things and is a quick learner.

Сопутствующая статья - Python String

Copyright © 2023. All right reserved

Источник

Поиск всех вхождений подстроки в строке в Python

В Python есть несколько способов поиска подстроки в строке. Например, можно использовать методы find() и rfind() , которые возвращают индекс первого вхождения подстроки и индекс последнего вхождения подстроки соответственно.

s = "Привет, мир! Мир - прекрасен" print(s.find('мир')) # 8 print(s.rfind('мир')) # 13

Однако, эти методы не предоставляют информации обо всех вхождениях подстроки в строку. Например, если необходимо найти все вхождения слова «мир» в предложении «Привет, мир! Мир — прекрасен», то find() и rfind() не смогут с этим справиться.

В этом случае можно использовать регулярные выражения или цикл для прохождения по строке и поиска всех вхождений подстроки.

Использование регулярных выражений

Модуль re в Python предоставляет функцию finditer() , которая возвращает итератор, содержащий все вхождения подстроки в строке.

import re s = "Привет, мир! Мир - прекрасен" matches = re.finditer('мир', s) indices = [match.start() for match in matches] print(indices) # [8, 13]

Использование цикла

Можно использовать цикл и метод find() для поиска всех вхождений подстроки в строке.

s = "Привет, мир! Мир - прекрасен" substring = 'мир' indices = [] index = -1 # начинаем поиск с начала строки while True: # находим следующее вхождение подстроки index = s.find(substring, index + 1) # если вхождение не найдено, выходим из цикла if index == -1: break # добавляем индекс в список indices.append(index) print(indices) # [8, 13]

Таким образом, с помощью регулярных выражений или цикла можно найти все вхождения подстроки в строке.

Источник