Методы преобразования и выравнивания строк

Программируя на Python, мы уже сталкивались как с функциями, так и с методами. Функции не привязаны к объектам и вызываются независимо от них. Например, функция id() возвращает уникальный идентификатор объекта, а функция print() выводит данные на экран.

Однако методы, напротив, принадлежат определённым типам данным (классам) и используются только совместно с объектом, к которому относятся. Например, уже рассмотренный метод dict.values() возвращает последовательность значений словаря dict.

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

Но строки являются неизменяемым типом данных, поэтому методы, преобразующие строку, на самом деле не изменяют её, а возвращают изменённую копию исходной строки, которую следует сразу использовать в работе или присвоить какой-либо переменной.

Изменение регистра букв строки

Прежде всего, вспомним, что буквы могут находиться в двух регистрах:

• нижний регистр – маленькие или строчные буквы ("ведомство");
• верхний регистр – заглавные или прописные буквы ("КГБ").

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

Приведение строки к единому регистру

Для преобразования всех букв строки в нижний регистр предназначен метод str.lower() а для приведения к верхнему регистру – метод str.upper().

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

message1 = input()
if message1.lower() == "привет":
    print("И тебе привет, дорогой друг!")
# Ввод: ПрИвЕт
# Вывод: И тебе привет, дорогой друг!

message2 = input()
if message2.upper() == "ПОКА":
    print("И тебе всего хорошего!")
# Ввод: покА
# Вывод: И тебе всего хорошего!

Изменение регистра отдельных частей строки

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

Метод str.capitalize() преобразует первую букву строки в верхний регистр, а все остальные – в нижний, а метод str.title() приводит к верхнему регистру первую букву каждого слова в строке, а остальные буквы делает строчными.

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

name = "иван"
print(name.capitalize())
# Вывод: Иван

article = "Самая ВКУСНАЯ оКрОшКа всего за 30 МИНУТ"
print(article.capitalize())
# Вывод: Самая вкусная окрошка всего за 30 минут

И если метод str.capitalize() приводит строку к виду предложения, то метод str.title() основан на правилах написания заголовков в английском языке, где каждое значимое слово начинается с заглавной буквы:

book = "Learn PYTHON the HARD WAY"
print(book.title())
# Вывод: Learn Python The Hard Way

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

message = "What's up, bro?"
print(message.title()) 
# Вывод: What'S Up, Bro?

Но если строка состоит из одного слова, то результаты методов str.title() и str.capitalize() совпадут:

city = "черепОВЕЦ"
print(city.capitalize())
# Вывод: Череповец
print(city.title())
# Вывод: Череповец

Удаление символов в начале и в конце строки

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

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

name = "  Жуков Георгий Константинович!!!\t\t\n   "
print("Приветствую,", name.strip()) 
# Вывод: Приветствую, Жуков Георгий Константинович!!!

Но параметр chars позволяет явно указать символы для удаления:

name = "  zzz!Кутузов, Михаил Илларионович!zzz  "
print("Приветствую,", name.strip("!z "))
# Вывод: Приветствую, Кутузов, Михаил Илларионович!

Порядок символов в строке chars не имеет значения, удаляются все вхождения любого из этих символов в начале и конце строки.

Если требуется удалить символы только в начале или только в конце строки, то у метода str.strip() есть варианты с префиксами «l» (от англ. left – лево) и «r» (от англ. right – право), которые удаляют символы слева или справа соответственно. Такое использование префиксов характерно для многих методов в Python.

Например, мы уверены, что пользователь может ввести лишние пробелы только в начале строки:

name = "    Райковский Викентий Логгинович"
print(name.lstrip())
# Вывод: Райковский Викентий Логгинович

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

occupation = "Генерал___"
print(occupation.rstrip("_"))
# Вывод: Генерал

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

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

В самом простом случае методу str.replace() достаточно передать заменяемое и новое значение:

poetic_line = "Ласточка с весною в сени к нам летит." 
new_poetic_line = poetic_line.replace("Ласточка", "Голубка")
print(new_poetic_line)
# Вывод: Голубка с весною в сени к нам летит.

Но с помощью параметра count можно ограничить количество замен:

poetic_line = "С нею солнце краше. И весна милей..." 
new_poetic_line = poetic_line.replace("с", "S", 3)
print(new_poetic_line)
# Вывод: С нею Sолнце краше. И веSна милей.... 

Если подстрока для замены не найдена, метод str.replace() возвращает исходную строку без изменений:

poetic_line = "Прощебечь с дороги нам привет скорей!" 
new_poetic_line = poetic_line.replace("дам тебе я зерен", "песню спой")
print(new_poetic_line)
# Вывод: Прощебечь с дороги нам привет скорей!

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

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

Например, у нас есть строка с жанрами фильмов, и с помощью метода str.split() мы можем разбить её на список, используя запятую в качестве разделителя:

genres = "комедия,фантастика,романтика"
genres_list = genres.split(",")
print(genres_list)
# Вывод: ['комедия', 'фантастика', 'романтика']

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

musicals = "Кабаре Отверженные    Эвита"
print(musicals.split())
# Вывод: ['Кабаре', 'Отверженные', 'Эвита']

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

message = "Он купил хлеб, молоко, колбасу и конфеты"
lst = message.split(",", 1)
print(lst)
# Вывод: ['Он купил хлеб', ' молоко, колбасу и конфеты']

Здесь строка разбивается на две части только по первой запятой.

Объединение элементов коллекции в строку

В то время как метод str.split() разделяет строку на список подстрок, метод str.join(), наоборот, объединяет все элементы коллекции (которые должны быть строками) в одну новую строку.

Этот метод берет каждую строку из коллекции и вставляет строку-разделитель между ними, тем самым создавая новую строку:

