Строковые методы python: Строковые методы в Python

Строковые методы в Python. Узнаём популярные и эксклюзивные… | by Андрей Шагин | NOP::Nuances of Programming

Published in

·

4 min read

·

Sep 3, 2019

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

Встроенные строковые функции в Python

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

Код для этой статьи можно взять из соответствующего репозитория Github Repository.

Метод center() выравнивает строку по центру. Выравнивание выполняется с помощью заданного символа (пробела по умолчанию).

Синтаксис

str. center(length, fillchar), где:

• length — это длина строки [обязательный параметр]
• fillchar—это символ, задающий выравнивание [на выбор]

Пример

Метод count() возвращает счёт или число появлений в строке конкретного значения.

Синтаксис

str.count(value, start, end), где:

• value — это подстрока, которая должна быть найдена в строке [обязательный параметр]
• start — это начальное значение индекса в строке, где начинается поиск заданного значения [на выбор]
• end — это конечное значение индекса в строке, где завершается поиск заданного значения [на выбор]

Пример

Метод find() возвращает наименьшее значение индекса конкретной подстроки в строке. Если подстрока не найдена, возвращается -1.

Синтаксис

str. find(value, start, end), где:

• value или подстрока, которая должна быть найдена в строке [обязательный параметр]
• start — это начальное значение индекса в строке, где начинается поиск заданного значения [на выбор]
• end — это конечное значение индекса в строке, где завершается поиск заданного значения [на выбор]

Типы

rfind(): метод rfind() такой же, как find(), за исключением того, что он возвращает наибольшее значение индекса подстроки.

Пример

Метод swapcase() возвращает копию строки, преобразуя все заглавные буквы в строчные, и наоборот.

Синтаксис

string.swapcase()

Пример

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

С другой стороны, функция endswith() возвращает True, если строка заканчивается заданным значением. В противном случае возвращает False.

Синтаксис

string.startswith(value, start, end)

string.endsswith(value, start, end)

• value — это искомая строка в строке [обязательный параметр]
• start — это начальное значение индекса в строке, где начинается поиск заданного значения [на выбор]
• end — это конечное значение индекса в строке, где завершается поиск заданного значения [на выбор]

Пример

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

Синтаксис

string.split(sep, maxsplit)

• sep: разделитель, используемый для разделения строки. Если не указано иное, разделителем по умолчанию является пробел [на выбор]
• maxsplit: обозначает количество разделений. Значение по умолчанию -1, что значит «все случаи» [на выбор]

Вариант

• rsplit(): разделяет строку справа.

Пример

1. capitalize( )

Метод capitalize() меняет на заглавную букву только первый символ строки.

Синтаксис

string.capitalize()

2. upper( )

Метод upper() делает заглавными все буквы в строке.

Синтаксис

string.upper()

3. string.title( )

Метод title() делает заглавными все первые буквы выбранной строки.

Синтаксис

string.title()

Пример

С помощью заданного символа (по умолчанию пробел) метод ljust() возвращает вариант выбранной строки с левым выравниванием. Метод rjust() выравнивает строку вправо.

Синтаксис

string.rjust/ljust(length, character)

• length: длина строки, которая должна быть возвращена [обязательный параметр]
• character: символ для заполнения незанятого пространства, по умолчанию являющийся пробелом [на выбор]

Пример

Метод strip() возвращает копию строки без первых и последних символов. Эти отсутствующие символы — по умолчанию пробелы.

Синтаксис

string.strip(character)

character: набор символов для удаления [на выбор]

Варианты

• rstrip(): удаляет символы с начала строки.
• lstrip(): удаляет символы с конца строки.

Метод zfill() добавляет нули в начале строки. Длина возвращаемой строки зависит от заданной ширины.

Синтаксис

string.zfill(width)

• width: указывает длину возвращаемой строки. Нули не добавляются, если параметр ширины меньше длины первоначальной строки.

Пример

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

Перевод статьи Parul Pandey: Useful String Methods in Python

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

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

Встроенные строковые функции в Python

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

Код для этой статьи можно взять из соответствующего репозитория Github Repository.

1. center( )

Метод center() выравнивает строку по центру. Выравнивание выполняется с помощью заданного символа (пробела по умолчанию).

Синтаксис

str.center(length, fillchar), где:

