Основные строковые методы, используемые в Python

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

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

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

Строковые методы Python, заслуживающие того, чтобы их запомнили

Ниже в таблице приведен список из 12-ти наиболее применяющихся разработчиками строковых методов Python, которые не помешает запомнить для дальнейшего применения при любой обработки строк:

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

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

Метод join

Данный метод используется везде, где в Python нужно преобразовать список или иной итерируемый объект в строку:

spisok_colors = ["фиолетовый", "синий", "зеленый", "оранжевый"]
stroka_colors = ", ".join(spisok_colors)
print(stroka_colors)

# фиолетовый, синий, зеленый, оранжевый

posledovatelnost = range(10)
stroka_posledovatelnost = "".join(str(n) for n in posledovatelnost)
print(stroka_posledovatelnost)

# 0123456789

Данный пример генерирует числовую последовательность от 0 до 9, после чего за счет метода join() объединяет все эти десять чисел без какого-либо разделительного знака.

Метод split

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

time = "1:16:43"
chasti = time.split(":")
print(chasti)

# ['1', '16', '43']

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

grafik = "A->B->C->D"
podstroki = grafik.split("->")
print(podstroki)

# ['A', 'B', 'C', 'D']

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

lengston = "Отложенный  сон\nсохнет как\nизюм на солнце\n"
podstroki = lengston.split(" ")
print(podstroki)

# ['Отложенный', '', 'сон\nсохнет', 'как\nизюм', 'на', 'солнце\n']

Как видим, метод split() при указании для него явного пробела буквально выполняет все то, что от него и ожидается. Но, если же мы вообще опустим указание аргументов для данного метода, split() воспримет это более фигурально и разделит нашу строку на соответствующие подстроки исходя из всех, находящихся в ней, невидимых символов, включая разрыв строки \n и много символьные пробелы. Давайте посмотрим, как это работает:

lengston = "Отложенный  сон\nсохнет как\nизюм на солнце\n"
podstroki = lengston.split()
print(podstroki)

# ['Отложенный', 'сон', 'сохнет', 'как', 'изюм', 'на', 'солнце']

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

stroka = "Резиновая утка|5|10"
nazvaniye_predmeta, ostalnoye = stroka.split("|", maxsplit=1)
print(nazvaniye_predmeta)

# Резиновая утка

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

stroka = "Резиновая утка|5|10"
nachalnaya_chast, summa = stroka.rsplit("|", maxsplit=1)
print(summa)

# 10

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

Метод replace

Рассматриваемый в данном подразделе статьи строковый метод replace() применяется везде, где в рамках заданной (большой) строки есть необходимость одну ее подстроку заменить другой:

kompliment = "JavaScript – изначально чудесен во всем"
kompliment_new = kompliment.replace("JavaScript", "Python")
print(kompliment_new)

# Python - изначально чудесен во всем

Метод replace() также весьма удобен и при удалении подстрок путем замены нового их значения пустыми строками:

kompliment = "Python прекрасен!!!!"
kompliment_new = kompliment.replace("!", "")
print(kompliment_new)

# Python прекрасен

При необходимости произвести замену подстрок только лишь для первых N вхождений в методе replace() можно воспользоваться его необязательным аргументом count:

kompliment = "Python прекрасен!!!!"
kompliment_new = kompliment.replace("!", "?", 2)
print(kompliment_new)

# Python прекрасен??!!

Метод strip

Метод strip() предназначен для удаления в начале и конце строки всех невидимых символов, к которым в частности могут относиться символы разрыва строки \n и много символьные пробелы:

text = """
   Приветствуем вас
   от всех собратьев многострочных текстов!
   """
print(text)

'   \nПриветствуем вас\nот всех собратьев многострочных текстов!\n'

obrezannyy_text = text.strip()
print(obrezannyy_text)

# 'Приветствуем вас\nот всех собратьев многострочных текстов!'

При необходимости удаления невидимых символов лишь только с конца строки (но, не с ее начала) можно воспользоваться похожим на strip() методом rstrip():

stroka = "    Строка с пробелами в начале и невидимыми символами в конце  \n"
obrezannaya_stroka = stroka.rstrip()
print(obrezannaya_stroka)

# '    Строка с пробелами в начале и невидимыми символами в конце'

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

stroka = "    Строка с пробелами в начале и невидимыми символами в конце  \n"
obrezannaya_stroka = stroka.lstrip()
print(obrezannaya_stroka)

