Python поиск замена подстроки

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

isalpha() : возвращает True, если строка состоит только из алфавитных символов
islower() : возвращает True, если строка состоит только из символов в нижнем регистре
isupper() : возвращает True, если все символы строки в верхнем регистре
isdigit() : возвращает True, если все символы строки — цифры
isnumeric() : возвращает True, если строка представляет собой число
startswith(str) : возвращает True, если строка начинается с подстроки str
endswith(str) : возвращает True, если строка заканчивается на подстроку str
lower() : переводит строку в нижний регистр
upper() : переводит строку в вехний регистр
title() : начальные символы всех слов в строке переводятся в верхний регистр
capitalize() : переводит в верхний регистр первую букву только самого первого слова строки
lstrip() : удаляет начальные пробелы из строки
rstrip() : удаляет конечные пробелы из строки
strip() : удаляет начальные и конечные пробелы из строки
ljust(width) : если длина строки меньше параметра width, то справа от строки добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по левому краю
rjust(width) : если длина строки меньше параметра width, то слева от строки добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по правому краю
center(width) : если длина строки меньше параметра width, то слева и справа от строки равномерно добавляются пробелы, чтобы дополнить значение width, а сама строка выравнивается по центру
find(str[, start [, end]) : возвращает индекс подстроки в строке. Если подстрока не найдена, возвращается число -1
replace(old, new[, num]) : заменяет в строке одну подстроку на другую
split([delimeter[, num]]) : разбивает строку на подстроки в зависимости от разделителя
partition(delimeter) : разбивает строку по разделителю на три подстроки и возвращает кортеж из трех элементов — подстрока до разделителя, разделитель и подстрока после разделителя
join(strs) : объединяет строки в одну строку, вставляя между ними определенный разделитель

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

string = input("Введите число: ") if string.isnumeric(): number = int(string) print(number)

Проверка, начинается или оканчивается строка на определенную подстроку:

file_name = "hello.py" starts_with_hello = file_name.startswith("hello") # True ends_with_exe = file_name.endswith("exe") # False

Удаление пробелов в начале и в конце строки:

string = " hello world! " string = string.strip() print(string) # hello world!

Дополнение строки пробелами и выравнивание:

print("iPhone 7:", "52000".rjust(10)) print("Huawei P10:", "36000".rjust(10))

iPhone 7: 52000 Huawei P10: 36000

Поиск в строке

Для поиска подстроки в строке в Python применяется метод find() , который возвращает индекс первого вхождения подстроки в строку и имеет три формы:

find(str) : поиск подстроки str ведется с начала строки до ее конца
find(str, start) : параметр start задает начальный индекс, с которого будет производиться поиск
find(str, start, end) : параметр end задает конечный индекс, до которого будет идти поиск

Если подстрока не найдена, метод возвращает -1:

welcome = "Hello world! Goodbye world!" index = welcome.find("wor") print(index) # 6 # поиск с 10-го индекса index = welcome.find("wor",10) print(index) # 21 # поиск с 10 по 15 индекс index = welcome.find("wor",10,15) print(index) # -1

Замена в строке

Для замены в строке одной подстроки на другую применяется метод replace() :

replace(old, new) : заменяет подстроку old на new
replace(old, new, num) : параметр num указывает, сколько вхождений подстроки old надо заменить на new. По умолчанию num равно -1, что соответствует первой версии метода и приводит к замене всех вхождений.

phone = "+1-234-567-89-10" # замена дефисов на пробел edited_phone = phone.replace("-", " ") print(edited_phone) # +1 234 567 89 10 # удаление дефисов edited_phone = phone.replace("-", "") print(edited_phone) # +12345678910 # замена только первого дефиса edited_phone = phone.replace("-", "", 1) print(edited_phone) # +1234-567-89-10

Разделение на подстроки

Метод split() разбивает строку на список подстрок в зависимости от разделителя. В качестве разделителя может выступать любой символ или последовательность символов. Данный метод имеет следующие формы:

split() : в качестве разделителя используется пробел
split(delimeter) : в качестве разделителя используется delimeter
split(delimeter, num) : параметр num указывает, сколько вхождений delimeter используется для разделения. Оставшаяся часть строки добавляется в список без разделения на подстроки

text = "Это был огромный, в два обхвата дуб, с обломанными ветвями и с обломанной корой" # разделение по пробелам splitted_text = text.split() print(splitted_text) print(splitted_text[6]) # дуб, # разбиение по запятым splitted_text = text.split(",") print(splitted_text) print(splitted_text[1]) # в два обхвата дуб # разбиение по первым пяти пробелам splitted_text = text.split(" ", 5) print(splitted_text) print(splitted_text[5]) # обхвата дуб, с обломанными ветвями и с обломанной корой

Еще один метод — partition() разбивает строку по разделителю на три подстроки и возвращает кортеж из трех элементов — подстрока до разделителя, разделитель и подстрока после разделителя:

text = "Это был огромный, в два обхвата дуб, с обломанными ветвями и с обломанной корой" text_parts = text.partition("дуб") print(text_parts) # ('Это был огромный, в два обхвата ', 'дуб', ', с обломанными ветвями и с обломанной корой')

Если разделитель с строке не найден, то возвращается кортеж с одной строкой.

Соединение строк

При рассмотрении простейших операций со строками было показано, как объединять строки с помощью операции сложения. Другую возможность для соединения строк представляет метод join() : он объединяет список строк. Причем текущая строка, у которой вызывается данный метод, используется в качестве разделителя:

words = ["Let", "me", "speak", "from", "my", "heart", "in", "English"] # разделитель - пробел sentence = " ".join(words) print(sentence) # Let me speak from my heart in English # разделитель - вертикальная черта sentence = " | ".join(words) print(sentence) # Let | me | speak | from | my | heart | in | English

Вместо списка в метод join можно передать простую строку, тогда разделитель будет вставляться между символами этой строки:

word = "hello" joined_word = "|".join(word) print(joined_word) # h|e|l|l|o

Источник

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

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

Допустим, у нас есть строка, содержащая следующее предложение:

The brown-eyed man drives a brown car.

Наша цель — заменить слово «brown» на «blue» :

The blue-eyed man drives a blue car.

В этой статье мы будем использовать функцию replace() , а также функции sub() и subn() с шаблонами для замены всех вхождений подстроки из строки.

replace()

Самый простой способ сделать это — использовать встроенную функцию — replace() :

string.replace(oldStr, newStr, count)

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

string_a = "The brown-eyed man drives a brown car." string_b = string_a.replace("brown", "blue") print(string_a) print(string_b)

Мы выполнили операцию над string_a , упаковали результат в string_b и распечатали их оба.

The brown-eyed man drives a brown car. The blue-eyed man drives a blue car.

Опять же, строка в памяти, на которую указывает string_a , остается неизменной. Строки в Python неизменяемы, что просто означает, что вы не можете изменить строку. Однако вы можете повторно присвоить ссылочной переменной новое значение.

Чтобы, казалось бы, выполнить эту операцию на месте, мы можем просто переназначить string_a после операции:

string_a = string_a.replace("brown", "blue") print(string_a)

Здесь новая строка, созданная методом replace() , присваивается переменной string_a .

Заменить n вхождений подстроки

А что, если мы не хотим изменять все вхождения подстроки? Что, если мы хотим заменить первые n?

Вот тут и появляется третий параметр функции replace() . Он представляет количество подстрок, которые будут заменены. Следующий код заменяет только первое вхождение слова «brown» на «blue» :

string_a = "The brown-eyed man drives a brown car." string_a = string_a.replace("brown", "blue", 1) print(string_a)

The blue-eyed man drives a brown car.

По умолчанию третий параметр настроен на изменение всех вхождений.

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

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

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

По сути, регулярное выражение определяет шаблон. Например, предположим, что у нас есть текст о людях, владеющих кошками и собаками, и мы хотим заменить оба термина словом «pet» . Во-первых, нам нужно определить шаблон, который соответствует обоим терминам, например — (cat|dog) .

Использование функции sub()

Разобравшись с шаблоном, мы собираемся использовать функцию re.sub() со следующим синтаксисом:

re.sub(pattern, repl, string, count, flags)

Первый аргумент — это шаблон, который мы ищем (строка или объект Pattern ), repl это то, что мы собираемся вставить (может быть строкой или функцией; если это строка, обрабатываются любые escape-символы в ней обратной косой чертой) и string это строка, в которой мы ищем.

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

Если шаблон не соответствует ни одной подстроке, исходная строка будет возвращена без изменений:

import re string_a = re.sub(r'(cat|dog)', 'pet', "Mark owns a dog and Mary owns a cat.") print(string_a)

Mark owns a pet and Mary owns a pet.

Сопоставление с шаблоном без учета регистра

Например, чтобы выполнить сопоставление с шаблоном без учета регистра, мы установим для параметра flag значение re.IGNORECASE :

import re string_a = re.sub(r'(cats|dogs)', "Pets", "DoGs are a man's best friend", flags=re.IGNORECASE) print(string_a)

Теперь любая комбинация регистра «dogs» также будет включена. При сопоставлении шаблона с несколькими строками, чтобы избежать его копирования в нескольких местах, мы можем определить объект Pattern . У них также есть функция sub() с синтаксисом:

Pattern.sub(repl, string, count)

Использование объектов шаблона

Давайте определим Pattern для кошек и собак и проверим пару предложений:

import re pattern = re.compile(r'(Cats|Dogs)') string_a = pattern.sub("Pets", "Dogs are a man's best friend.") string_b = pattern.sub("Animals", "Cats enjoy sleeping.") print(string_a) print(string_b)

Pets are a man's best friend. Animals enjoy sleeping.

Функция subn()

Также есть метод subn() с синтаксисом:

re.subn(pattern, repl, string, count, flags)

Функция subn() возвращает кортеж со строкой и числом совпадений в строке поиска:

import re string_a = re.subn(r'(cats|dogs)', 'Pets', "DoGs are a mans best friend", flags=re.IGNORECASE) print(string_a)

('Pets are a mans best friend', 1)

Объект Pattern содержит аналогичную функцию subn() :

Pattern.subn(repl, string, count)

И он используется очень похожим образом:

import re pattern = re.compile(r'(Cats|Dogs)') string_a = pattern.subn("Pets", "Dogs are a man's best friend.") string_b = pattern.subn("Animals", "Cats enjoy sleeping.") print(string_a) print(string_b)

("Pets are a man's best friend.", 1) ('Animals enjoy sleeping.', 1)

Вывод

Python предлагает простые функции для обработки строк. Самый простой способ заменить все вхождения данной подстроки в строке — использовать функцию replace() .

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

Источник:

Источник