• length — это длина строки [обязательный параметр]
• fillchar—это символ, задающий выравнивание [на выбор]

Пример

2.

count( )

Метод count() возвращает счёт или число появлений в строке конкретного значения.

Синтаксис

str.count(value, start, end), где:

• value — это подстрока, которая должна быть найдена в строке [обязательный параметр]
• start — это начальное значение индекса в строке, где начинается поиск заданного значения [на выбор]
• end — это конечное значение индекса в строке, где завершается поиск заданного значения [на выбор]

Пример

3. find( )

Метод find() возвращает наименьшее значение индекса конкретной подстроки в строке. Если подстрока не найдена, возвращается -1.

Синтаксис

str.find(value, start, end), где:

• value или подстрока, которая должна быть найдена в строке [обязательный параметр]
• start — это начальное значение индекса в строке, где начинается поиск заданного значения [на выбор]
• end — это конечное значение индекса в строке, где завершается поиск заданного значения [на выбор]

Типы

rfind(): метод rfind() такой же, как find(), за исключением того, что он возвращает наибольшее значение индекса подстроки.

Пример

4. swapcase( )

Метод swapcase() возвращает копию строки, преобразуя все заглавные буквы в строчные, и наоборот. 

Синтаксис

string.swapcase()

Пример

5. startswith( ) and endswith( )

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

С другой стороны, функция endswith() возвращает True, если строка заканчивается заданным значением. В противном случае возвращает False.

Синтаксис

string.startswith(value, start, end)

string.endsswith(value, start, end)

• value — это искомая строка в строке [обязательный параметр]
• start — это начальное значение индекса в строке, где начинается поиск заданного значения [на выбор]
• end — это конечное значение индекса в строке, где завершается поиск заданного значения [на выбор]

Пример

6.

split( )

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

Синтаксис

string.split(sep, maxsplit)

• sep: разделитель, используемый для разделения строки. Если не указано иное, разделителем по умолчанию является пробел [на выбор]
• maxsplit: обозначает количество разделений. Значение по умолчанию -1, что значит «все случаи» [на выбор]

Вариант

• rsplit(): разделяет строку справа.

Пример

7. Строка заглавными буквами

1. capitalize( )

Метод capitalize() меняет на заглавную букву только первый символ строки.

Синтаксис

string.capitalize()

2. upper( )

Метод upper() делает заглавными все буквы в строке.

Синтаксис

string.upper()

3. string.title( )

Метод title() делает заглавными все первые буквы выбранной строки.

Синтаксис

string.title()

Пример

8. ljust( ) и rjust( )

С помощью заданного символа (по умолчанию пробел) метод ljust() возвращает вариант выбранной строки с левым выравниванием. Метод rjust() выравнивает строку вправо.

Синтаксис

string.rjust/ljust(length, character)

• length: длина строки, которая должна быть возвращена [обязательный параметр]
• character: символ для заполнения незанятого пространства, по умолчанию являющийся пробелом [на выбор]

Пример

9. strip( )

Метод strip() возвращает копию строки без первых и последних символов. Эти отсутствующие символы — по умолчанию пробелы.

Синтаксис

string.strip(character)

character: набор символов для удаления [на выбор]

Варианты

• rstrip(): удаляет символы с начала строки.
• lstrip(): удаляет символы с конца строки.

10. zfill( )

Метод zfill() добавляет нули в начале строки. Длина возвращаемой строки зависит от заданной ширины.

Синтаксис

string.zfill(width)

• width: указывает длину возвращаемой строки. Нули не добавляются, если параметр ширины меньше длины первоначальной строки.

Пример

Заключение

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

Читайте также:

• PEG парсеры и Python
• Популярные лайфхаки для Python
• Овладей Python, создавая реальные приложения. Часть 1

---

Перевод статьи Parul Pandey: Useful String Method

Читайте также

строковых методов Python, которые нужно знать

Строки Python имеют 47 методов. Это почти столько же строковых методов, сколько встроенных функций в Python! Какие строковые методы следует изучить в первую очередь?

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

Наиболее полезные строковые методы

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