sentence = ["Сегодня", "идёт", "снег"]
sep = " "
sentence_str = sep.join(sentence)
print(sentence_str)
# Вывод: Сегодня идёт снег

При этом, если хотя один элемент объединяемой коллекции не является строкой, то вызывается исключение TypeError:

grades = ["Отлично", "Хорошо", 3]
sep = " "
grades_str = sep.join(grades)
# Ошибка: TypeError: sequence item 2: expected str instance, int found

Выравнивание строк

Методы выравнивания строк добавляют определенные символы-заполнители в начало или конец строки до тех пор, пока строка не достигнет заданной длины.

По умолчанию строка уже выравнена по левому краю, однако это также можно сделать явно с помощью метода str.ljust() (от англ. left justify – выравнивать слева) который добавляет символы-заполнители в конец строки.

По правому краю строку выравнивает метод str.rjust() (от англ. right justify – выравнивать справа), добавляющий символы-заполнители в начало строки.

Методы str.ljust() и str.rjust() отличаются префиксами «l» и «r», обозначающими по какому краю выравнивается строка.

По центру строку выравнивает метод str.center(), который добавляет символы-заполнители в начало и конец строки.

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

• Столбец "Название" сделаем шириной 20 символов и выровняем по левому краю.
• Столбец "Год выхода" ограничим до ширины 15 символов и выровняем по центру.
• Столбец "Жанр" сделаем шириной 20 символов и выровняем по правому краю.

# Создаём заголовки
title = "Название".ljust(20, "-")
year = "Год выхода".center(15, "-")
genre = "Жанр".rjust(20, "-")

# Создаём ячейки первой строки
game1_title = "Марио".ljust(20, "-")
game1_year = "1985".center(15, "-")
game1_genre = "Платформер".rjust(20, "-")

# Построчно выводим на экран
print(f"{title}|{year}|{genre}")
print(f"{game1_title}|{game1_year}|{game1_genre}")

Тогда на экран будет выведена следующая таблица:

Название------------|---Год выхода--|----------------Жанр
Марио---------------|------1985-----|----------Платформер

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

Также метод str.rjust() полезен для выравнивания чисел путём добавления ведущих нулей:

print("23".rjust(5, "0"))
# Вывод: 00023

Однако для этой цели существует более специализированный метод – str.zfill(width) (от англ. zero fill – заполнить нулями), который дополняет строку ведущими нулями до указанной длины.

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

print("-791".zfill(6))
# Вывод: -000791

Примеры

Пример 1. Нормализация пользовательского ввода команд

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

command = input("Введите команду: ")
normalized_command = command.strip().lower()
if normalized_command == "выход":
    print(f"Завершение работы")
else:
    print(f"Команда '{command}' не распознана")

Вывод:

Введите команду:     ВыХОД  
Завершение работы

Пример 2. Создание отчёта о наличии товаров на складе

Программа выводит на экран отчёт о наличии товаров на складе с колонками фиксированной ширины:

# Исходные данные
sales = [
    ("Ноутбук", 15, 45000),
    ("Монитор", 8, 12000),
    ("Клавиатура", 23, 1500)
]
 
# Создаём заголовки
item_title = "Товар".ljust(15)
count_title = "Кол-во".center(10)
price_title = "Цена".rjust(10)
print(item_title + count_title + price_title)
print("-" * 35)
 
# Заполняем таблицу 
for sale in sales:
    item = sale[0].ljust(15)
    count = str(sale[1]).zfill(3).center(10)
    price =  f"{sale[2]}".rjust(10)
    print(item + count + price)

Вывод:

Товар            Кол-во        Цена
-----------------------------------
Ноутбук           015         45000
Монитор           008         12000
Клавиатура        023          1500

Пример 3. Генератор логинов из ФИО

Программа создаёт логин сотрудника в формате «фамилия_инициалы» на основе полного имени:

full_name = "Ковалевская Софья Васильевна"
 
# Разделяем ФИО на части
parts = full_name.split()
 
# Формируем логин: фамилия + первая буква имени + отчества
login = f"{parts[0]}_{parts[1][0]}{parts[2][0]}".lower()
print(f"Логин сотрудника: {login}")

Вывод:

Логин сотрудника: ковалевская_св

Итоги

Задания для самопроверки

1. Почему методы преобразования строк в Python возвращают новую строку, а не изменяют исходную?

2. Запросите у пользователя строку s и символ sep для разбиения этой строки на список. Разбейте строку s на список по разделителю sep и выведите этот список на экран.

s = input("Введите строку для преобразования в список: ")
sep = input("Введите разделитель: ")
lst = text.split(separator)
print(lst)

3. Выведите на экран строку "Привет, друг!", выровненную по центру до длины 20 символов символом "-".

message = "Привет, друг!"
print(message.center(20, "-"))  
# Вывод: ----Привет, друг----

4. Как удалить лишние пробелы и символ "№" в начале и конце строки " Заказ №298 №№№"? Каким бы методом вы воспользовались для удаления пробелов только в начале строки?

order = "    Заказ №298 №№№"
print(order.strip(" №"))
# Вывод: Заказ №298

order = "    Заказ №298 №№№"
print(order.lstrip(" №"))
# Вывод: Заказ №298 №№№

5. Запросите у пользователя строку. Если пользователь написал "да" в любом регистре, то выведите на экран строку "Продолжение работы", а если "нет", то – "Завершение работы". Если пользователь ввёл строку, отличную от ответа "да" или "нет", то выведите на экран строку "Команда не распознана".

answer = input("Хотите продолжить? (да/нет): ").lower()

if answer == "да":
    print("Продолжение работы")
elif answer == "нет":
    print("Завершение работы")
else:
    print("Команда не распознана")