Python поиск подстроки в строке: python — Поиск подстроки в строке

Строка Python __contains__(). Этот метод используется для проверки наличия строки в другой строке или нет.

Python3

Вывод

 Да! Компьютерщики-13 содержат.
Да! Выродки-78 содержат. 

RegEx можно использовать для проверки наличия в строке указанного шаблона поиска. В Python есть встроенный пакет re , который можно использовать для работы с регулярными выражениями.

Python3

Выход

 NO, String 'Geeks' Not In String in String in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in in wort in worpt in out in in in out in wout in worpl 

Метод: Использование Постижения списка

Python3

Output

 ['yes'] 

Method: Using lambda function

Python3

Output

 ['yes'] 

Method: Using countof функция

Python3

Output

 ['yes'] 

Как проверить, содержит ли строка Python подстроку — настоящий Python

чтобы проверить, содержит ли строка другую строку в Python.

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

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

Наконец, вы также узнаете, как найти подстроки в столбцах pandas . Это полезно, если вам нужно выполнить поиск данных из CSV-файла. Вы могли бы использовать подход, который вы узнаете в следующем разделе, но если вы работаете с табличные данные , лучше всего загрузить данные в pandas DataFrame и искать подстроки в pandas.

Как убедиться, что строка Python содержит другую строку

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

>>>

 >>> raw_file_content = """Привет и добро пожаловать.
... Это специальный скрытый файл с СЕКРЕТНЫМ секретом.
... Я не хочу раскрывать тебе Секрет,
... но я хочу по секрету сказать вам, что он у меня есть."""
>>> "секрет" в raw_file_content
Истинный
 

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

Примечание: Если вы хотите проверить, является ли подстрока , а не в строке, вы можете использовать не в :

>>>

 >>> "secret" не в raw_file_content
ЛОЖЬ
 

Поскольку подстрока "секретная" присутствует в raw_file_content , оператор не в возвращает False .

При использовании в выражение возвращает логическое значение:

• Истинно , если Python нашел подстроку
• Ложь , если Python не нашел подстроку

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

>>>

 >>> если "секрет" в raw_file_content:
... печать("Найдено!")
...
Найденный!
 

В этом фрагменте кода вы используете оператор принадлежности, чтобы проверить, является ли "secret" подстрокой raw_file_content . Если это так, то вы напечатаете сообщение на терминал. Любой код с отступом будет выполняться только в том случае, если проверяемая вами строка Python содержит предоставленную вами подстроку.

Примечание: Python всегда рассматривает пустые строки как подстроку любой другой строки, поэтому проверка на наличие пустой строки в строке возвращает True :

>>>

 >>> "" в "секрет"
Истинный
 

Это может показаться удивительным, поскольку Python считает строки emtpy ложными, но это крайний случай, о котором полезно помнить.

Оператор членства в — ваш лучший друг, если вам просто нужно проверить, содержит ли строка Python подстроку.

Однако что, если вы хотите узнать больше о подстроке? Если вы прочитаете текст, хранящийся в raw_file_content , то вы заметите, что подстрока встречается более одного раза и даже в разных вариациях!

Какие из этих вхождений нашел Python? Имеет ли значение заглавная буква? Как часто эта подстрока встречается в тексте? И каково расположение этих подстрок? Если вам нужен ответ на любой из этих вопросов, продолжайте читать.

Удалить рекламу

Обобщить проверку, удалив чувствительность к регистру

Строки Python чувствительны к регистру. Если подстрока, которую вы предоставляете, использует заглавные буквы, отличные от того же слова в вашем тексте, то Python не найдет ее. Например, если вы проверяете строчное слово "secret" в заглавной версии исходного текста, проверка оператора принадлежности возвращает False :

