Содержание

Метод find в Python

Автор Сергей Тимофеев На чтение 10 мин Просмотров 11.4к. Обновлено

В статье подробно разбираем метод find() в Python: описание, синтаксис, применение.

Содержание

  1. Описание метода find()
  2. Синтаксис
  3. Поиск символа или подстроки в строке
  4. Поиск символа в подстроке со start и end
  5. Проверка есть ли символ в строке
  6. Метод rfind()
  7. Вывод

Описание метода find()

Функция find() в языке python (питон) используется для поиска первого вхождения символа или подстроки во всей строке, либо только в ее отрезке.

Примечательно, что если в качестве аргумента, который необходимо найти, отправить подстроку, то ошибка не вернется. Вместо этого функция решит найти подстроку в строке python. Конечно, сначала будет казаться, что лучше бы возвращался и начальный и конечный элемент, но в таком случае тогда придется создавать список.

 

Да и к тому же, если разработчик будет знать размер искомой строки, индекс первого элемента, то он может получить и индекс последнего элемента, прибавив размер подстроки и отняв.

1. Метод find работает только со строками, для списков и словарей используются совсем другие методы.

Если же нужная подстрока или буква не были найдены внутри строки, то возвращается значение -1.

Кстати, если вы уже думаете сделать конструкцию, в которой с помощью функции find определяется индекс, а после сразу происходит вывод по этому индексу, то это плохая идея. Если буква не будет найдена, то будет возвращено значение -1 (как мы уже говорили).

Если обратиться к минус первому элементу, то питон вернет самый последний элемент (например, в слово «сайт» элемент с индексом -1 – это «т»). Дело в том, что когда в качестве индекса указывается отрицательное число, то минус исчезает, но отсчет начинается с конца.

Следственно, при работе с find стоит дополнительно использовать условия (о них читайте в предыдущих статьях).

Find – это своего рода человек с лупой, который выискивает нужную вещь по дорожке (строке)

Пройдите обучение “Программирование на Python”, нажимите на ссылку Топ Академии, чтобы записаться.

 

Учебная программа “Программирование на Python” создана для тех, кто хочет с нуля освоить 3й по популярности язык в мире, и создавать на нем от простых приложений до высоконагруженных web-сервисов.

В основе программы лежат реальные требования IT-рынка. Методисты и преподаватели постоянно работают над ее улучшением и обновлением, чтобы выпускники Академии Top могли достойно показать себя перед работодателем.

  • Введение в веб-технологий. Структура HTML. Форматирование текста с помощью HTML
  • Форматирование с помощью CSS. Списки. Отступы и поля
  • Графика в веб-дизайне. Оптимизация графики. Гиперссылки. Принципы навигации сайта
  • Таблицы. Формы. Фреймы
  • И многое другое

Синтаксис

Find не является самостоятельной функцией, а только методом для объекта типа string.

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

Сам синтаксис функции выглядит следующим образом:

s.find(str, start, end)

Вместо «string» необходимо указать строку, в которой происходит поиск, вместо char подставляем букву или подстроку, которые нужно найти. Последние два аргумента необходимы для установки начального и конечного значения, но об этом немного позже. Разберемся на конкретном примере.

Функция возвращает индекс символа

Поиск символа или подстроки в строке

У нас есть последовательность букв английского алфавита, но только в этой последовательности не все буквы, а потому вручную указать индекс не получится. Необходимо по введенной букве, определить ее индекс и вывести все буквы после этого индекса. И так, как будет выглядеть решение:

alphabet = "abcdfghjmnopqrsuvwxz" # алфавит с пробелами
symbol_for_find = input("Введите начальный символ:")
index_of_symbol = alphabet. find(symbol_for_find) # поиск индекса символа
if (index_of_symbol >= 0): # если метод find нашел символ, а потому не вернул отрицательное число
print(alphabet[index_of_symbol:]) # вывод строки от введенного индекса и до конца
else:
print("Простите, но в нашем псевдоалфавите нет введенной буквы")

Готово. Если бы не find, тогда разработчику пришлось бы создавать цикл while с счетчиком, сверять каждый элемент с введенным пользователем, а после, если символ был найден, выводить его индекс, который находился в счетчике. Не совсем удобно, потому рекомендуем пользоваться только готовой функцией.

Как мы видим, программа работает как часы

А если вспомнить, что с помощью циклов будет проблематично проверить подстроку, то это еще сильнее повышает любовь к встроенным функциям типа этой.