Метод	Родственные методы	Описание
присоединиться		Соединение итерируемых строк с помощью разделителя
сплит	Разделить	Разделить (по умолчанию с пробелами) на список строк
заменить		Заменить все копии одной подстроки на другую
лента	R-полоска и L-полоска	Удалить пробелы в начале и в конце
чехол	нижний и верхний	Возвращает нормализованную по регистру версию строки
начинается с		Проверить, начинается ли строка с одной или нескольких других строк
заканчивается		Проверить, заканчивается ли строка одной или несколькими другими строками
линии разделения		Разделить на список строк
формат		Отформатировать строку (рассмотрите f-строку перед этим)
количество		Подсчитать, сколько раз встречается заданная подстрока
удалить префикс		Удалить данный префикс
удалить суффикс		Удалить указанный суффикс

У вас может возникнуть вопрос: «Подождите, почему моего любимого метода нет в этом списке?» Я кратко объясню остальные методы и мои мысли о них ниже. Но сначала давайте рассмотрим каждый из вышеперечисленных способов.

join

Если вам нужно преобразовать список в строку в Python, вам нужен метод string join .

 >>> colors = ["фиолетовый", "синий", "зеленый", "оранжевый"]
>>>joined_colors = ", ".join(цвета)
>>> объединенные_цвета
'фиолетовый, синий, зеленый, оранжевый'
 

Метод join может объединить список строк в одну строку

, но он также примет любые другие итерируемые строки.

 >>> цифры = диапазон (10)
>>> digit_string = "".join(str(n) для n в цифрах)
>>> цифра_строка
'0123456789'
 

split

Если вам нужно разбить строку на более мелкие строки на основе разделителя, вам нужен метод string split .

 >>> время = "1:19:48"
>>> части = time.split(":")
>>> части
['1', '19', '48']
 

Разделителем может быть любая подстрока. Мы разделили на : выше, но мы также можем разделить на -> :

 >>> graph = "A->B->C->D"
>>> график. split("->")
(«А», «Б», «С», «Г»)
 

Обычно вы не хотите называть split пробелом:

 >>> langston = "Он сохнет\nкак изюм на солнце?\n"
>>> langston.split(" ")
['Это', 'это', 'сухой', 'на\nподобный', 'а', 'изюм', 'в', 'это', 'солнце?\n']
 

Разделение по символу пробела работает, но часто при разделении по пробелам на самом деле полезнее разделить по всем пробелам.

Вызов метода split никакие аргументы не будут разделены на любые последовательные пробельные символы:

 >>> langston = "Сохнет\nкак изюм на солнце?\n"
>>> langston.split()
['Это', 'это', 'сухой', 'вверху', 'как', 'а', 'изюм', 'в', 'то', 'солнце?']
 

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

Есть еще одна особенность split , которую люди иногда упускают из виду: аргумент maxsplit . При вызове split со значением maxsplit Python разделит строку на несколько раз. Это удобно, когда вы заботитесь только о первые одно или два появления разделителя в строке:

 >>> line = "Резиновая уточка|5|10"
>>> item_name, the_rest = line.split("|", maxsplit=1)
>>> имя_элемента
'Резиновая утка'
 

Если вам нужна последняя пара вхождений разделителя, вы можете вместо этого использовать метод string

rsplit :

 >>> the_rest, amount = line.rsplit("|", maxsplit=1)
>>> сумма
«10»
 

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

replace

Нужно заменить одну подстроку (строку в строке) другой? Вот для чего нужен метод замены строки на !

 >>> message = "JavaScript прекрасен"
> >> сообщение. заменить("JavaScript", "Python")
«Питон прекрасен»
 

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

 >>> message = "Python прекрасен!!!!"
>>> сообщение.заменить("!", "")
«Питон прекрасен»
 

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

 >>> message = "Python прекрасен!!!!"
>>> сообщение.заменить("!", "?", 2)
'Питон прекрасен??!!'
 

strip

Метод strip предназначен для удаления пробелов в начале и конце строки:

 >>> text = """
... Привет!
... Это многострочная строка.
... """
>>> текст
'\nЗдравствуйте!\nЭто многострочная строка.\n'
>>> stripped_text = text.strip()
>>> stripped_text
'Здравствуйте!\nЭто многострочная строка.'
 

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

 >>> line = "Строка с отступом и пробелами в конце \n"
>>> строка. rstrip()
'Строка с отступом и пробелами в конце'
 

А если вам нужно удалить пробелы с самого начала, вы можете использовать метод

lstrip :

 >>> line = "Строка с отступом и конечными пробелами \n"
