Прошлый урок прошёл под знаком арифметических операторов, так что фундамент из чисел уже заложен, и самое время заняться текстом. Строки окружают каждую программу без исключений: имя пользователя, приветствие на экране, путь к файлу, строка таблицы, сообщение об ошибке - всё это текст. Python даёт для работы с ними щедрый набор инструментов, и почти все главные из них помещаются в один урок. Дальше разбирается создание строк в разных кавычках, склейка и повторение, длина, индексы, срезы, повседневные методы и f-строки как основной способ форматирования текста в Python 3. К концу урока текст перестанет быть туманным набором букв и превратится в обычный рабочий материал, с которым удобно делать что угодно: резать, склеивать, перекрашивать и красиво показывать на экране.

Создание строк и выбор кавычек

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

name = 'Анна'
city = "Санкт-Петербург"
print(name)
print(city)

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

phrase1 = 'Он сказал: "Начинаем урок"'
phrase2 = "Он сказал: 'Начинаем урок'"
print(phrase1)
print(phrase2)

Экранирование всё же существует: сочетание \" вставляет двойную кавычку внутрь строки в двойных кавычках, а \n означает перенос строки. Но заучивать такие случаи наизусть не обязательно, потому что почти всегда спасает простая смена кавычек. Длина строки при этом значения не имеет: в кавычках может лежать и один символ, и целое полотно текста.

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

note = """Список покупок:
хлеб
молоко
сыр"""
print(note)

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

Склейка строк и повторение текста

Оператор плюс, знакомый по прошлому уроку, со строками работает иначе: он склеивает их в одну. Оператор звёздочка повторяет строку указанное число раз:

first = "Анна"
last = "Смирнова"
full_name = first + " " + last
print(full_name)

line = "=" * 30
print(line)
print("Итоги недели")
print(line)

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

print("-" * 3 + " текст " + "-" * 3)

Инициалы тоже собираются из индексов и плюса за пару секунд:

initials = first[0] + "." + last[0] + "."
print(initials)   # А.С.

Одна ловушка поджидает новичка здесь постоянно: плюс соединяет только строку со строкой. Попытка приклеить текст к числу заканчивается ошибкой TypeError:

age = 25
# print("Возраст: " + age)  # TypeError: can only concatenate str (not "int") to str
print("Возраст: " + str(age))

Функция str() превращает число в строку, и склейка проходит успешно. В конце урока станет понятно, зачем вообще возиться с str(), когда существуют f-строки.

Длина строки и индексы символов

Функция len() считает символы в строке, включая пробелы и знаки препинания:

print(len("Привет, мир!"))   # 12
print(len("Python"))         # 6

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

len() - встроенная функция, как и print(): она принимает строку в скобках и возвращает число. Результат легко сохранить в переменную и использовать в вычислениях:

title = "Домашняя библиотека"
size = len(title)
print(size)      # 19
print(size * 2)  # 38

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

word = "Python"
print(word[0])   # P
print(word[1])   # y
print(word[5])   # n

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

word = "Python"
print(word[-1])   # n
print(word[-2])   # o
print(word[-6])   # P

Запрос индекса за пределами строки приводит к ошибке IndexError: string index out of range, и интерпретатор честно покажет её в консоли. Комментарии в примерах содержат вывод программы, поэтому каждый блок можно копировать целиком и запускать без изменений.

Срезы строк и шаг выборки

Индекс достаёт один символ, а срез - целый кусок. Запись выглядит как квадратные скобки с двумя числами через двоеточие, и у неё есть строгое правило: правая граница в результат не попадает:

s = "Программирование"
print(s[0:7])   # Програм
print(s[7:])    # мирование
print(s[:7])    # Програм
print(s[:])     # Программирование

Срез s[0:7] забирает символы с индексами от нуля до шести, а седьмой остаётся за бортом. Опущенная левая граница означает начало строки, опущенная правая - конец. Срезом удобно откусывать от строки лишнее, например расширение файла:

filename = "report.txt"
print(filename[:-4])   # report

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

word = "Python"
print(word[:100])    # Python
print(word[10:20])   # пустая строка

Третий параметр задаёт шаг. Шаг два берёт каждый второй символ, а отрицательный шаг идёт по строке справа налево и разворачивает её задом наперёд:

s = "Программирование"
print(s[2:9:2])   # орми
print(s[::2])     # Пормиоаи
print(s[::-1])    # еинавориммаргорП

Разворот через срез [::-1] относится к самым известным фокусам Python, его часто просят показать на собеседованиях, так что запомнить его вдвойне полезно. Квадратные скобки и срезы ещё не раз встретятся в курсе: у списков, которые пойдут следом, они работают точно так же.

Методы строк для повседневной работы

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

