Строки в Python: текст как данные

Текст окружает любую программу: имя пользователя в форме, город в доставке, сообщение бота, строка лога, колонка CSV-файла. Всё это в Python — строки, тип str. Раздел начинается с фундамента: что вообще считается строкой, как её записать, как измерить, склеить и повторить — и почему одну из этих операций Python запретит.

Ничего устанавливать не нужно: строки — часть самого языка. Каждый код-блок на странице запускается в браузерном интерпретаторе кнопкой «Запустить» — вывод можно проверить сразу.

Кавычки: одинарные и двойные

Строка — это последовательность символов в кавычках. Python разрешает два вида: одинарные и двойные — и они полностью равнозначны. 'кот' и "кот" — одна и та же строка, Python даже не отличит:

first = 'кот'
second = "кот"
print(first == second)
print(type(first))

True
<class 'str'>

Функция type() вернула str — так называется строковый тип. А равенство True означает: для Python это буквально одно и то же значение. Выбирают обычно один стиль и держатся его во всём проекте — так код выглядит единообразно.

len: сколько в строке символов

len (от англ. length — длина) считает символы строки. Это встроенная функция, а не метод: строка передаётся ей в скобках:

print(len('кот'))
print(len(' кот '))
print(len(''))

3
5
0

Три сюрприза в одном блоке: пробел — тоже символ и считается наравне с буквами (строка ' кот ' длиннее слова «кот» на два), а пустая строка '' — полноценная строка длиной ноль. Пустая строка встречается везде: это «ничего не ввели», «не нашли», «очистили».

Конкатенация: плюс склеивает строки

Конкатенация — склейка строк оператором +. Берёшь одну строку, прибавляешь другую — получаешь третью:

greeting = 'Привет, '
name = 'Аня'
message = greeting + name
print(message)
print('кот' + ' ' + 'код')

Привет, Аня
кот код

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

print('3' + '3')
print(3 + 3)

33
6

Умножение: строка на число

Второй арифметический фокус со строками: умножение на целое число повторяет строку нужное количество раз. Разделители таблиц, рамки, подчёркивания — всё это делается в одну строку кода:

line = '-' * 20
print(line)
print('ля' * 3)
print('кот' * 0)

--------------------
ляляля

'ля' * 3 собрал 'ляляля' — три повтора подряд, без разделителей. А 'кот' * 0 дал пустую строку: ноль повторов — это ничего, и print вывел пустую строку. Умножение на отрицательное число работает так же — даст пустую строку, ошибки не будет.

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

Строки в Python неизменяемы (immutable): после создания строку нельзя поменять ни на один символ. Это не стиль, а жёсткое правило языка — и первый по частоте сюрприз новичка. Попробуем переписать первую букву слова «кот»:

s = 'кот'
try:
    s[0] = 'X'
except TypeError as e:
    print(e)
print(s)

'str' object does not support item assignment
кот

Квадратные скобки s[0] достают символ по номеру — нумерация идёт с нуля, о ней подробно рассказано в уроке про срезы. Но присвоить через них новое значение нельзя: Python отвечает 'str' object does not support item assignment — «строка не поддерживает присваивание элементу». Строка s после этого всё та же: «кот».

Как же «изменить» строку? Собрать новую и записать в переменную — хоть с тем же именем. Первую букву заменит склейка: новый символ плюс хвост старой строки:

s = 'кот'
fixed = 'Р' + s[1:]
print(fixed)
print(s)

Рот
кот

Запись s[1:] означает «всё, начиная с символа номер один» — срез, его полный разбор ждёт в уроке 2. Важно другое: исходная строка не тронулась, мы получили новую — Рот — и положили её в новую переменную. Тот же принцип у всех методов строк: replace и strip тоже возвращают новые строки, не меняя старые.

print: как выводится текст

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

print('кот', 'код', 'ток')
print('кот', 'код', sep=' | ')
print('без', end=' ')
print('переноса')

кот код ток
кот | код
без переноса

Несколько аргументов через запятую print разделяет пробелом; параметр sep заменяет этот разделитель, а end — то, чем заканчивается вывод (по умолчанию переносом строки). В этом курсе вывод почти всегда одна строка на print — так результат легко сверить с ожидаемым.

Сценарий: чек из двух полей формы

Приём заказа в маленьком интернет-магазине выглядит так: в форме два поля — название товара и количество. Валидатор проверил, что поля не пустые, и передал программе две строки: title = 'Кружка' и count = '3'. Дальше нужно показать покупателю, что он заказал, и записать это в лог. Обе задачи — про сборку текста из готовых кусочков.

title = 'Кружка'
count = '3'

label = title + ' x' + count
total = 'К заказу: ' + label
print(total)
print(len(total))

К заказу: Кружка x3
19

Счёт в форме пришёл строкой, и в этой задаче это даже удобно: количество показывают как есть, одним куском текста, без всякой арифметики. Длина собранной строки — 19 символов, и len посчитал её быстро, потому что длина хранится рядом с текстом, а не вычисляется перебором букв.

Число или строка: откуда берётся разница

Строки не возникают из воздуха: их приносят input(), CSV-файл, JSON, строка лога. И почти всегда это именно текст, даже когда за ним стоит число. Поэтому первое, что стоит сделать с полученным значением, — привести его к нужному типу явно: int(count), float(price). И наоборот: если число надо показать в тексте, его надо превратить в str().

count = '3'
price = '129.5'

print(int(count) * 2)
print(float(price) + 0.5)
print(str(int(count)) + ' шт.')

6
130.0
3 шт.

number = '41'
try:
    print(number + 1)
except TypeError as e:
    print('Ошибка типа:', type(e).__name__)
print(int(number) + 1)

Ошибка типа: TypeError
42

Строки, числа и списки: одна таблица, три разных правила

Разница между строками и числами не в синтаксисе, а в смысле. Число можно увеличить, и оно останется тем же числом. Строку увеличить нельзя, поэтому каждая правка текста создаёт новый объект — и это правило стоит держать в голове весь курс.

Что лежит внутри строки

Строка — не «текст вообще», а конкретный объект: в нём лежит ссылка на последовательность символов и отдельно записанная длина. Длина хранится рядом с текстом, поэтому len не пересчитывает её, проходя по буквам. Отсюда и то, что у пустой строки длина равна нулю, а не «неизвестно».

Вторая деталь: короткие строки Python часто не создаёт заново, а берёт из заранее заготовленных. Именно поэтому 'кот' + 'код' не тормозит, а вот склейка тысяч кусков в цикле — тормозит: там каждый раз появляется новый объект, и прежний текст копируется целиком. Про разницу в скорости — в уроке про join.

Карточка операций урока

Следующий шаг — доставать из строки не только длину, но и части: символы, куски, разворот. Это срезы, и они заслуживают отдельного урока 2. А чтобы красиво вставлять значения в текст без плясок с плюсами и str(), добро пожаловать в урок 3 про f-строки.

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