>>> строка.lstrip()
'Строка с отступом и пробелами в конце \n'
 

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

 >>> line = "Line 1\n"
>>> строка
'Строка 1\n'
>>> строка.rstrip("\n")
'Линия 1'
 

Обратите внимание, что strip , lstrip и rstrip также принимают строку из

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

 >>> words = ['Я', 'наслаждаюсь', 'Python!', 'Делаю', 'ты?', 'Я', 'надеюсь', 'так. ']
>>> [w.strip(".!?") для w прописью]
['Я', 'наслаждаюсь', 'Питон', 'Делай', 'ты', 'я', 'надеюсь', 'так']
 

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

Если вам нужно удалить многосимвольную подстроку вместо отдельных символов, см. removesuffix и удалите префикс ниже.

футляр

Нужно перевести строку в верхний регистр? Для этого есть метод upper :

 >>> name = "Trey"
>>> имя.верхнее()
ТРЕЙ
 

Нужно перевести строку в нижний регистр? Для этого есть метод нижнего :

 >>> name = "Trey"
>>> имя.нижнее()
'трей'
 

Что делать, если вы пытаетесь выполнить сравнение строк без учета регистра? Вы можете строчными или прописными буквами все ваши строки для сравнения. Или вы можете использовать строку casefold method:

 >>> name = "Trey"
>>> "т" в имени
ЛОЖЬ
>>> "t" в name. casefold()
Истинный
 

Но подождите, разве чехол не то же самое, что нижний ?

 >>> имя = "Трей"
>>> имя.casefold()
'трей'
 

Почти. Если вы работаете с символами ASCII, метод casefold делает то же самое, что и метод string lower .

Но если у вас есть символы, отличные от ASCII (см. кодировку символов Unicode в Python), есть некоторые символа, которые casefold обрабатывают однозначно.

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

Имейте в виду, что чехол 9Однако 0027 не решает всех проблем с нормализацией текста. В Python можно представлять одни и те же данные несколькими способами, поэтому вам нужно изучить нормализацию данных Unicode и модуль Python unicodedata , если вы думаете, что будете часто сравнивать текст, отличный от ASCII.

начинается с

Строка начинается с . Метод может проверить, является ли одна строка префиксом другой строки :

 >>> property_id = "UA-1234567"
>>> property_id.startswith("UA-")
Истинный
 

Альтернативой , начинающейся с , является нарезка большей строки и проверка на равенство:

 >>> property_id = "UA-1234567"
>>> префикс = "UA-"
>>> property_id[:len(префикс)] == префикс
Истинный
 

Это работает, но неудобно.

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

Здесь мы проверяем, начинается ли каждая строка в списке с гласной, чтобы определить, следует ли использовать артикль «an» или «a»:

 >>> имена = ["Go", "Эликсир", "OCaml", "Rust"]
>>> для имени в именах:
. .. если name.startswith(("A", "E", "I", "O", "U")):
... print(f"Программа {имя}")
...     еще:
... print(f"Программа {имя}")
...
Программа Го
Эликсирная программа
Программа OCaml
Программа на Rust
 

Обратите внимание, что начинается с , возвращает True , если строка начинается с любых заданных подстрок.

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

endwith

Метод endwith может проверить, является ли одна строка суффиксом другой строки .

Метод строки заканчивается работает почти так же, как метод начинается с .

Работает с одной строкой:

 >>> filename = "3c9a9fd05f404aefa92817650be58036.min.js"
>>> имя_файла.заканчивается(".min.js")
Истинный
 

Но он также принимает кортеж строк:

 >>> filename = "3c9a9fd05f404aefa92817650be58036. min.js"
>>> имя_файла.заканчивается((".min.js", ".min.css"))
Истинный
 

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

splitlines

Метод splitlines специально предназначен для разделения строк на строки.

 >>> text = "Я Никто! Кто ты?\nТы тоже Никто?"
>>> text.splitlines()
["Я Никто! Кто ты?", "Ты - Никто - тоже?"]
 

Зачем делать отдельный метод только для разбиения на строки? Не могли бы мы вместо этого использовать метод split с \n ?

 >>> text.split("\n")
["Я Никто! Кто ты?", "Ты - Никто - тоже?"]
 