Читайте здесь про методы split и str.rsplit в языке Python.

Кстати, давайте попробуем искать не по символу, а по подстроке. Сразу пример из жизни: вспомните школьные года, когда на некоторых предметах было деление по группам. Представим, что необходимо вывести две части строки.

Первая часть – это первая группа, а вторая – вторая группа. Разделять их будет введённое имя.

Реализация (не забывайте, регистр важен):

students = "Karl, Misha, Olga, Steve, Oliver, Harry, Jone, Damir, Eliot, Mister" split_student = input("Введите имя студента, на котором начинается вторая группа:") 
split_index = students.find(split_student) # получаем разделительный индекс (индекс соответствует первому введенному символу) 
if(split_index >= 0): # проверяем его существование 
print("Первая группа:", students[:split_index - 2]) # выводим первую группу. -2 нужен для того, чтобы убрать лишние запятые в конце 
print("Вторая группа:", students[split_index:]) # выводим вторую группу 
else: print("Студент не найден")

и снова результат на картинке ниже.

Результат выполнения программы

Невероятно крутой инструмент, и при этом простой в исполнении.

Читайте здесь If-elif-else в Python

Поиск символа в подстроке со start и end

Периодически возникает необходимость искать только в отдельном отрезке строки.

Например, если на вход поступает строка формата: «Запись № 0001 *текст*», то искать нужно только после цифр, так как они не несут никакой ценности.

Или допустим есть строка: «*имена* — студенты, пришедшие на пересдачу».  Зачем обрабатывать эту константную фразу, ведь важны только имена. Так вот, чтобы ограничить отрезок, где будет проверяться элемент, используются необязательные аргументы start и end. Соответственно, start отвечает за начало отрезка строки, а end за конец.

По умолчанию start = 0, а end = -1. Название аргумента указывать необязательно.

То есть, в функции в первую очередь указывается символ для поиска, после начальный элемент, и только после этого конечный элемент.

Рассмотрим пример, когда нужно искать только с определенного элемента:

tasklist = "Задачи на сегодня: Купить продукты, навестить друга, найти работу, отвести машину в ремонт. Успеть бы до 11"
begin_char = tasklist.find(':') # мы знаем, что список начинается с двоеточия
end_char = -15 # убираем 15 последних символов с конца
text = input("Введите задачу, с которой нужно начать отсчет:")
index = tasklist. find(text, begin_char, end_char) # проверка с выбором начала и конца отрезка
if ( index >= 0 ):
	print (tasklist[index:end_char]) # вывести с выбранного индекса и до конца списка (но не строки)
else:
	print ("пункт не найден")
Результат выполнения

Как видно на скриншоте, слово «сегодня» есть в переменной, но оно не было найдено, так как не принадлежит промежутку, указанному при вызове метода, а потому в учет не принималось.

Проверка есть ли символ в строке

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

Достаточно сделать условие: если find вернул отрицательное число, значит нужной подстроки нет, иначе есть. Однако, это нерационально. Для таких случаев в python предусмотрено ключевое слово «in».

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

x = word in string

Если word есть в string, то x присвоится True, иначе False. Рассмотрим на реальном примере:

cities = "Moscow, Novosibirsk, Rostov, Magadan, Peterburg, Donetsk"
word = "Novosibirsk"
word1 = "Krasnodar"
x = word in cities
x1 = word1 in cities
print(x)
print(x1)

Как вы уже догадались, первый вывод будет True, а второй False. Так что на будущее: не придумывайте велосипед, если есть готовая замена.

Метод rfind()

Во всех примерах выше мы могли находить первое вхождение символа или подстроки. Однако, что делать, если считывать необходимо с конца. В таком случае необходимо использовать похожую по написанию функцию rfind.

Она начинает парсинг элементов с конца. И, кстати, нумерует она символы также сначала.

Допустим, если есть переменная из 20 символов, а нужный символ окажется на 18 позиции, то функция и вернет 18, а не 2 (ведь 20 – 18 = 2, а проверяет то она с конца).

Это полезно, главное не запутаться.

И как обычно пример:

string = "Эта простая строка, у которой в конце неожиданно буква ф в слове фольклор появилась"
x = string.
 
 rfind('ф')
print(x)

Программа выведет число 65, но если бы мы использовали find, то ответ был бы 55. Потому что тогда программа сначала бы увидела отдельную букву «ф», а после только «ф» в слове «фольклор».

Наглядное описание работы двух методов

Вывод

