Главная
Основы Python
Строки и коллекции данных

Основные методы строк

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

строка.имя_метода(аргументы)

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

string = "Hello World!"

и мы собираемся для нее вызвать метод

String.upper()

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

string.upper()

Вот по такому синтаксису вызываются различные методы строк. Причем, сама переменная string продолжает ссылается на ту же самую неизмененную строку «Hello World!». Как мы с вами говорили на предыдущем занятии, строки – это неизменяемые объекты, поэтому метод upper возвращает новую строку с заглавными буквами, не меняя прежней.

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

string = string.upper()

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

Также этот метод мы можем вызвать непосредственно у строкового литерала:

"hello".upper()

Так тоже можно делать.

Ну и раз уж мы затронули метод upper, который переводит буквы в верхний регистр, то отметим противоположный ему метод:

String.lower()

который, наоборот, преобразует все буквы в строчные. Например:

string.lower()

возвращает строку «hello world!». Соответственно, сама строка здесь остается прежней, измененным является новый строковый объект, который и возвращает метод lower. По такому принципу работают все методы при изменении строк. Следующий метод

String.count(sub[, start[, end]])

возвращает число повторений подстроки sub в строке String. Два необязательных аргумента:

start – индекс, с которого начинается поиск;
end – индекс, которым заканчивается поиск.

В самом простом случае, мы можем для строки

msg = "abrakadabra"

определить число повторений сочетаний «ra»:

msg.count("ra")

получим значение 2 – именно столько данная подстрока встречается в нашей строке.

Теперь предположим, что мы хотим начинать поиск с буквы k, имеющей индекс 4.

Тогда метод следует записать со значением start=4:

msg.count("ra", 4)

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

msg.count("ra", 4, 10)

и получаем значение 0. Почему? Ведь на индексах 9 и 10 как раз идет подстрока «ra»? Но здесь, также как и в срезах, последний индекс исключается из рассмотрения. То есть, мы говорим, что нужно дойти до 10-го, не включая его. А вот если запишем 11:

msg.count("ra", 4, 11)

то последнее включение найдется.

Следующий метод

String.find(sub[, start[, end]])

возвращает индекс первого найденного вхождения подстроки sub в строке String. А аргументы start и end работают также как и в методе count. Например:

msg.find("br")

вернет 1, т.к. первое вхождение «br» как раз начинается с индекса 1. Поставим теперь значение start=2:

msg.find("br", 2)

и поиск начнется уже со второго индекса. Получим значение 8 – индекс следующего вхождения подстроки «br». Если мы укажем подстроку, которой нет в нашей строке:

msg.find("brr")

то метод find возвращает -1. Третий аргумент end определяет индекс до которого осуществляется поиск и работает также как и в методе count.

Метод find ищет первое вхождение слева-направо. Если требуется делать поиск в обратном направлении: справа-налево, то для этого используется метод

String.rfind(sub[, start[, end]])

который во всем остальном работает аналогично find. Например:

msg.rfind("br")

возвратит 8 – первое вхождение справа.

Наконец, третий метод, аналогичный find – это:

String.index(sub[, start[, end]])

Он работает абсолютно также как find, но с одним отличием: если указанная подстрока sub не находится в строке String, то метод приводит к ошибке:

msg.index("brr")

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

Следующий метод

String.replace(old, new, count=-1)

Выполняет замену подстрок old на строку new и возвращает измененную строку. Например, в нашей строке, мы можем заменить все буквы a на o:

msg.replace("a", 'o')

на выходе получим строку «obrokodobro». Или, так:

msg.replace("ab", "AB")

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

msg.replace("ab", "")

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

msg.replace("a", 'o', 2)

Заменит только первые две буквы a: «msg.replace("a", 'o', 2)». При значении -1 количество замен неограниченно.

Следующие методы позволяют определить: из каких символов состоит наша строка. Например, метод

String.isalpha()

возвращает True, если строка целиком состоит из букв и False в противном случае. Посмотрим как он работает:

msg.isalpha()

вернет True, т.к. наша строка содержит только буквенные символы. А вот для такой строки:

"hello world".isalpha()

мы получим False, т.к. имеется символ пробела.

Похожий метод

String.isdigit()

возвращает True, если строка целиком состоит из цифр и False в противном случае. Например:

"5.6".isdigit()

т.к. имеется символ точки, а вот так:

"56".isdigit()