Хотя в некоторых случаях это работает, иногда символы новой строки обозначаются цифрой 9.0026 \r\n или просто \r вместо \n . Если вы точно не знаете, какие окончания строк используются в вашем тексте, разделенных строк могут быть удобными.

 >>> text = "Может быть, он просто провисает\r\nкак тяжелый груз.\r\nИли он взрывается?"
>>> text.split("\n")
['Может, просто провисает\r', 'как тяжелый груз.\r', 'Или взрывается?']
>>> text.splitlines()
['Может быть, он просто провисает', 'как тяжелый груз.', 'Или он взрывается?']
 

Но есть еще более полезная причина использовать splitlines : текст довольно часто заканчивается завершающим символом новой строки.

 >>> zen = "Плоский лучше, чем вложенный.\nРазреженный лучше, чем плотный.\n"
 

Метод splitlines удалит конечный символ новой строки, если он его найдет, тогда как метод split разделит этот конечный символ новой строки, что даст нам пустую строку в конце (скорее всего, это не то, что мы на самом деле хотим при разделении строк).

 >>> зен.split("\n")
['Плоский лучше, чем вложенный.', 'Разреженный лучше, чем плотный.', '']
>>> zen.splitlines()
['Плоский лучше, чем вложенный.', 'Разреженный лучше, чем плотный. ']
 

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

 >>> zen.splitlines(keepends=True)
['Плоский лучше, чем вложенный.\n', 'Разреженный лучше, чем плотный.\n']
 

При разбиении строк на строки в Python я рекомендую использовать разделенных строк вместо разделенных .

Формат

Формат Python 9Метод 0027 используется для форматирования строк (он же интерполяция строк).

 >>> version_message = "Требуется версия {версия} или выше."
>>> print(version_message.format(version="3.10"))
Требуется версия 3.10 или выше
 

F-строки Python были развитием метода формата .

 >>> имя = "Трей"
>>> print(f"Здравствуйте, {имя}! Добро пожаловать в Python.")
Привет, Трей! Добро пожаловать в Python.
 

Можно подумать, что 9Метод формата 0026 не имеет большого применения сейчас, когда f-строки уже давно являются частью Python. Но метод формата удобен для случаев, когда вы хотите определить строку шаблона в одной части кода, а использовать эту строку шаблона в другой части.

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

 BASE_URL = "https://api.stackexchange.com/2.3/questions/{ids}?site={site}"
# Здесь больше кода
question_ids = ["33809864", "2759323", "9321955"]
url_for_questions = BASE_URL.format(
    сайт = "переполнение стека",
    ids=";".join(question_id),
)
 

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

count

Метод string count принимает подстроку и возвращает количество раз, которое эта подстрока встречается в нашей строке:

 >>> time = "3:32"
>>> время.счет(":")
1
>>> время = "2:17:48"
>>> время.счет(":")
2
 

Вот и все. Метод count довольно прост.

Обратите внимание, что если вам не важно фактическое число, а вместо этого важно, больше ли количество, чем 0 :

 has_underscores = text.count("_") > 0
 

Вам не нужен метод подсчета .

Почему? Потому что оператор Python в — лучший способ проверить, содержит ли строка подстроку:

 has_underscores = "_" в тексте
 

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

removeprefix

Метод removeprefix удалит необязательный префикс из начала строки.

 >>> hex_string = "0xfe34"
>>> hex_string.removeprefix("0x")
'fe34'
>>> шестнадцатеричная_строка = "ac6b"
>>> hex_string.removeprefix("0x")
'ac6b'
 

Метод removeprefix был добавлен в Python 3. 9. До removeprefix было обычным делом проверять, начинается ли строка с префикса , а затем удалять ее с помощью нарезки:

 if hex_string.startswith("0x"):
    шестнадцатеричная_строка = шестнадцатеричная_строка[len("0x"):]
 

Теперь вместо этого можно просто использовать removeprefix :

 hex_string = hex_string.removeprefix("0x")
 

Метод removeprefix немного похож на lstrip за исключением того, что lstrip удаляет одиночные символы из конца строки и удаляет столько символов, сколько находит.

Итак, хотя это удалит все ведущие символы v из начала строки:

 >>> a = "v3.11.0"
>>> a.lstrip("v")
«3.11.0»
>>> б = "3.11.0"
>>> b.lstrip("v")
«3.11.0»
>>> с = "vvv3.11.0"
>>> c.lstrip("v")
«3.11.0»
 

