Методы строк python: Методы строк Python

Методы строк — Python documentation

Методы строк — Python documentation

О методах

До сих пор мы использовали функции, которые были «сами по себе»: input, print. В языке Python существуют специальные функции, привязанные к объектам. Они называются методы. Сравните вызов обычной свободной функции len() и вызов метода строки upper():

>>> s = "hello"
>>> len(s)
5
>>> s.upper()
'HELLO'

Здесь функция len в качестве своего единственного аргумента принимает строку s и возвращает количество символов в ней. Метод upper() связан с типом str и вызывается у объекта s с помощью точки.

Аналогично методы можно вызывать и у литералов:

>>> 'world'.upper()
'WORLD'

s.lower()

s.upper()

s.title()

Методы приводят строку к нижнему, верхнему и title регистру соответственно:

>>> 'world'. upper()
'WORLD'
>>> 'HELLO'.lower()
'hello'
>>> 'hello'.upper()
'HELLO'
>>> 'hello'.title()
'Hello'

s.count(sub)

Возвращает количество вхождений подстроки sub в строку s.

s.find(sub)

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

>>> 'otto'.find('t')
1

s.rfind(sub)

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

>>> 'otto'.rfind('t')
2

ljust(width)

Возвращает строку, выровненную по левой границе поля ширины

width. Строка дополняется пробелами справа:

>>> 'hello'.ljust(10)
'hello     '

rjust(width)

Возвращает строку, выровненную по правой границе поля ширины width. Строка дополняется пробелами слева:

>>> 'hello'.rjust(10)
'     hello'

replace(old, new)

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

Задачи

1. Пользователь вводит фамилию, имя и отчество. Приложение должно вывести фамилию и инициалы. Пример:

   Фамилия: Ершов
   Имя: Андрей
   Отчество: Петрович
   Ершов А. П.
   

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

   Фамилия: ерШоВ
   Имя: андрей
   Отчество: петрович
   Ершов А. П.
   

3. Пользователь вводит слово. Подсчитать количество символов ‘a’ в нем. Пример:

   word: abracadabra
   5
   

4. Пользователь вводит строку. Нужно удалить из нее первое слово. Разделителем слов считать пробел. Пример:

   > Hello, World!
   World
   

5. Пользователь вводит строку. Нужно удалить из нее последнее слово.

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

   Harry Potter
   Potter Harry
   

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

   > To be or not to be.
   Find: be
   Replace: eat
   To eat or not to eat.
   

8. Приложение принимает на вход строку и заменяет все вхождения буквы «ё» на букву «е».

9. Написать приложение, выполняющее транслитерацию введенного слова. Пример:

   > Иван
   Ivan
   

10. Пользователь вводит адрес электронной почты, нужно вывести отдельными строками почтовый логин и домен:

    > [email protected]
    Login: vasya
    Domain: mail.ru
    

Read the Docs v: latest

Versions

latest

Downloads

html

On Read the Docs

Project Home

Builds

---

Free document hosting provided by Read the Docs.

Строки, кортежи, списки — Основы Python

В первой главе мы познакомились с таким типом данных, как строка (

str). Мы умеем складывать строки, умножать их на число и даже сравнивать между собой.

Если рассмотреть строку детальнее, то она состоит из символов, каждый из которых стоит на своём месте. Другими словами, строка — упорядоченная последовательность (коллекция) символов.

Слово «коллекция» в Python применяется не только к строкам. Коллекциями в Python также называют типы данных, в которых можно хранить сразу несколько значений.

В упорядоченных коллекциях, к которым относится строка, каждое значение автоматически имеет свой номер — индекс. Индексация в коллекциях Python начинается со значения 0. При этом пробел, запятая, управляющие символы \n, \t и прочие тоже получают свой индекс в строке. Для доступа к определённому символу строки по индексу нужно указать его в квадратных скобках сразу после имени переменной.

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

text = input()
print(text[0])

Если пользователь введёт пустую строку, то наша программа выдаст ошибку:

IndexError: string index out of range

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

text = input("Введите строку: ")
i = int(input("Введите индекс символа: "))
if i < len(text):
    print(text[i])
else:
    print("Индекс выходит за пределы строки")

Давайте подумаем, как можно взять последний символ строки? Для этого нам потребуется воспользоваться функцией len:

text = input()
print(text[len(text) - 1])