>>>

 >>> title_cased_file_content = """Привет и добро пожаловать.
... Это специальный скрытый файл с секретным секретом.
... Я не хочу рассказывать вам секрет,
... Но я хочу по секрету сказать вам, что он у меня есть.
>>> "секрет" в title_cased_file_content
ЛОЖЬ
 

Несмотря на то, что слово секрет появляется несколько раз в тексте заголовка title_cased_file_content , никогда не появляется во всех строчных буквах. Вот почему проверка, которую вы выполняете с оператором членства, возвращает False . Python не может найти строчную строку «секрет» в предоставленном тексте.

У людей другой подход к языку, чем у компьютеров. Вот почему вы часто хотите игнорировать заглавные буквы, когда проверяете, содержит ли строка подстроку в Python.

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

>>>

 >>> file_content = title_cased_file_content.lower()
>>> печать (файл_содержимое)
привет и добро пожаловать.
это специальный скрытый файл с секретным секретом.
я не хочу раскрывать тебе тайну,
но я хочу по секрету сказать вам, что у меня есть один.
>>> "секрет" в файле_содержимого
Истинный
 

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

Примечание: В следующих примерах вы продолжите работать с file_content , версией текста в нижнем регистре.

Если вы работаете с исходной строкой ( raw_file_content ) или с заголовком ( title_cased_file_content ), вы получите разные результаты, потому что они не в нижнем регистре. Не стесняйтесь попробовать это, пока вы работаете с примерами!

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

Узнайте больше о подстроке

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

Python предоставляет множество дополнительных строковых методов, которые позволяют вам проверять, сколько целевых подстрок содержит строка, искать подстроки в соответствии со сложными условиями или находить индекс подстроки в вашем тексте.

В этом разделе вы познакомитесь с некоторыми дополнительными строковыми методами, которые помогут вам больше узнать о подстроке.

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

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

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

Если вам нужно знать, где в вашей строке встречается подстрока, вы можете использовать .index() для строкового объекта:

>>>

 >>> file_content = """привет и добро пожаловать. 