Это удалит не более один v с начала строки:

 >>> a = "v3.11.0"
>>> a.removeprefix("v")
«3.11.0»
>>> б = "3. 11.0"
>>> b.lstrip("v")
«3.11.0»
>>> с = "vvv3.11.0"
>>> c.removeprefix("v")
"вв3.11.0"
 

removesuffix

Метод removesuffix удалит необязательный суффикс с конца строки.

 >>> time_readings = ["0", "5 сек", "7 сек", "1", "8 сек"]
>>> new_readings = [t.removesuffix(" сек") для t в time_readings]
>>> новые_показания
['0', '5', '7', '1', '8']
 

Делает почти то же самое, что и removeprefix , за исключением того, что удаляет с конца, а не с начала.

Изучите эти методы позже

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

Метод	Родственные методы	Описание
кодировать		Кодировать строку до байт объект
найти	найти	Возвращает индекс подстроки или -1 , если не найдено
индекс	индекс	Возвращает индекс подстроки или повышает ValueError
Название	с большой буквы	Заглавная строка
раздел	рраздел	Разделение на 3 части на основе разделителя
просто	справа и по центру	Выравнивание строки по левому/правому/центру
заполнение		Дополнить числовую строку нулями (до ширины)
идентификатор		Проверить, является ли строка допустимым идентификатором Python

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

• кодировать : обычно вы можете избежать ручного кодирования строк, но вы обнаружите этот метод по необходимости, когда вы не можете (см. Преобразование между двоичными данными и строками в Python)
• find и rfind : мы редко заботимся о поиске индексов подстрок: обычно нам нужно включение (например, мы используем 'y' в имени вместо имя.найти('у') != -1 )
• index и rindex : они вызывают исключение, если данный индекс не найден, поэтому эти методы редко используются
• title и использовать заглавные буквы : метод title не всегда работает так, как вы ожидаете (см. Заглавие строки в Python), а использовать заглавные буквы только с заглавной буквы
• раздел и rpartition : это может быть очень удобно при разделении при проверке 9 модификаторы форматирования строки вместо этого (см. строки форматирования)
• zfill : этот метод заполняет строки нулями, чтобы сделать их определенной ширины, и я обычно предпочитаю также использовать форматирование строк для заполнения нулями (см. Заполнение нулями при форматировании строки)
• isidentifier : это ниша, но она полезна для проверки того, что строка является допустимым идентификатором Python, хотя обычно для этого требуется соединение с ключевым словом .iskeyword , чтобы исключить ключевые слова Python
.

Альтернативы регулярным выражениям

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

Метод	Родственные методы	Описание
Десятичный	— цифра и — цифра	Проверить, представляет ли строка число
исасци		Проверить, все ли символы ASCII
для печати		Проверить, все ли символы печатаются
isspace		Проверить, состоит ли строка полностью из пробелов
исальфа	нижний и верхний	Проверить, содержит ли строка только буквы
Изальнум		Проверить, содержит ли строка буквы или цифры
название		Проверить, введена ли строка в заглавном регистре

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

Также имейте в виду, что эти методы не всегда могут работать так, как вы ожидаете. Все isdigit , isdecimal и isnumeric соответствуют более чем просто 0 до 9 , и ни одно из них не соответствует - или . . Метод isdigit соответствует всему, что соответствует isdecimal и больше, а метод isnumeric соответствует всему, чему соответствует isdecimal плюс больше. Таким образом, пока только isnumeric соответствует ⅷ , isdigit и isnumeric соответствует ⓾ , и все они совпадают с ۸ .

Вам, скорее всего, не нужны эти методы

Эти 5 методов встречаются довольно редко:

• expandtabs : конвертировать символы табуляции в пробелы (количество пробелов, необходимое для перехода к следующей 8-символьной позиции табуляции)
• swapcase : преобразование верхнего регистра в нижний и нижнего регистра в верхний
• format_map : вызов my_string. format_map(mapping) аналогичен my_string.format(**отображение)
• maketrans : создать словарь, отображающий кодовые точки символов между ключами и значениями (для передачи на str.translate )
• перевести : сопоставить всю одну кодовую точку с другой в данной строке

Узнайте, что вам нужно

Строки Python содержат тонны методов. На самом деле не стоит запоминать их все: поберегите время для чего-нибудь более полезного.

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