Сначала кажется, что метод find не несет никакой пользы. В будущем в практике часто придется искать индексы элементов по их значению. Например, чтобы делить строки или анализировать содержимое, ну или очищать мусорный контент. Главное научиться, а применение всегда найдется. Благодарим за прочтение.

 

Как найти символ в строке python методом find() c примерами

Часто нам нужно найти символ в строке python. Для решения этой задачи разработчики используют метод find(). Он помогает найти индекс первого совпадения подстроки в строке. Если символ или подстрока не найдены, find возвращает -1.

Синтаксис

string.find(substring,start,end)

Метод find принимает три параметра:

  • substring (символ/подстрока) — подстрока, которую нужно найти в данной строке.
  • start (необязательный) — первый индекс, с которого нужно начинать поиск. По умолчанию значение равно 0.
  • end (необязательный) — индекс, на котором нужно закончить поиск. По умолчанию равно длине строки.

Поиск символов методом find() со значениями по умолчанию

Параметры, которые передаются в метод, — это подстрока, которую требуются найти, индекс начала и конца поиска. Значение по умолчанию для начала поиска — 0, а для конца — длина строки.

В этом примере используем метод со значениями по умолчанию.

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

Копировать Скопировано Use a different Browser


>>> string = "Добро пожаловать!"
>>> print("Индекс первой буквы 'о':", string.find("о"))
Индекс первой буквы 'о': 1

Поиск не с начала строки с аргументом start

Можно искать подстроку, указав также начальное положение поиска.

В этом примере обозначим стартовое положение значением 8 и метод начнет искать с символа с индексом 8. Последним положением будет длина строки — таким образом метод выполнит поиска с индекса 8 до окончания строки.

Копировать Скопировано Use a different Browser


>>> string = "Специалисты назвали плюсы и минусы Python"
>>> print("Индекс подстроки 'али' без учета первых 8 символов:", string.find("али", 8))
Индекс подстроки 'али' без учета первых 8 символов: 16

Поиск символа в подстроке со start и end

С помощью обоих аргументов (start и end) можно ограничить поиск и не проводить его по всей строке. Найдем индексы слова «пожаловать» и повторим поиск по букве «о».

Копировать Скопировано Use a different Browser


>>> string = "Добро пожаловать!"
>>> start = string.find("п")
>>> end = string.find("ь") + 1
>>> print("Индекс первой буквы 'о' в подстроке:", string. find("о", start, end))
Индекс первой буквы 'о' в подстроке: 7

Проверка есть ли символ в строке

Мы знаем, что метод find() позволяет найти индекс первого совпадения подстроки. Он возвращает -1 в том случае, если подстрока не была найдена.

Копировать Скопировано Use a different Browser


>>> string = "Добро пожаловать!"
>>> print("Есть буква 'г'?", string.find("г") != -1)
Есть буква 'г'? False
>>> print("Есть буква 'т'?", string.find("т") != -1)
Есть буква 'т'? True

Поиск последнего вхождения символа в строку

Функция rfind() напоминает find(), а единое отличие в том, что она возвращает максимальный индекс. В обоих случаях же вернется -1, если подстрока не была найдена.

В следующем примере есть строка «Добро пожаловать!». Попробуем найти в ней символ «о» с помощью методов find() и rfind().

Копировать Скопировано Use a different Browser


>>> string = "Добро пожаловать"
>>> print("Поиск 'о' методом find:", string.find("о"))
Поиск 'о' методом find: 1
>>> print("Поиск 'о' методом rfind:", string.rfind("о"))
Поиск 'о' методом rfind: 11

Вывод показывает, что find() возвращает индекс первого совпадения подстроки, а rfind() — последнего совпадения.

Второй способ поиска — index()

Метод index() помогает найти положение данной подстроки по аналогии с find(). Единственное отличие в том, что index() бросит исключение в том случае, если подстрока не будет найдена, а find() просто вернет -1.

Вот рабочий пример, показывающий разницу в поведении index() и find():

Копировать Скопировано Use a different Browser


>>> string = "Добро пожаловать"
>>> print("Поиск 'о' методом find:", string. find("о"))
Поиск 'о' методом find: 1
>>> print("Поиск 'о' методом index:", string.index("о"))
Поиск 'о' методом index: 1

В обоих случаях возвращается одна и та же позиция. А теперь попробуем с подстрокой, которой нет в строке:

Копировать Скопировано Use a different Browser