t = "  Привет, Мир!  "
print(t.upper())   # ПРИВЕТ, МИР!
print(t.lower())   # привет, мир!
print(t.strip())   # Привет, Мир!

upper() поднимает все буквы в верхний регистр, lower() опускает в нижний, strip() отрезает по краям не только пробелы, но и табуляции с переносами строк. Последний незаменим при обработке ввода, потому что пользователи почти всегда оставляют случайные пробелы. Близкий помощник capitalize() поднимает только первую букву строки:

line2 = "привет из python"
print(line2.capitalize())   # Привет из python

Нижний регистр ещё и спасает при сравнении, ведь строка "ДА" и строка "да" для Python разные:

answer = "ДА"
print(answer.lower() == "да")   # True

Метод replace() меняет одну подстроку на другую, split() разрезает строку на список кусков по разделителю, а find() ищет позицию подстроки:

phrase = "я люблю язык python"
print(phrase.replace("python", "Python"))

row = "яблоко,банан,вишня"
fruits = row.split(",")
print(fruits)        # ['яблоко', 'банан', 'вишня']
print(fruits[1])     # банан

text = "здесь спрятан ключ от двери"
print(text.find("ключ"))   # 14

Если find() не находит искомое, он возвращает минус единицу, и это удобно проверять в условии if. Для простой проверки наличия подстроки чаще используют оператор in:

print("ключ" in text)   # True
print("клад" in text)   # False

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

sentence = "python учит думать по-новому"
words = sentence.split()
print(words)        # ['python', 'учит', 'думать', 'по-новому']
print(len(words))   # 4

Неизменяемость строк и новая строка

У строк есть свойство, которое поначалу сбивает с толку: изменить строку на месте нельзя. Попытка присвоить новое значение отдельному символу заканчивается ошибкой:

s = "привет"
# s[0] = "П"  # TypeError: 'str' object does not support item assignment

Интерпретатор прямо сообщает, что строки не поддерживают присваивание по индексу. Поэтому любое преобразование создаёт новую строку, а старая остаётся нетронутой:

s = "привет"
shout = s.upper()
print(s)       # привет
print(shout)   # ПРИВЕТ

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

s = "привет"
s = "П" + s[1:]
print(s)   # Привет

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

dirty = "  Смешанный СЛУЧАЙ  "
clean = dirty.strip().lower()
print(clean)   # смешанный случай

F-строки для форматирования текста и чисел

Склейка плюсом быстро надоедает: кавычки, пробелы, постоянные str(). С третьей версии Python в языке появились f-строки, и сейчас это главный способ подставлять значения в текст. Достаточно поставить букву f перед кавычками и заключить имя переменной в фигурные скобки. Сама буква f расшифровывается как formatted, то есть форматированная строка:

name = "Мария"
age = 25
print(f"Меня зовут {name}, мне {age} лет")

F-строка при этом остаётся самой обычной строкой: её можно сохранить в переменную, склеить с другой строкой и передать в print позже. Кавычки внутри тоже работают, если внешние другие:

greeting = f"Привет, {name}!"
print(greeting)   # Привет, Мария!
print(f'{name} сказал "привет"')

F-строка умеет сразу многое, и вот её главные возможности:

  1. подставлять значения переменных прямо в текст без склеек и str();
  2. выполнять вычисления и даже вызывать методы внутри фигурных скобок;
  3. управлять внешним видом чисел, например количеством знаков после запятой.

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

a = 7
b = 3
print(f"{a} + {b} = {a + b}")
print(f"Квадрат числа {a} равен {a ** 2}")
print(f"Имя заглавными буквами: {name.upper()}")
print(f"Букв в слове Привет: {len('Привет')}")

Отдельная сила f-строк - форматирование чисел. После двоеточия указывается шаблон, и .2f означает число с плавающей точкой и двумя знаками после запятой:

price = 1234.5
total = price * 3
print(f"Цена: {price:.2f} руб.")
print(f"Сумма за три штуки: {total:.2f} руб.")

pi = 3.1415926535
print(f"Число pi с тремя знаками: {pi:.3f}")

progress = 0.7543
print(f"Готово: {progress:.1%}")

Без шаблона цена вывелась бы как 1234.5, а с ним получаются аккуратные 1234.50, ровно как в чеках и отчётах. Шаблон .1% умножит долю на сто и добавит знак процента, превратив 0.7543 в 75.4%. До появления f-строк текст собирали оператором процент и методом format(), они до сих пор встречаются в чужом коде, но новые проекты разумнее писать на f-строках: короче, читабельнее и быстрее.

В следующем уроке программа впервые заговорит с человеком: функции input() и print() научат её задавать вопросы и показывать ответы. И там строки пригодятся на полную мощность, потому что input() всегда возвращает именно строку, какое бы число пользователь ни ввёл. Знания из этого урока сделают тот переход лёгким и понятным.