# 'Строка с пробелами в начале и невидимыми символами в конце  \n'

Под невидимыми символами, удаляемыми по умолчанию методами strip(), lstrip() и rstrip() в данной статье следует понимать, например, такие символы как: табуляция, пробел, разрыв строки, мягкий перенос и т.д. Но, помимо использования всех невидимых символов для вышеперечисленных методов мы можем также указывать вполне конкретные отдельные символы, которые нам требуется удалять с концов строки. Так, например, с помощью кода ниже мы в обрабатываемой строке удаляем все разрывы \n, но оставляем нетронутыми, имеющиеся в ней конечные пробелы:

stroka = "Строка 1 \n"
print(stroka)

# 'Строка 1 \n'

stroka_new = stroka.rstrip("\n")
print(stroka_new)

# 'Строка 1 '

В качестве образца для удаления концов строки, кроме одного символа, методы strip(), lstrip() и rstrip() способны также принимать и последовательности из нескольких символов взятых в кавычки:

slova = ['Я', 'наслаждаюсь', 'Python', 'разработками!', 'А', 'ты?', 'Я',
         'надеюсь', 'также.']
spisok = [sl.strip(".!?") for sl in slova]
print(spisok)

# ['Я', 'наслаждаюсь', 'Python', 'разработками', 'А', 'ты', 'Я', 'надеюсь',
#  'также']

В вышеприведенном коде аргумент метода strip() был задан в виде подстроки в кавычках. Однако, в реальности данная подстрока должна рассматриваться лишь как последовательность, каждый символ которой сравнивается со строкой, подлежащей обрезки по концам. Таким образом, в нашем случае все строки исходного списка, имеющие (.), (!) либо (?) будут очищены от этих символов.

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

Метод casefold

В Python существует два, наверняка уже полюбившихся нам метода для перевода строк в верхний и нижний регистр. Так, для перевода строки в верхний регистр мы всегда пользуемся методом upper():

strana = "Канада"
strana_upper = strana.upper()
print(strana_upper)

# КАНАДА

Если же нам нужно перевести строку в нижний регистр, у нас всегда для этого есть метод lower():

strana = "Канада"
strana_lower = strana.lower()
print(strana_lower)

# канада

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

strana = "Канада"
sravneniye1 = "к" in strana
print(sravneniye1)

# False

sravneniye2 = "к" in strana.casefold()
print(sravneniye2)

# True

Данный код определяет, входит ли буква (к) в строку, которая содержится в переменной strana. Однако, изучая вышеприведенный код, становится также вполне очевидным и то, что метод casefold() по сути ни чем не отличается от метода lower():

strana = "Канада"
strana_casefold = strana.casefold()
print(strana_casefold)

# канада

Вывод о идентичности метода casefold() с методом lower() является действительно абсолютно справедливым, но лишь в том случае, когда мы работаем с символами в ASCII кодировке.

Если же строка у нас будет закодирована, например, в Unicode, то результат метода casefold() и метода lower() по некоторым символам этой строки может существенно отличаться.

Действительно, существует несколько сотен символов, выходящих за рамки ASCII, которые по-разному нормализуются в casefold() и в lower() методах. Поэтому, при обработки текстов сформированных, например, в кириллице, на греческом или же на армянском языках, а также при использовании в текстах международного фонетического алфавита, лучше все же вместо lower() пользоваться методом casefold().

Примечание: На практике, все же следует иметь в виду, что метод casefold() отнюдь не решает всех проблем связанных с нормализацией текстов. Ведь Python позволяет представлять одни и те же данные несколькими способами, которые невозможно учесть при применении вышеназванного метода. Поэтому, если при разработке программ вам потребуется частое сравнение текстов в иной, отличающейся от ASCII, кодировке, то вы должны будете быть готовы к довольно глубокому изучению принципов нормализации Unicode текстов и освоению Python модуля unicodedata.

Метод startswith

Предназначение строкового метода startswith() сводится к проверки начала проверяемой строки на совпадение с той подстрокой, которая задается в качестве аргумента данного метода:

identifikator = "UA-1234567"
proverka = identifikator.startswith("UA-")
print(proverka)

# True

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

identifikator = "UA-1234567"
prefix = "UA-"
proverka = identifikator[:len(prefix)] == prefix
print(proverka)

# True

Это конечно же работает, однако, данный подход гораздо менее компактен и удобочитаем.