>>> string = "Добро пожаловать"
>>> print("Поиск 'г' методом find:", string.find("г"))
Поиск 'г' методом find: 1
>>> print("Поиск 'г' методом index:", string.index("г"))
Traceback (most recent call last):
File "pyshell#21", line 1, in module
print("Поиск 'г' методом index:", string.index("г"))
ValueError: substring not found

В этом примере мы пытались найти подстроку «г». Ее там нет, поэтому find() возвращает -1, а index() бросает исключение.

Поиск всех вхождений символа в строку

Чтобы найти общее количество совпадений подстроки в строке можно использовать ту же функцию find(). Пройдемся циклом while по строке и будем задействовать параметр start из метода find().

Изначально переменная start будет равна -1, что бы прибавлять 1 у каждому новому поиску и начать с 0. Внутри цикла проверяем, присутствует ли подстрока в строке с помощью метода find.

Если вернувшееся значение не равно -1, то обновляем значением count.

Вот рабочий пример:

Копировать Скопировано Use a different Browser


my_string = "Добро пожаловать"
start = -1
count = 0
while True:
start = my_string.find("о", start+1)
if start == -1:
break
count += 1
print("Количество вхождений символа в строку: ", count )
Количество вхождений символа в строку:  4

Выводы

  • Метод find() помогает найти индекс первого совпадения подстроки в данной строке. Возвращает -1, если подстрока не была найдена.
  • В метод передаются три параметра: подстрока, которую нужно найти, start со значением по умолчанию равным 0 и end со значением по умолчанию равным длине строки.
  • Можно искать подстроку в данной строке, задав начальное положение, с которого следует начинать поиск.
  • С помощью параметров start и end можно ограничить зону поиска, чтобы не выполнять его по всей строке.
  • Функция rfind() повторяет возможности find(), но возвращает максимальный индекс (то есть, место последнего совпадения). В обоих случаях возвращается -1, если подстрока не была найдена.
  • index() — еще одна функция, которая возвращает положение подстроки. Отличие лишь в том, что index() бросает исключение, если подстрока не была найдена, а find() возвращает -1.
  • find() можно использовать в том числе и для поиска общего числа совпадений подстроки.

Метод Python String find()

❮ Строковые методы

Пример

Где в тексте слово «добро пожаловать»?:

txt = «Привет, добро пожаловать в мой мир».

x = txt.find(«добро пожаловать»)

print(x)

Попробуйте сами »

Определение и использование

Метод find() находит первое возникновение указанного значения.

Метод find() возвращает -1, если значение не найден.

Метод find() почти такой же, как индекс() метод, единственная разница в том, что index() метод вызывает исключение, если значение не найдено. (См. пример ниже)

Синтаксис

строка .find( значение, начало, конец )

Значения параметров

1 Параметр

Описание
значение Обязательно. Значение для поиска
начало Дополнительно. С чего начать поиск. По умолчанию 0
конец Дополнительно. Где закончить поиск. По умолчанию до конца строки

Другие примеры

Пример

Где в тексте первое вхождение буквы «e»?:

txt = «Привет, добро пожаловать в мой мир».

х = txt.find(«е»)

print(x)

Попробуй сам »

Пример

Где в тексте первое появление буквы «e» при вы ищете только между позициями 5 и 10?:

txt = «Привет, добро пожаловать в мой мир».

х = txt.find («е», 5, 10)

print(x)

Попробуйте сами »

Пример

Если значение не найдено, метод find() возвращает -1, но index() метод вызовет исключение:

txt = «Привет, добро пожаловать в мой мир».

print(txt.find(«q»))
print(txt.index(«q»))

Попробуйте сами »

❮ Строковые методы


ВЫБОР ЦВЕТА

Лучшие учебники
Учебник по HTML
Учебник по CSS
Учебник по JavaScript
Учебник How To
Учебник по SQL
Учебник по Python
Учебник по W3. CSS
Учебник по Bootstrap
Учебник по PHP
Учебник по Java
Учебник по C++
Учебник по jQuery

900324 Справочник по HTML
Справочник по CSS
Справочник по JavaScript
Справочник по SQL
Справочник по Python
Справочник по W3.CSS
Справочник по Bootstrap
Справочник по PHP
Цвета HTML
Справочник по Java
Справочник по Angular
Справочник по jQuery

Top4 Examples Примеры HTML

Примеры CSS
Примеры JavaScript
Примеры инструкций
Примеры SQL
Примеры Python
Примеры W3.CSS
Примеры Bootstrap
Примеры PHP
Примеры Java
Примеры XML
Примеры jQuery