Однако в Python можно упростить эту запись, убрав из неё функцию len. И тогда в качестве индекса просто будет использоваться отрицательное число:

text = input()
print(text[-1])

Таким образом, последний символ имеет индекс -1, предпоследний -2 и т. д.

Так как строка — упорядоченная коллекция, то можно пройти по этой коллекции в цикле, указав в качестве индекса итерируемую переменную цикла. Например, вывести на строке каждый символ введённой пользователем строки:

text = input()
for i in range(len(text)):
    print(text[i])

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

text = input()
for letter in text:
    print(letter)

При такой записи цикла программа проходит не по индексам строки, а непосредственно по её символам. Так, переменная

letter на каждой итерации цикла принимает значение очередного символа строки text.

Если требуется совместить проход непосредственно по символам строки с определением индекса итерации, то можно воспользоваться функцией enumerate. Она возвращает пары значений — номер элемента коллекции и сам этот элемент. Эта функция удобна, когда нужно пройти именно по элементам коллекции, но при этом ещё и знать индекс каждого элемента.

text = input()
for i, letter in enumerate(text):
    print(f"{i}. {letter}")

Для строк в Python существует ещё одна полезная операция — срез (slice).

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

range.

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

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

text = "Привет, мир!"
print(text[8:11])
print(text[:6])
print(text[8:])
print(text[:])
print(text[::2])

Обратите внимание: строка является неизменяемой коллекцией. Это означает, что изменить отдельный символ строки нельзя.

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

word = "мир"
word[0] = "п"

Программа выдаст ошибку:

TypeError: 'str' object does not support item assignment

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

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

Например, у строк есть метод islower(), который проверяет, что в строке не встречаются большие буквы, и возвращает в таком случае значение True, иначе — False:

print("а".islower())
print("A". islower())

True
False

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

str.capitalize()

Метод	str.capitalize()
Описание	Возвращает копию строки, у которой первая буква заглавная, а остальные приведены к строчным
Пример	s = «hello, World!» s.capitalize()
Результат	Hello, world!

str.count(sub)

Метод	str.count(sub)
Описание	Возвращает количество неперекрывающихся вхождений подстроки sub. К примеру, если искать в строке «ААААА» неперекрывающиеся значения «АА», то первое вхождение будет «AAAAA». Второе — «AAAAA». Больше неперекрывающихся вхождений нет. Так, поиск последующих вхождений подстроки происходит с индекса, который следует за последним найденным вхождением
Пример	s = «Hello, world!» s. count(«l»)
Результат	3

str.endswith(suffix)

Метод	str.endswith(suffix)
Описание	Возвращает True, если строка оканчивается на подстроку suffix. Иначе возвращает False. suffix может быть кортежем проверяемых окончаний строки
Пример	s = «Hello, world!» s.endswith(«world!»)
Результат	True

str.find(sub)

Метод	str.find(sub)
Описание	Возвращает индекс первого вхождения подстроки sub. Если подстрока не найдена, то возвращает -1
Пример	s = «Hello, world!» s.find(«o»)
Результат	4

str.index(sub)

Метод	str.index(sub)
Описание	Возвращает индекс первого вхождения подстроки sub. Вызывает исключение ValueError, если подстрока не найдена. Тема ошибок (исключений) будет разбираться на одной из следующих глав
Пример	s = «Hello, world!» s.index(«o»)
Результат	4

str.isalnum()

Метод	str.isalnum()
Описание	Возвращает True, если все символы строки являются буквами и цифрами и в строке есть хотя бы один символ. Иначе возвращает False
Пример	s = «abc123» s.isalnum()
Результат	True

str.isalpha()

Метод	str.isalpha()
Описание	Возвращает True, если все символы строки являются буквами и в строке есть хотя бы один символ. Иначе возвращает False
Пример	s = «Letters» s.isalpha()
Результат	True

str.isdigit()

Метод	str. isdigit()
Описание	Возвращает True, если все символы строки являются цифрами и в строке есть хотя бы один символ. Иначе возвращает False
Пример	s = «123» s.isdigit()
Результат	True

str.islower()

Метод	str.islower()
Описание	Возвращает True, если все буквы в строке маленькие и в строке есть хотя бы одна буква. Иначе возвращает False
Пример	s = «word123» s.islower()
Результат	True

str.isupper()

Метод	str.isupper()
Описание	Возвращает True, если все буквы в строке большие и в строке есть хотя бы одна буква. Иначе возвращает False
Пример	s = «WORD123» s.isupper()
Результат	True