Кроме того, благодаря вышеназванному методу мы можем очень быстро и легко проверить, начинается ли одна строка с множества иных подстрок, заданных через аргумент *startswith() в виде кортежа.

В коде ниже мы нормализуем результаты сдачи сессии одним из студентов, проверяя оценки, стоящие перед названием каждого, сдаваемого на сессии предмета. По результатам данного кода, стоящие перед предметом, оценки 5, 4 и 3 нормализуются к отметке Зачет. Более же низкие оценки преобразуются к отметке Незачет:

predmety = ["2 Алгебра", "4 Биология", "3 Информатика", "5 История",
            "2 Химия", "3 Физика"]
for pr in predmety:
    if pr.startswith(("3", "4", "5")):
        print(f"{pr[2:]} - Зачет")
    else:
        print(f"{pr[2:]} - Незачет")

# Алгебра - Незачет
# Биология - Зачет
# Информатика - Зачет
# История - Зачет
# Химия - Незачет
# Физика - Зачет

Из вышеприведенного кода видно, что метод startswith() проверяет здесь сразу же три позитивные оценки 5, 4 и 3, наличие которых в предметах приводит к возврату True с последующей распечаткой этих предметов, как зачтенных.

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

Метод endswith

Аналогично startswith(), метод endswith() проверяет совпадение части строки с подстрокой, задаваемой аргументом этого метода. Но, если startswith() сравнивает подстроку с началом строки, то endswith() осуществляет то же сравнение подстроки, но только с концом (суффиксом) проверяемой строки. Посмотрим, как работает этот метод при условии сравнения суффикса строки лишь с одним значением подстроки:

filename = "3c9a9fd05f404aefa92817650be58036.min.js"
proverka = filename.endswith(".min.js")
print(proverka)

# True

Абсолютно точно также, как раннее рассматриваемый, метод endswith() работает и с множественным сравнением, осуществляемым за счет формирования аргумента данного метода в виде кортежа образцов подстрок, сравниваемых со строкой:

filename = "3c9a9fd05f404aefa92817650be58036.min.js"
proverka = filename.endswith((".min.js", ".min.css"))
print(proverka)

# True

В частности, из приведенного выше примера видно, что методу endswith() был передан кортеж, один из элементов которого совпадает с суффиксом проверяемой строки. Это, в свою очередь, обусловило возврат результата данным методом со значением True.

Метод splitlines

Основной особенностью метода splitlines() является то, что он предназначен сугубо для разбиения строк на подстроки.

text = "Я - Никто!\nКто же ты?\nНаверняка, тоже Никто?"
text_new = text.splitlines()
print(text_new)

# ['Я - Никто!', 'Кто же ты?', 'Наверняка, тоже Никто?']

Но, если предназначение splitlines() сводилось бы только лишь к разбиению строк, то вполне резонно вставал бы вопрос о потребности данного метода вообще. Ведь для решения той же задачи мы просто могли бы использовать метод split() с аргументом \n?

text = "Я - Никто!\nКто же ты?\nНаверняка, тоже Никто?"
text_new = text.split("\n")
print(text_new)

# ['Я - Никто!', 'Кто же ты?', 'Наверняка, тоже Никто?']

Да, действительно, в некоторых случаях это работает. Но, зачастую возникают ситуации, когда символы разрыва строк обозначаются различными вариациями последовательностей типа \r\n или же просто \r вместо \n. Поэтому, если мы точно не знаем, какие же окончания строк используются в нашем тексте, то применение метода splitlines() может оказаться для нас наиболее приемлемым вариантом:

text = "Может он временно виснет и,\r\nэто с годами пройдет.\r\n" \
       "Или же, это уже навсегда?"
text_new1 = text.split("\n")
print(text_new1)

# ['Может он временно виснет и,\r', 'это с годами пройдет.\r',
#  'Или же, это уже навсегда?']

text_new2 = text.splitlines()
print(text_new2)

# ['Может он временно виснет и,', 'это с годами пройдет.',
#  'Или же, это уже навсегда?']

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

zen_python = "Красивое лучше, чем уродливое.\nЯвное лучше, чем неявное.\n"

При возникновении ситуаций с конечным символом \n, подобных вышеприведенной строке, метод splitlines() просто удалит данный символ, в то время, как split() заменит вышеназванный символ новой, скорее всего, абсолютно не нужной нам, пустой строкой в конце текста:

zen_python = "Красивое лучше, чем уродливое.\nЯвное лучше, чем неявное.\n"
text_new1 = zen_python.split("\n")
print(text_new1)

# ['Красивое лучше, чем уродливое.', 'Явное лучше, чем неявное.', ' ']

text_new2 = zen_python.splitlines()
print(text_new2)

# ['Красивое лучше, чем уродливое.', 'Явное лучше, чем неявное.']

В отличии от split(), метод splitlines() благодаря поименованному аргументу keepends, установленному в True также может разделять строку на подстроки, сохраняя в них существующие окончания из невидимых символов:

zen_python = "Красивое лучше, чем уродливое.\nЯвное лучше, чем неявное.\n"
text_new = zen_python.splitlines(keepends=True)
print(text_new)

# ['Красивое лучше, чем уродливое.\n', 'Явное лучше, чем неявное.\n']

Метод splitlines() безусловно имеет очень важные специфические преимущества перед split(). Поэтому, если перед нами встанет задача просто разбить строку на подстроки по невидимым символам, то вместо split() нам однозначно нужно будет выбирать метод splitlines().

Метод format

Строковый метод format() позволяет форматировать (видоизменять) строки посредством вставки в заранее заданные места этих строк соответствующих инициализированных аргументов:

trebovaniya = "При работе с пакетом требуется Python {version} или выше"
print(trebovaniya.format(version="3.10"))

# При работе с пакетом требуется Python 3.10 или выше

Рассматриваемый метод абсолютно схож с так называемыми F-строками Python, являющимися его развитием.

name = "Магдалина"
print(f"Бонжур {name}! Добро пожаловать на курсы Python.")

# Бонжур Магдалина! Добро пожаловать на курсы Python.

В связи с этим может возникнуть вполне логичный вопрос – зачем же тогда использовать метод format(), если более продвинутые f-строки, по сути, уже давно стали частью Python. Объяснение этого парадокса состоит в том, что в отличии от f-строк метод format() является весьма удобным способом для определения и использования, применяющихся им шаблонных строк в абсолютно разных частях нашего кода.

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

BASE_URL = "https://api.stackexchange.com/2.3/questions/{ids}?site={site}"

# Основной код модуля

id_voprosov = ["33809864", "2759323", "9321955"]
url_zaprosa = BASE_URL.format(
    site="stackoverflow",
    ids=";".join(id_voprosov),
)
print(url_zaprosa)

# https://api.stackexchange.com/2.3/questions/33809864;2759323;9321955?site=stackoverflow

В коде выше мы предварительно определили нашу строку шаблона BASE_URL, а затем использовали ее для создания действительного URL-адреса с помощью метода format().

Метод count

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

time = "3:32"
print(time.count(":"))

# 1

time = "2:17:48"
print(time.count(":"))

# 2

Это, пожалуй, и все, на что способен этот довольно простой метод.

Очень часто бывает, когда нам просто нужно узнать, содержится ли интересующая нас подстрока в том или ином тексте (строке). Для этого нам всего лишь достаточно сверить результирующее значение count() с нулем:

proviant = ["просроченная говяжья тушенка", "свежие свиные ребра"]
for product in proviant:
    godnost = product.count("просроч") > 0
    if godnost:
        print(f"{product} - Негодно")
    else:
        print(f"{product} - Годно")

# просроченная говяжья тушенка - Негодно
# свежие свиные ребра - Годно

В таких ситуациях, как вышеописанная, метод count(), в принципе, нам не так уж нужен. Это объясняется тем, что в Python данному методу противопоставляется гораздо более удобная альтернатива в виде оператора in, заточенного как раз под то, чтобы эффективно осуществлять вышеназванную проверку наличия подстроки в строке:

proviant = ["просроченная говяжья тушенка", "свежие свиные ребра"]
for product in proviant:
    if "просроч" in product:
        print(f"{product} - Негодно")
    else:
        print(f"{product} - Годно")

# просроченная говяжья тушенка - Негодно
# свежие свиные ребра - Годно

Метод removeprefix

Строковый метод removeprefix() используется в Python для удаления заданной подстроки (префикса) в начале проверяемой строки и, лишь в том случае, если данный префикс был в этой строке найден:

hex_stroka = "0xfe34"
stroka = hex_stroka.removeprefix("0x")
print(stroka)

# 'fe34'

hex_stroka = "ac6b"
stroka = hex_stroka.removeprefix("0x")
print(stroka)