FORUM | О

W3Schools оптимизирован для обучения и обучения. Примеры могут быть упрощены для улучшения чтения и обучения. Учебники, ссылки и примеры постоянно пересматриваются, чтобы избежать ошибок, но мы не можем гарантировать полную правильность всего содержания. Используя W3Schools, вы соглашаетесь прочитать и принять наши условия использования, куки-файлы и политика конфиденциальности.

Copyright 1999-2023 Refsnes Data. Все права защищены.
W3Schools работает на основе W3.CSS.

Метод Python String find() — Темы масштабирования

Обзор

find() — это библиотечная функция Python, которая используется для поиска индекса первого вхождения подстроки в заданной строке. Если find() не может найти подстроку, она возвращает -1 вместо создания исключения.

Прежде чем читать эту статью, ознакомьтесь со следующими темами программирования на Python:

  • Указатели в C
  • Транспонирование матрицы в C

Введение

При создании программного обеспечения есть определенные задачи, которые требуют от нас поиска некоторых слов/предложений. Предположим, вы создаете текстовый редактор, тогда одной из наиболее важных функций является функция «Найти и заменить». Для этого вам нужно искать слова и даже предложения в документе. В таких случаях на помощь приходит функция find() .

Функция find() является частью библиотеки Python. find() принимает строку в качестве входных данных. Он используется для нахождения индекса первое вхождение подстроки внутри данной строки. Если подстрока отсутствует, возвращается -1 , но не генерируется исключение.

Синтаксис функции find() в Python 

 
 string.find(подстрока, начало, конец)
  • строка — исходное предложение/слово, в котором вы хотите найти подстроку.
  • подстрока — это предложение/слово, которое вы должны искать.
  • start и end являются необязательными параметрами . Они указывают диапазон, в котором нужно искать подстроку.

Что возвращает Python find()?

  • Если подстрока существует в строке, то будет возвращен индекс первого вхождения подстроки .
  • Если подстрока не существует, возвращается -1 .

Вот пример,

 
 параграф = 'Я изучаю Python, и это отличный язык'
печать (абзац. найти ('I'))
печать (абзац. найти ('q'))

Вывод:

В этом коде мы создали абзац с именами строковых переменных и вызвали find() , чтобы найти вхождения « I » и « q ». Здесь « I » стоит в самом начале строки, поэтому возвращается ее индекс 0 , но во втором случае « q » не найден, поэтому мы получаем -1

Давайте рассмотрим различные типы примеров

1) Начальный и конечный аргументы не указаны 

 
 str = 'python очень прост в освоении и работе с ним '
print("найдено по адресу: ", str.find('python'))
печать (стр.найти ('q'))

Вывод: 

 
 найдено по адресу: 0
-1

Здесь мы создали переменную str, содержащую предложение, а затем вызвали find() на str и передал ему в качестве аргумента ‘ python ‘. Итак, find() будет искать ‘ python ‘ в строке str и вернуть индекс его первого вхождения в строку str

Когда аргументы start и end не заданы, тогда find() начинает искать с начала и ищет до конца строки.

Что, если мы используем аргументы по умолчанию? 

 
 str = 'Я очень рано понял разницу между знанием названия чего-либо и знанием чего-либо'.
print("найдено по адресу: ", str.find('difference'))

Вывод: 

 
 найдено по адресу:25

Если вы не передаете аргументы start и end , то используются их значения по умолчанию. Значение по умолчанию для начала — 0 , а для конца — . Длина строки .

2) Приведены начальные и конечные аргументы 

 
 str = 'Усердно изучайте то, что вас больше всего интересует, самым недисциплинированным, непочтительным и оригинальным способом. '
print("найдено по адресу: ", str.find('интересы', 10, 30))
print("найдено по адресу: ", str.find('интересы', 30, 40))

Выход 

 
 найдено по адресу: 16
найдено по адресу: -1

Здесь мы создали переменную с именем str и сохранили в ней предложение. Затем мы вызываем find() и передаем ему ‘interests ‘, 10 и 30 в качестве аргументов. 10 сообщает find() , что он должен начать поиск подстроки (т.е. интересов ) с 10-й позиции , а 30 сообщает find() искать до 30-й положение и не более того.

Итак, аргументы start и end задают диапазон, а find() ищет подстроку только в этом диапазоне.

‘ Interest ‘ занимает 16-ю позицию , которая находится между 10 и 30, поэтому для первого print() вывод равен 16, а для второго -1, поскольку ‘ Interest ‘ не присутствует между 30 и 40.