Я рекомендую запомнить наиболее полезные строковые методы Python, примерно в таком порядке:

1. join : Соединить итерацию строк с помощью разделителя
2. split : Разделить (по умолчанию с пробелами) на список строк
3. заменить : заменить все копии одной подстроки на другую
4. полоса : Удалить пробелы в начале и в конце
5. casefold (или ниже , если хотите): возвращает версию строки
, нормализованную по регистру.
6. начинается с и заканчивается с : проверьте, начинается ли строка/заканчивается ли она одной или несколькими другими строками
7. splitlines : Разделить на список строк
8. формат : Отформатируйте строку (рассмотрите f-строку перед этим)
9. количество : Подсчитать, сколько раз встречается данная подстрока
10. removeprefix & removesuffix : удалить указанный префикс/суффикс

Хотите помочь в изучении наиболее полезных строковых методов Python?

Хотите зафиксировать все эти строковые методы в долговременной памяти? Я работаю над системой, которая может помочь вам сделать это за 5 минут в день в течение примерно 10 дней.

Эта система также может помочь вам запомнить многие другие важные концепции Python.

Хотите получить ранний доступ?

Ваш адрес электронной почты

Также присылайте мне еженедельные советы по Python (дополнительная подписка на информационный бюллетень)

Я не буду спамить вас, и вы можете отказаться от подписки в любое время.

31 важный строковый метод в Python, который вы должны знать

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

Патрик Лебер · · · · · 19 декабря 2021 г. · Чтение: 14 мин.

---

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

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

1. Нарезка

С помощью нарезки мы можем получить доступ к подстрокам. Он может получить необязательные начальные и конечные индексы.

 с = 'привет'
s = s[3:8] # без сбоя, если s[3:20]
# 'привет'
 

2. strip()

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

 s = 'привет' .strip()
# 'привет'
 

3./4. lstrip() и rstrip()

lstrip([chars]) : вернуть копию строки с удаленными начальными символами. rtrip([chars]) : вернуть копию строки с удаленными завершающими символами.

 s = 'привет'.lstrip()
# 'привет   '
s = 'привет'.rstrip()
# '   привет'
 

strip() с символом

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

 s = '###привет###'.strip('#')
# 'привет'
 

Осторожно: удаляются только начальные и конечные найденные совпадения:

 s = ' \n \t hello\n'.strip('\n')
# -> не ведущий, поэтому первый \n не удаляется!
# '\n \t привет'
s = '\n\n \t привет\n'.strip('\n')
# '\т привет'
 

strip() с комбинацией символов

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

 s = 'www.example.com'.strip('cmow.')
# 'пример'
 

5./6. removeprefix() и removesuffix()

Как и раньше, функции strip, lstrip и rstrip удаляют все вхождения переданной строки символов. Поэтому, если мы просто хотим удалить данную строку, мы можем использовать префикс удаления и удаление суффикса.

 s = 'Артур: три!'.lstrip('Артур: ')
# 'Э-э!'
s = 'Артур: три!'.removeprefix('Артур: ')
# 'три!'
s = 'HelloPython'.removesuffix('Python')
# 'Привет'
 

7. replace()

Возвращает копию строки, в которой все вхождения старой подстроки заменены новой.

 s = '\n \t привет\n'.replace('\n', '')
# '\т привет'
 

8. re.sub()

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

 импорт повторно
s = "строковые методы в питоне"
s2 = re.sub("\s+", "-", s)
# 'строковые методы в питоне'
 

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

9. split()

Возвращает список слов в строке, используя sep в качестве строки-разделителя. Если указано значение maxsplit, выполняется не более maxsplit.

 s = 'строковые методы в python'.split()
# ['строка', 'методы', 'в', 'питон']
s = 'строковые методы в python'.split(' ', maxsplit=1)
# ['строка', 'методы в питоне']
 

10. rsplit()

Возвращает список слов в строке, используя sep в качестве строки-разделителя. Если задано значение maxsplit, выполняется не более maxsplit, самые правые.

 s = 'строковые методы в python'.rsplit()
# ['строка', 'методы', 'в', 'питон']
s = 'строковые методы в python'.rsplit(' ', maxsplit=1)
# ['строковые методы в', 'python']
 

11. join()

Возвращает строку, которая является конкатенацией строк в итерации.

 list_of_strings = ['строка', 'методы', 'в', 'питон']