получим значение True. Такая проверка полезна, например, перед преобразованием строки в целое число:

dig = input("Введите число: ")
if(dig.isdigit()):
   dig = int(dig)
    print(dig)
else:
   print("Число введено неверно")

Следующий метод

String.rjust(width[, fillchar = ‘ ‘])

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

d="abc"
d.rjust(5)

Получаем строку « abc» с двумя добавленными слева пробелами. А сама исходная строка как бы прижимается к правому краю. Или, можно сделать так:

d.rjust(5, "-")

Получим строку «--abc». Причем вторым аргументом можно писать только один символ. Если записать несколько, то возникнет ошибка:

d.rjust(5, "-*")

Если ширина width будет меньше длины строки:

d.rjust(2)

то ничего не изменится. Аналогично работает метод

String.ljust(width[, fillchar = ‘ ‘])

который возвращает новую строку с заданным числом символов width, но добавляет символы fillchar уже справа:

d.ljust(10, "*")

Следующий метод

String.split(sep=None, maxsplit=-1)

возвращает коллекцию строк, на которые разбивается исходная строка String. Разбивка осуществляется по указанному сепаратору sep. Например:

"Иванов Иван Иванович".split(" ")

Мы здесь разбиваем строку по пробелам. Получаем коллекцию из ФИО. Тот же результат будет и при вызове метода без аргументов, то есть, по умолчанию он разбивает строку по пробелам:

"Иванов Иван Иванович".split()

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

digs = "1, 2,3, 4,5,6"
digs.replace(" ", "").split(",")

мы сначала убираем все пробелы и для полученной строки вызываем split, получаем список цифр.

Обратный метод

String.join(список)

возвращает строку из объединенных элементов списка, между которыми будет разделитель String. Например:

d = digs.replace(" ", "").split(",")
", ".join(d)

получаем строку «1, 2, 3, 4, 5, 6». Или так, изначально была строка:

fio = "Иванов Иван Иванович"

и мы хотим здесь вместо пробелов поставить запятые:

fio2 = ",".join(fio.split())

Теперь fio2 ссылается на строку с запятыми «Иванов,Иван,Иванович».

Следующий метод

String.strip()

удаляет пробелы и переносы строк в начале и конце строки. Например:

"   hello world         \n".strip()

возвращает строку «hello world». Аналогичные методы:

String.rtrip() и String.ltrip()

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

Вот такие методы строк существуют в Python. Для наглядности ниже они представлены в таблице:

Название	Описание
String.upper()	Возвращает строку с заглавными буквами
String.lower()	Возвращает строку с малыми буквами
String.count(sub[, start[, end]])	Определяет число вхождений подстроки в строке
String.find(sub[, start[, end]])	Возвращает индекс первого найденного вхождения
String.rfind(sub[, start[, end]])	Возвращает индекс первого найденного вхождения при поиске справа
String.index(sub[, start[, end]])	Возвращает индекс первого найденного вхождения
String.replace(old, new, count=-1)	Заменяет подстроку old на new
String.isalpha()	Определяет: состоит ли строка целиком из буквенных символов
String.isdigit()	Определяет: состоит ли строка целиком из цифр
String.rjust(width[, fillchar = ‘ ‘])	Расширяет строку, добавляя символы слева
String.ljust(width[, fillchar = ‘ ‘])	Расширяет строку, добавляя символы справа
String.split(sep=None, maxsplit=-1)	Разбивает строку на подстроки
String.join(список)	Объединяет коллекцию в строку
String.strip()	Удаляет пробелы и переносы строк справа и слева
String.rstrip()	Удаляет пробелы и переносы строк справа
String.ltrip()	Удаляет пробелы и переносы строк слева

Задания для самоподготовки

1. Написать программу корректности ввода телефонного номера по шаблону:

x(xxx)xxxxxx

где x – любая цифра от 0 до 9. Данные представлены в виде строки.

2. Написать программу изменения строки

"2+3+6.7 + 82 + 5.7 +1"

на строку, в которой все «+» заменены на «-» и удалены все пробелы

3. Написать программу вывода чисел 0; -100; 5.6; -3 в виде столбца:

в котором все строки выровнены по правому краю (подсказка: воспользуйтесь методом rjust).

4. В строке "abrakadabra" найдите все индексы подстроки «ra» и выведите их (индексы) в консоль.

Основные методы строк

Задания для самоподготовки

Видео по теме