Прошлый урок прошёл под знаком арифметических операторов, так что фундамент из чисел уже заложен, и самое время заняться текстом. Строки окружают каждую программу без исключений: имя пользователя, приветствие на экране, путь к файлу, строка таблицы, сообщение об ошибке - всё это текст. 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-строка умеет сразу многое, и вот её главные возможности:
- подставлять значения переменных прямо в текст без склеек и str();
- выполнять вычисления и даже вызывать методы внутри фигурных скобок;
- управлять внешним видом чисел, например количеством знаков после запятой.
Внутри фигурных скобок работает полноценное выражение, а не только имя переменной. 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() всегда возвращает именно строку, какое бы число пользователь ни ввёл. Знания из этого урока сделают тот переход лёгким и понятным.