# 'ac6b'

Рассматриваемый метод появился лишь в версии Python 3.9. Раннее же вместо removeprefix() было принято сначала методом *startswith() проверять наличие в строке нужного префикса, а затем уже, в случае его выявления, удалять данный префикс с помощью так называемой нарезки:

if hex_stroka.startswith("0x"):
    stroka = hex_stroka[len("0x"):]

С появлением же метода removeprefix() процесс удаления заданного префикса в строке значительно упростился:

stroka = hex_stroka.removeprefix("0x")

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

a = "v3.11.0"
print(a.lstrip("v"))

# '3.11.0'

b = "3.11.0"
print(b.lstrip("v"))

# '3.11.0'

c = "vvv3.11.0"
print(c.lstrip("v"))

# '3.11.0'

В отличии же от lstrip(), метод removeprefix() в контексте ожидаемых от него действий будет работать более корректно:

a = "v3.11.0"
print(a.removeprefix("v"))

# '3.11.0'

b = "3.11.0"
print(b.removeprefix("v"))

# '3.11.0'

c = "vvv3.11.0"
print(c.removeprefix("v"))

# 'vv3.11.0'

Метод removesuffix

Метод removesuffix(), по сути, выполняет те же действия по удалению подстрок в строке, что и removeprefix(). Но, в отличии от раннее рассмотренного метода, removesuffix() удаляет в строке ту ее подстроку, которая совпадает не с префиксом, а с суффиксом (концом) этой строки:

pokazaniya_vremeni = ["0", "5 секунд", "7 секунд", "1", "8 секунд"]
novyye_pokazaniya = [vr.removesuffix(" секунд") for vr in pokazaniya_vremeni]
print(novyye_pokazaniya)

# ['0', '5', '7', '1', '8']

В этом примере во всех значениях времени, содержащих слово “секунд”, это слово удаляется благодаря методу removesuffix().

Методы строк, зачастую могущие оказаться достаточно полезными

В Python существует также ряд иных строковых методов, которые применяются далеко не так часто, как те, что мы уже рассмотрели, однако в определенных ситуациях являющихся, по сути, единственным оптимальным способом решения стоящих перед нами задач. Основные из этих методов приведены в таблице ниже:

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

• encode: Выполняемое данным методом кодирование текста в байты необходимо лишь при работе с локальными сетями или с Internet на основе соответствующих сетевых протоколов. Подобные задачи, как правило, являются достаточно редкими. В тоже время, эффективно справится с ними может только лишь вышеназванный строковый метод.
• find и rfind: Этими методами, обычно, мы также довольно редко пользуемся, поскольку их надобность в основном сводится к поиску подстроки в строке, что намного проще реализуется с использованием оператора in. Например, если нам нужно узнать, есть ли (y) в имени, занесенном в переменную name, то всегда лучше воспользоваться выражением 'y' in name нежели выражением name.find('y') != -1).
• index и rindex: Данные методы аналогичны раннее упомянутым, но дополнительно, в случае неудачи при поиске подстроки, обладают фичей выдачи исключения ValueError, которое также мало где применяется в программировании.
• title и capitalize: Эти методы переводят каждую первую букву каждого слова (с случае с title) или же каждую первую букву строки (в случае с capitalize) в верхней регистр и, действительно для решения специфических задач форматирования текстов являются достаточно полезным инструментариями. Но, частота фактического применения этих методов отнюдь не способствует тому, чтобы они реально сколь-нибудь нуждались бы в запоминании.
• partition и rpartition: Данные методы являются лишь частными вариантами таких более функционально продвинутых методов, как split и rsplit, которыми безусловно все пользуются гораздо чаще.
• ljust, rjust, и center: Эти методы аналогично, рассмотренным выше, являются лишь частными вариантами так называемых f-строк. Вместе с тем, данные методы являются достаточно удобными в применении, поскольку заточены сугубо на выравнивании текста по левому (правому) краю или по центру.
• zfill: Также, как и предшествующие методы, это метод представляет собой лишь частный вариант f-строк, которые аналогично zfill могут дополнять строку нулями до заданной длины за счет спецификатора 0Nd.
• isidentifier: Более продвинутым аналогом данному строковому методу выступает соответствующий метод из модуля keyword - keyword.iskeyword(), который точно также, как и isidentifier позволяет проверять пригодность строк для использования в качестве идентификаторов Python.