str.join(str_col)

Метод	str. join(str_col)
Описание	Возвращает строку, полученную конкатенацией (сложением) строк — элементов коллекции str_col (обозначение коллекции с элементами типа данных «строка»). Разделителем является строка, для которой вызван метод
Пример	a = [«1», «2», «3»] «; «.join(a)
Результат	«1; 2; 3»

str.ljust(width, fillchar)

Метод	str.ljust(width, fillchar)
Описание	Возвращает строку длиной width с выравниванием по левому краю. Строка дополняется справа символами fillchar до требуемой длины. По умолчанию значение fillchar — пробел
Пример	s = «text» s.ljust(10, «=»)
Результат	«text======»

str.rstrip(chars)

Метод	str.rstrip(chars)
Описание	Возвращает строку, у которой в конце удалены символы, встречающиеся в строке chars. Если значение chars не задано, то пробельные символы удаляются
Пример	s = «stringBCCA» s.rstrip(«ABC»)
Результат	«string»

str.split(sep)

Метод	str.split(sep)
Описание	Возвращает список строк по разделителю sep. По умолчанию sep — любое количество пробельных символов
Пример	s = «one, two, three» s.split(«, «)
Результат	[«one», «two», «three»]

str.startswith(prefix)

Метод	str.startswith(prefix)
Описание	Возвращает True, если строка начинается на подстроку prefix, иначе возвращает False. prefix может быть кортежем проверяемых префиксов строки. Под кортежами подразумевается неизменяемая последовательность элементов
Пример	s = «Hello, world!» s. startswith(«Hello»)
Результат	True

str.strip(chars)

Метод	str.strip(chars)
Описание	Возвращает строку, у которой в начале и в конце удалены символы, встречающиеся в строке chars. Если значение chars не задано, то пробельные символы удаляются
Пример	s = «abc Hello, world! cba» s.strip(» abc»)
Результат	«Hello, world!»

str.title()

Метод	str.title()
Описание	Возвращает строку, в которой каждое отдельное слово начинается с буквы в верхнем регистре, а остальные буквы идут в нижнем
Пример	s = «hello, world!» s.title()
Результат	«Hello, World!»

str.upper()

Метод	str.upper()
Описание	Возвращает копию строки, у которой все буквы приведены к верхнему регистру
Пример	s = «Hello, world!» s. upper()
Результат	«HELLO, WORLD!»

str.zfill(width)

Метод	str.zfill(width)
Описание	Возвращает строку, дополненную слева символами «0» до длины width
Пример	s = «123» s.zfill(5)
Результат	«00123»

Рассмотрим ещё одну коллекцию в Python — список (list). Этот тип данных является упорядоченной коллекцией, которая может в качестве элементов иметь значения любого типа данных.

Один из способов создания списков — перечислить его элементы в квадратных скобках и присвоить это значение переменной, которая и станет в итоге списком в программе:

numbers = [10, 20, 30]

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

mixed_list = [10, 20.55, "text"]

Индексация в списках работает так же, как и в строках, — начальный индекс 0. Можно использовать отрицательные индексы, а также доступны срезы:

numbers = [10, 20, 30, 40, 50]
print(numbers[0])
print(numbers[-1])
print(numbers[1:3])
print(numbers[::-1])

Результат работы программы:

10
50
[20, 30]
[50, 40, 30, 20, 10]

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

numbers = [10, 20, 50]
numbers[2] = 30
print(numbers)

Вывод программы:

[10, 20, 30]

Если требуется добавить элемент в конец списка, то можно использовать метод append().

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

numbers = []
for i in range(10):
    numbers.append(int(input()))
print(numbers)

Вывод программы:

[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

Для удаления элемента из списка применяется операция del. Нужно указать индекс элемента, который требуется удалить:

numbers = [10, 20, 50]
del numbers[-1]
print(numbers)

Вывод программы:

[10, 20]

С помощью del можно удалить несколько элементов списка. Для этого вместо одного элемента указываем срез:

numbers = [1, 2, 3, 4, 5]
del numbers[::2]
print(numbers)

Вывод программы:

[2, 4]

Полезные методы и функции списков и примеры их работы приведены в следующей таблице.

Операция	Описание	Пример	Результат
x in s	Возвращает True, если в списке s есть элемент x. Иначе False	1 in [1, 2, 3]	True
x not in s	Возвращает False, если в списке s есть элемент x. Иначе True	4 not in [1, 2, 3]	True
s + t	Возвращает список, полученный конкатенацией списков s и t	[1, 2] + [3, 4, 5]	[1, 2, 3, 4, 5]
s * n (n * s)	Возвращает список, полученный дублированием n раз списка s	[1, 2, 3] * 3	[1, 2, 3, 1, 2, 3, 1, 2, 3]
len(s)	Возвращает длину списка s	len([1, 2, 3])	3
min(s)	Возвращает минимальный элемент списка	min([1, 2, 3])	1
max(s)	Возвращает максимальный элемент списка	max([1, 2, 3])	3
s. index(x)	Возвращает индекс первого найденного элемента x. Вызывается исключение ValueError, если элемент не найден	[1, 2, 3, 2, 1].index(2)	1
s.count(x)	Возвращает количество элементов x	[1, 1, 1, 2, 3, 1].count(1)	4
s.append(x)	Добавляет элемент x в конец списка	s = [1, 2] s.append(3) print(s)	[1, 2, 3]
s.clear()	Удаляет все элементы списка	s = [1, 2, 3] s.clear() print(s)	[]
s.copy()	Возвращает копию списка	[1, 2, 3].copy()	[1, 2, 3]
s.extend(t) или s += t	Расширяет список s элементами списка t	s = [1, 2, 3] s.extend([4, 5]) print(s)	[1, 2, 3, 4, 5]
s.insert(i, x)	Вставляет элемент x в список по индексу i	s = [1, 3, 4] s.insert(1, 2) print(s)	[1, 2, 3, 4]
s.pop(i)	Возвращает и удаляет элемент с индексом i. Если i не указан, то возвращается и удаляется последний элемент	s = [1, 2, 3] x = s.pop() print(x) print(s)	3 [1, 2]
s.remove(x)	Удаляет первый элемент со значением x	s = [1, 2, 3, 2, 1] s.remove(2) print(s)	[1, 3, 2, 1]
s.reverse()	Меняет порядок элементов списка на противоположный (переворачивает список)	s = [1, 2, 3] s.reverse() print(s)	[3, 2, 1]
s.sort()	Сортирует список по возрастанию, меняя исходный список. Для сортировки по убыванию используется дополнительный аргумент reverse=True	s = [2, 3, 1] s.sort() print(s)	[1, 2, 3]
sorted(s)	Возвращает отсортированный по возрастанию список, не меняя исходный. Для сортировки по убыванию используется дополнительный аргумент reverse=True	s = [2, 3, 1] new_s = sorted(s, reverse=True) print(new_s)	[3, 2, 1]

Ещё одной коллекцией в Python является кортеж (tuple). Кортеж является неизменяемой упорядоченной коллекцией. В кортеже нельзя заменить значение элемента, добавить или удалить элемент. Простыми словами, кортеж — неизменяемый список. Свойство неизменяемости используется для защиты от случайных или намеренных изменений.

Задать кортеж можно следующим образом:

numbers = (1, 2, 3, 4, 5)

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

one_number = (1, )

Запятая в примере показывает, что в скобках не совершается операция, а идёт перечисление элементов кортежа.

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

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

a = 1
b = 2
(a, b) = (b, a)
# можно опустить круглые скобки и записать так a, b = b, a
print(f"a = {a}, b = {b}")

Вывод программы:

a = 2, b = 1

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

text = "Привет, мир!"
list_symbols = list(text)
tuple_symbols = tuple(text)
text_from_list = str(list_symbols)
print(list_symbols)
print(tuple_symbols)
print(text_from_list)

Вывод программы:

['П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!']
('П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!')
['П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!']

Обратите внимание: преобразование коллекций к типу данных str не объединяет элементы этой коллекции в одну строку, а возвращает представление коллекции в виде строки.

строковых методов 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)
>>> имя_элемента
'Резиновая утка'
 

Если вам нужна последняя пара вхождений разделителя, вместо этого вы можете использовать метод строки 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 /{идентификаторы}?сайт={сайт}"
# Здесь больше кода
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

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

• encode : обычно вы можете избежать ручного кодирования строк, но вы обнаружите этот метод по необходимости, когда не сможете (см. преобразование между двоичные данные и строки в 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. начинается с и заканчивается с : проверьте, начинается ли строка или заканчивается 1 или несколькими другими строками
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.