3) Дан только начальный аргумент 

 
 str = 'Усердно изучайте то, что вас больше всего интересует, самым недисциплинированным, непочтительным и оригинальным способом.'
print("найдено по адресу: ", str.find('интересы', 10))
print("найдено по адресу: ", str.find('интересы', 30))

Вывод: 

 
 найдено по адресу: 16
найдено по адресу: -1

Здесь мы снова сохранили предложение в переменной с именем str и вызываем find() на str и передаем «interests » и 10 в качестве аргументов. 10 здесь говорит find() что он должен начать поиск с 10-го индекса , а поскольку нет конечного аргумента, он будет искать до конца строки.

Если указано только начало, конец автоматически принимает значение по умолчанию, т. е. длину строки. Итак, здесь мы определяем начальный диапазон, но не конечный диапазон.

‘ Interest ‘ занимает 16-ю позицию , поэтому для первого print() вывод равен 16, а для второго -1 как ‘ интересы ‘нет после 16.

Могу ли я найти позицию подстроки?

Да, конечно можете.

 
 str = 'Я очень рано понял разницу между знанием названия чего-либо и знанием чего-либо'.
print("найдено по адресу: ", str.find('очень рано'))

Вывод:

В find() вы можете передать целое предложение в качестве ввода. Здесь мы передали « очень рано » в качестве входных данных для 9.0189 find() и find() ищет « очень рано » в строке str и возвращает 10 в качестве позиции « очень рано », что является правильной позицией.

Что такое rfind() в Python?

rfind() похож на find() , но есть небольшая разница. rfind() возвращает наивысший индекс подстроки. Аналогично find() возвращает -1 , если подстрока не найдена.

Его синтаксис такой же, как у find(), и он также принимает те же аргументы, что и find().

Вот пример, который прояснит ситуацию.

 
 myStr = "py py py py"
печать (myStr.find («py»))
печать (myStr.rfind ("py"))

Вывод:

Здесь мы сначала создали строковую переменную с именем myStr и вызвали для нее find() и rfind() . find() возвратил 0 и rfind() возвратил 9 .

Это связано с тем, что rfind() вернул индекс последнего вхождения из ‘ py ‘, а find() вернул индекс первого вхождения из ‘ py ‘.

Python String index()

Функция index() также является библиотечной функцией Python. Эта функция возвращает позицию подстроки точно так же, как find() , но разница в том, что index() выдаст ValueError , если подстрока отсутствует в строке. В таком случае find() возвращает -1.

 
 myStr = "py py py py"
печать (myStr.find («js»))
печать (myStr.index («js»))

Выход: 

 
 -1
Traceback (последний последний вызов):
  Файл "D:\Programming\python\article\find.py", строка 38, в 
    печать (myStr.index («js»))
ValueError: подстрока не найдена

Здесь вы можете видеть, что функция find() вернула -1 , тогда как index() выдал ошибку , не найденную подстроку .

Как найти общее количество вхождений подстроки?

Это тоже простая задача, мы можем сделать это с помощью find() и цикла.

 
 RepeatingStr = 'Это повторяющаяся строка, повторяющаяся строка, повторяющаяся строка.'
начало = 0
вхождения = 0
для i в диапазоне (len (repeatingStr)):
    j = RepeatingStr.find('повторение', начало)
    если (j! = -1):
        начало = j+1
        вхождения += 1
print("Всего вхождений: ", вхождений)

Вывод: 

 
 Всего вхождений: 3

В этом коде сначала мы установили значение начала и вхождения равными 0, а затем использовали цикл for для перебора строки repeatingStr.

Внутри цикла мы вызываем find() , чтобы проверить, находится ли подстрока ‘ Repeating ‘ внутри repearingStr или нет.

Если она присутствует, то мы добавляем 1 к значению start и увеличиваем значение вхождений на 1. Причина, по которой мы добавляем 1 к start, заключается в том, что подстрока не считается дважды.

Когда цикл завершен, печатается значение вхождений.

Сводка

  • find() возвращает первое вхождение подстроки в заданной строке. Он вернет -1 , если подстрока отсутствует.
  • find() может принимать 3 параметра: подстрока , начало , конец . Начало и конец опционально .
  • начало и end полезны, когда вам нужно искать подстроку в определенной позиции внутри строки.
  • rfind() аналогичен find() , но возвращает последнее вхождение подстроки.

    No related posts.