Строковые методы, заменяющие регулярные выражения

Описываемые в этом разделе статьи строковые методы направлены сугубо на проверку наличия тех или иных свойств (характеристик) у наших строк. При этом, большинство из приведенных здесь методов (за исключением istitle) производя проверку строки на наличие у нее соответствующих свойств, осуществляют посимвольный анализ данной строки.

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

Вместе с тем, не следует ожидать, что приведенные выше методы стопроцентно смогут удовлетворит наши ожидания. Так, например, все такие методы, как isdigit(), isdecimal() и isnumeric() призваны проверять строку на наличие в ней сугубо только чисел от 0 до 9. Но, при этом, все эти три методы существенно отличаются друг от друга. К примеру метод isdigit() в отличии от метода isdecimal() расширяет диапазон допустимых значений при проверки, добавляя к десятичным цифрам еще и такие символы, как верхние и нижние числовые индексы. Метод же isnumeric() расширяет диапазон проверки, присущий уже методу isdigit() такими символами, как ⓾, ۸, / и т.д.

Методы, в полезности которых можно усомниться

Ниже приведены 5-ть строковых методов, необходимость в использовании которых возникает в чрезвычайно редких случаях. Именно поэтому, их стоит просто окинуть взором, так чтобы только лишь иметь представление об их существовании:

• expandtabs: Метод разбивает строку по символам табуляции \t на столбцы указанной ширины. Сами символы табуляции при этом преобразовываются в пробелы, количество которых по умолчанию равно 8-ми.
• swapcase: С помощью данного метода все буквы верхнего регистра в обрабатываемой строке преобразовываются в нижний регистр, а все буквы нижнего регистра – в верхней регистр.
• format_map: Этот метод форматирует строку, используя данные из указанного шаблона (отображения). Вызов данного метода аналогичен вызову str.format(**mapping), только отображение здесь не копируется, а используется напрямую.
• maketrans: Данный метод создает (возвращает) таблицу пакетной замены символов, которая впоследствии используется строковым методом translate().
• translate: Метод осуществляет пакетную замену символов обрабатываемой строки, используя таблицу замены, созданную с помощью метода maketrans().

Рекомендации по приоритетности запоминания строковых методов Python

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

Конечно же, отбирать строковые методы для запоминания можно и, даже нужно, базируясь в основном на своей личной практике их применения. Однако, в качестве образца (остова) для определения приоритетности тех методов, которые нам следует запомнить, рекомендуется все же использовать соответствующий их список, сформированный исходя из группового опыта применяемости вышеназванных методов множеством Python разработчиков. В соответствии с данным списком советуем вам запомнить около десятка наиболее полезных строковых методов в следующем порядке:

1. join: С помощью данного метода производится объединение (конкатенация) строки из элементов итерируемого объекта с учетом разделителя между этими элементами.
2. split: Данный метод выполняет разбиение исходной строки на подстроки по заданному символу, являющемуся по умолчанию пробелом, и возвращает эти подстроки в виде списка.
3. replace: Метод заменяет копии одной подстроки на копии другой подстроки с учетом указываемого количества тех замен, которые следует провести с данными подстроками.
4. strip: С помощью данного метода производится удаление начальных и конечных символов строки в соответствии с заданным шаблонам. Если же данный шаблон не указан, то по умолчанию с начала и с конца строки удаляются пробелы.
5. casefold или lower - как менее продвинутый вариант: Данные методы нормализуют составляющие строку символы, приводя их к нижнему регистру.
6. startswith и endswith: Эти методы сравнивают задаваемые в их аргументах подстроки либо с началом обрабатываемой строки (для startswith), либо с ее концом (для endswith) и возвращают True в том случае если данные подстроки совпадают с соответствующими частями вышеназванной строки.
7. splitlines: С помощью данного метода строка разбивается на подстроки исходя из фиксированного набора разделителей (невидимых символов). Возвращаемые при этом подстроки представляются в виде списка.
8. format: Данный метод форматирует строку на основе вставки в указанные места этой строки соответствующих аргументов, которые могут еще к тому же предварительно обрабатываться (форматироваться).
9. count: Метод подсчитывает, сколько раз встречается заданная в его аргументе подстрока в обрабатываемой им строке.
10. removeprefix и removesuffix: С помощью этих методов удаляется заданная последовательность символов в начале (removeprefix) или в конце (removesuffix) строки.