s = ' '.join(list_of_strings)
# 'строковые методы в питоне'
 

12./13./14. upper(), lower(), capitalize()

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

 s = 'Питон потрясающий!'.upper()
# 'ПИТОН ПОТРЯСАЮЩИЙ!'
s = 'ПИТОН ПОТРЯСАЮЩИЙ!'.lower()
# 'питон потрясающий!'
s = 'Питон потрясающий!'.capitalize()
# 'Питон потрясающий!'
 

15./16. islower(), isupper()

Проверяет, состоит ли строка только из символов верхнего или нижнего регистра.

 'ПИТОН ПОТРЯСАЮЩИЙ!'.islower() # False
'Питон потрясающий!'.islower() # Верно
'ПИТОН КРУТО!'.isupper() # Верно
'ПИТОН КРУТОЙ!'.isupper() # False
 

17./18./19. isalpha(), isnumeric(), isalnum()

isalpha() : Возвращает True, если все символы в строке являются буквенными и есть хотя бы один символ, False в противном случае. isnumeric() : Возвращает True, если все символы в строке являются числовыми и есть хотя бы один символ, в противном случае возвращает False. isalnum() : Вернуть True, если все символы в строке буквенно-цифровые и есть хотя бы один символ, False в противном случае.

 с = 'питон'
печать (s. isalpha(), s.isnumeric(), s.isalnum())
# Верно Ложно Верно
s = '123'print(s.isalpha(), s.isnumeric(), s.isalnum())
# Ложь Истина Истина
с = 'питон123'
печать (s.isalpha(), s.isnumeric(), s.isalnum())
# Ложь Ложь Истина
с = 'питон-123'
печать (s.isalpha(), s.isnumeric(), s.isalnum())
# Ложь Ложь Ложь
 

20. количество()

Возвращает количество непересекающихся вхождений подстроки sub в диапазоне [начало, конец].

 n = 'привет, мир'.count('o')
№ 2
 

21. find()

Возвращает наименьший индекс в строке, в которой подстрока найдена в срезе s[начало:конец].

 s = «Машинное обучение»
idx = s.find('a')
печать (idx) # 1
print(s[idx:]) # 'машинное обучение'
idx = s.find('a', 2)
печать (idx) # 10
print(s[idx:]) # 'получение'
 

22. rfind()

Возвращает самый высокий индекс в строке, где найдена подстрока, так что подстрока содержится в s[начало:конец].

 s = «Машинное обучение»
idx = s.rfind('a')
печать (idx) # 10
 

23.

/24. startwith() и endwith()

Возвращает True, если строка начинается/заканчивается префиксом/суффиксом, в противном случае возвращает False.

 s = 'Patrick'.startswith('Pat') # с учетом регистра!
# Истинный
s = 'Patrick'.endswith('k') # с учетом регистра!
# Истинный
 

25. partition()

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

 s = 'Python великолепен!'
части = s.partition («есть»)
# ('Python', 'есть', 'круто!')
части = s.partition («было»)
# («Питон — это круто!», '', '')
 

26./27./28 center(), ljust(), rjust()

center() : Возврат по центру строки длины ширины. Заполнение выполняется с использованием указанного fillchar (по умолчанию используется пробел). ljust() : Возвращает строку, выровненную по левому краю, в строке длины ширины. Заполнение выполняется с использованием указанного fillchar (по умолчанию используется пробел). rjust() : Вернуть строку, выровненную по правому краю, в строке длины ширины. Заполнение выполняется с использованием указанного fillchar (по умолчанию используется пробел).

 s = 'Python великолепен!'
s = s.center (30, '-')
# ------ Python великолепен!------
s = 'Python великолепен!'
s = s.ljust(30, '-')
# Python великолепен! -------------
s = 'Python великолепен!'
s = s.rjust(30, '-')
# ------------ Python великолепен!
 

29. f-строки

Начиная с Python 3.6, f-строки можно использовать для форматирования строк. Они более читабельны, лаконичнее, а также быстрее!

 число = 1
язык = 'Питон'
s = f'{language} - это число {num} в программировании!'
# 'Python номер 1 в программировании!'
 

30. swapcase()

Возвращает копию строки с преобразованием символов верхнего регистра в нижний и наоборот.

 с = 'ПРИВЕТ, мир'
s = s.
No related posts.