... это специальный скрытый файл с секретным секретом.
... я не хочу раскрывать тебе секрет,
... но я хочу по секрету сказать вам, что он у меня есть."""
>>> file_content.index("секрет")
59

Когда вы вызываете .index() для строки и передаете ей подстроку в качестве аргумента, вы получаете позицию индекса первого символа первого вхождения подстроки.

Примечание: Если Python не может найти подстроку, то .index() вызывает исключение ValueError .

Но что, если вы хотите найти другие вхождения подстроки? Метод .index() также принимает второй аргумент, который может определить, с какой позиции индекса начинать поиск. Таким образом, передавая определенные позиции индекса, вы можете пропустить вхождения подстроки, которую вы уже идентифицировали:

>>>

 >>> file_content.index("секрет", 60)
66
 

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

Это означает, что текст содержит подстроку более одного раза. Но как часто он там?

Вы можете использовать .count() , чтобы быстро получить ответ, используя описательный и идиоматический код Python:

>>>

 >>> file_content.count("секрет")
4
 

Вы использовали .count() в строчной строке и передали подстроку "secret" в качестве аргумента. Python подсчитал, как часто подстрока появляется в строке, и вернул ответ. Текст содержит подстроку четыре раза. Но как выглядят эти подстроки?

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

>>>

 >>> для слова в file_content.split():
... если "секретно" в слове:
... печать (слово)
...
секрет
секрет. 
секрет,
тайно
 

В этом примере вы используете .split() для разделения текста в пробелах на строки, которые Python упаковывает в список. Затем вы перебираете этот список и используете в для каждой из этих строк, чтобы увидеть, содержит ли она подстроку "secret" .

Примечание: Вместо того, чтобы печатать подстроки, вы также можете сохранить их в новом списке, например, используя понимание списка с условным выражением:

>>>

 >>> [дословно в file_content.split () если "секрет" в слове]
['секретно', 'секретно.', 'секретно', 'тайно']
 

В этом случае вы строите список только из слов, содержащих подстроку, что существенно фильтрует текст.

Теперь, когда вы можете проверить все подстроки, которые идентифицирует Python, вы можете заметить, что Python не заботится о том, есть ли какие-либо символы после подстроки 9.0039 "секрет" или нет. Он находит слово независимо от того, следует ли за ним пробел или знак препинания. Он даже находит такие слова, как «тайно» .

Это приятно знать, но что делать, если вы хотите установить более строгие условия для проверки подстроки?

Удалить рекламу

Найти подстроку с условиями с помощью регулярного выражения

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

В таких случаях, когда требуется более сложное сопоставление строк, вы можете использовать регулярные выражения или регулярные выражения с модулем Python re .

Например, если вы хотите найти все слова, начинающиеся с «секрет» , но за которыми следует хотя бы одна дополнительная буква, вы можете использовать символ слова регулярного выражения ( \w ), за которым следует квантификатор плюса. ( + ):

>>>

 >>> импорт
>>> file_content = """привет и добро пожаловать. 
... это специальный скрытый файл с секретным секретом.
... я не хочу раскрывать тебе секрет,
... но я хочу по секрету сказать вам, что он у меня есть."""
>>> re.search(r"secret\w+", file_content)

 

Функция re.search() возвращает как подстроку, соответствующую условию, так и ее начальную и конечную позиции индекса, а не просто True !

Затем вы можете получить доступ к этим атрибутам с помощью методов объекта Match , который обозначается m :

>>>

 >>> m = re.search(r"secret\w+", file_content)
>>> м.группа()
'тайно'
>>> м.промежуток()
(128, 136)
 

Эти результаты обеспечивают большую гибкость для продолжения работы с совпавшей подстрокой.

Например, вы можете искать только те подстроки, за которыми следует запятая (, ) или точка (. ):

>>>

 >>> re. search(r"секрет[\.,]", file_content)

 

В вашем тексте есть два возможных совпадения, но вы сопоставили только первый результат, соответствующий вашему запросу. Когда вы используете re.search() , Python снова находит только первых совпадений . Что делать, если вы хотите все упоминания "секретные" которые соответствуют определенному условию?

Чтобы найти все совпадения, используя re , вы можете работать с re.findall() :

>>>

 >>> re.findall(r"секрет[\.,]", file_content)
['секрет.', 'секрет']
 

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

Когда вы используете группу захвата, вы можете указать, какую часть совпадения вы хотите оставить в своем списке, заключив эту часть в круглые скобки:

>>>

 >>> re. findall(r"(секрет)[\.,]", file_content)
['секрет', 'секрет']
 

Заключив секрет в круглые скобки, вы определили единую группу захвата. Функция findall() возвращает список строк, соответствующих этой захватываемой группе, если в шаблоне имеется ровно одна захватываемая группа. Добавив скобки вокруг secret , вам удалось избавиться от пунктуации!

Примечание: Помните, что в вашем тексте было четыре вхождения подстроки "secret" , и, используя re , вы отфильтровали два конкретных вхождения, которые вы сопоставили в соответствии с особыми условиями.

Использование re.findall() с группами соответствия — это мощный способ извлечения подстрок из вашего текста. Но вы получаете только список из строк , что означает, что вы потеряли позиции индекса, к которым у вас был доступ при использовании re.search() .

Если вы хотите сохранить эту информацию, то re может дать вам все совпадения в итераторе:

>>>

 >>> для совпадения в re. finditer(r"(secret)[\.,]", file_content):
... печать (совпадение)
...


 

Когда вы используете re.finditer() и передаете шаблон поиска и текстовое содержимое в качестве аргументов, вы можете получить доступ к каждому Совпадение с объектом , который содержит подстроку, а также ее начальную и конечную позиции индекса.

Вы можете заметить, что в этих результатах появляются знаки препинания, даже если вы все еще используете группу захвата. Это связано с тем, что строковое представление объекта Match отображает все совпадение, а не только первую группу захвата.

Но объект Match является мощным контейнером информации, и, как вы уже видели ранее, вы можете выбрать именно ту информацию, которая вам нужна:

>>>

 >>> для совпадения в re.finditer(r"(secret)[\.,]", file_content):
. .. печать (соответствие.группа (1))
...
секрет
секрет
 

Вызвав .group() и указав, что вам нужна первая группа захвата, вы выбрали слово секрет без знаков препинания из каждой совпадающей подстроки.

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

Примечание: Если вы хотите узнать больше об использовании групп захвата и составлении более сложных шаблонов регулярных выражений, вы можете глубже изучить регулярные выражения в Python.

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

Удалить рекламу

Найти подстроку в столбце pandas DataFrame

Если вы работаете с данными, которые поступают не из простого текстового файла или пользовательского ввода, а из файла CSV или листа Excel, вы можете использовать тот же подход, который обсуждался выше.

Однако есть лучший способ определить, какие ячейки в столбце содержат подстроку: вы будете использовать pandas ! В этом примере вы будете работать с CSV-файлом, содержащим поддельные названия компаний и слоганы. Вы можете скачать файл ниже, если хотите работать вместе:

Когда вы работаете с табличными данными в Python, обычно лучше сначала загрузить их в pandas DataFrame :

>>>

 >>> импортировать панд как pd
>>> компании = pd.read_csv("companies.csv")
>>> компании.форма
(1000, 2)
>>> компании.голова()
             слоган компании
0 Кувалис-Нолан произвели революцию в метриках следующего поколения
1. Дитрих-Шамплин предлагает передовые функциональные возможности
2 ориентированных на пользователя информационных посредника West Inc.
3 ООО «Венер» использует липких информационных посредников
4 Langworth Inc заново изобретает магнитные сети
 

В этом блоке кода вы загрузили файл CSV, содержащий тысячу строк поддельных данных компании, в кадр данных pandas и проверили первые пять строк, используя . head() .

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

>>>

 >>> компании[companies.slogan.str.contains("секрет")]
              слоган компании
7 Maggio LLC нацелена на секретные ниши
117 фирменных секретных методологий Kub and Sons
654 Секретные парадигмы синдиката Косс-Зулауф
656 Бернье-Кин тайно синтезирует внутреннюю полосу пропускания
921 Ward-Shield использует секретную электронную коммерцию
945 Williamson Group выпускает секретные экшн-предметы
 

Вы можете использовать .str.contains() в столбце pandas и передать ему подстроку в качестве аргумента для фильтрации строк, содержащих подстроку.

Примечание: Оператор индексирования ( [] ) и оператор атрибута ( . ) предлагают интуитивно понятные способы получения отдельного столбца или фрагмента DataFrame.

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

Когда вы работаете с .str.contains() и вам нужны более сложные сценарии сопоставления, вы также можете использовать регулярные выражения! Вам просто нужно передать шаблон поиска, совместимый с регулярным выражением, в качестве аргумента подстроки:

>>>

 >>> компании[companies.slogan.str.contains(r"secret\w+")]
          слоган компании
656 Бернье-Кин тайно синтезирует внутреннюю полосу пропускания
 

В этом фрагменте кода вы использовали тот же шаблон, что и ранее, для сопоставления только слов, содержащих секрет , но затем продолжите с одним или несколькими символами слова ( \w+ ). Кажется, только одна из компаний в этом поддельном наборе данных тайно управляет !

Вы можете написать любой сложный шаблон регулярного выражения и передать его . str.contains() , чтобы вырезать из столбца pandas только те строки, которые вам нужны для анализа.

Заключение

Как настойчивый охотник за сокровищами, вы нашли каждый «секрет» , как бы хорошо он ни был спрятан! В процессе вы узнали, что лучший способ проверить, содержит ли строка подстроку в Python, — это использовать в операторе членства .

Вы также узнали, как описательно использовать два других строковых метода , которые часто неправильно используются для проверки подстрок:

• .count() для подсчета вхождений подстроки в строку
• .index() , чтобы получить позицию индекса начала подстроки

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

Наконец, вы также узнали, как можно использовать метод DataFrame .