Один из самых недооценённых начинающими питонистами встроенных типов данных - строки. Как недавно признался один из студентов: "Когда я встречаю строки - сразу иду гуглить". И это странно, ведь работа с текстом неизбежна.
Откуда текст может возникать? Откуда угодно. Текст может генерироваться при помощи вашего кода налету, приходить извне через input() или откуда-то из интернета. Кроме этого, вы можете (и будете) писать его самостоятельно. Во всех этих случаях вам нужно уметь его обрабатывать либо для дальнейшего использования в коде, либо для вывода на экран, либо для каких-то иных целей.
За работу с текстом в пайтоне отвечают строки. Напомню, что строки - это неизменяемые последовательности, которые поддерживают индексацию и срезы. Пайтон воспринимает текст в качестве текста только в том случае, когда текст заключён (или, если угодно, обёрнут) в литералы строк - кавычки или апострофы.
Все нижеприведённые примеры являются строками в понимании питона:
s = 'text' # одинарные апострофы
s = "text" # одинарные двойные кавычки
s = '''text''' # тройные апострофы
s = """text""" # тройные двойные кавычки
Строкой является любой символ (или последовательность символов), заключённый в литералы строк, в т.ч. пробелы, цифры, знаки препинания.
# Это всё строки
s = '' # пустая строка (без символов между литералами) - тоже строка
s = " " # это строка из одного пробела
s = 'мама мыла раму'
s = "1234" # это не число, это строка
s = " Привет, мир! "
Обратите внимание на последний пример. Он начинается и заканчивается пробелами. Эти пробелы так и будут выводиться на экран и сами собой никуда не денутся. Это важно, потому что пробел также является символом строки и элементом последовательности. В данном случае при принте первого и/или последнего элемента мы не увидим ничего на экране. Но тем не менее, эти пробелы там будут, потому что они включены в строку и являются её элементами, хоть и не имеют визуального отображения. Что с этим делать и как быть, мы обязательно поговорим во второй части.
В чём разница одинарных и тройных литералов? Стандартно для объявления строк в коде мы используем одинарные кавычки или апострофы. И чаще всего такие строки являются короткими.
Тройные вариации используются в основном для написания документационных аннотаций к модулям, классам и функциям. Иначе это называется docstring или докстринг, и о них мы поговорим, когда дойдём до функций. А пока что нужно иметь в виду, что такой тип объявления строки технически доступен в рамках кода как такового для создания длинных строк.
Что значит короткая и длинная строка? Для ответа на этот вопрос вспомним PEP8: длина строки кода не должна превышать 80 символов. Пока строка текста не превышает этот предел - она считается короткой. Как только текст требует переноса - строка становится длинной.
Экранирование
По умолчанию пайтон в принтах выводит строки, обёрнутые в одинарные апострофы, как бы они ни были заданы пользователем.
>>> s = "text" # одинарные двойные кавычки
>>> s
'text' # в выводе - одинарные апострофы
Нам с вами совершенно не важно, какие литералы отобразятся в принте. Единственное, что нас интересует - это то, что заключено внутри этих литералов. Но такое поведение сохраняется до определенной ситуации.
Сейчас внимательно следите за порядком слов "кавычки" и "апострофы". Если внутри самой строки должны содержаться апострофы или кавычки, то сама строка должна обрамляться соответственно кавычками или апострофами:
>>> "A.Dumas - D'Artagnan et les trois mousquetaires"
"A.Dumas - D'Artagnan et les trois mousquetaires"
>>> 'Ледокол "Ленин"'
'Ледокол "Ленин"'
Т.е. питон самостоятельно меняет вид обрамляющих литералов в зависимости от того, что находится внутри строки. А что если внутри строки должны быть и кавычки, и апострофы одновременно? Тут можно пойти двумя путями:
1. использовать тройные кавычки или апострофы (при чём без разницы, что вы из них выберете),
>>> """O'Reilly published D.Beazley's book "Python Cookbook" in 2013"""
'O\'Reilly published D.Beazley\'s book "Python Cookbook" in 2013'
2. использовать экранирование специальным символом обратного слэша - \.
>>> 'O\'Reilly published D.Beazley\'s "Python Cookbook" in 2013'
'O\'Reilly published D.Beazley\'s "Python Cookbook" in 2013'
>>> "O'Reilly published D.Beazley's \"Python Cookbook\" in 2013"
'O\'Reilly published D.Beazley\'s "Python Cookbook" in 2013'
Как вы видите, в экранировании нуждаются символы, совпадающие с литералами - главное не запутаться, особенно, если текста много.
В экранировании также нуждаются специальные символы, при использовании которых в поведении строк происходят те или иные изменения. За полным списком таких символов и за примерами использования я вас пошлю вот сюда. Здесь же я опишу только те, которые чаще всего используются на деле (некоторые примеры я позаимствовал оттуда же).
Однако, прежде чем продолжить, хочу сделать ремарку для тех, кто родился в эпоху мобильных телефонов: некоторая терминология в статье, куда я вас отправил, относится к эре печатных машинок. Если вы не знаете, что такое звонок, каретка и как её переводить - "Ok, Google! Устройство печатной машинки".
Итак,
\ - если после символа \ сразу нажать Enter, то это переведёт каретку на новую строку:
>>> s = 'Это будет очень\
... , очень-очень\
... , ну прям оооооочень\
... длинная строка'
>>>
>>> s
'Это будет очень, очень-очень, ну прям оооооочень длинная строка'
\\ - экранирование символа обратного слеша (полезно при работе с файловой системой винды):
>>> s = 'D:\\мои документы\\книги\\Лутц.pdf'
>>> s
'D:\\мои документы\\книги\\Лутц.pdf'
\n - перевод каретки (новая строка):
>>> s = "Мама мыла раму\nМила раму мыла"
>>> print(s) # только функция print понимает, что делать со спецсимволами
Мама мыла раму
Мила раму мыла
>>> s # в этом случае просто выводится содержимое переменной
'Мама мыла раму\nМила раму мыла'
\t - горизонтальный отступ слева от начала строки (горизонтальная табуляция (да, есть и вертикальная)):
>>> s = '0\t1\t\t2\t\t\t3'
>>> print(s)
0 1 2 3
>>> '0 1 2 3'
'0\t1\t\t2\t\t\t3'
Achtung! Achtung! Приятные новости: в длинных строках всё это не нужно! =)
>>> s = """Эта очень длинная строка
... сама переносится, сама табулируется
... сама экранируется \."""
>>> print(s)
Эта очень длинная строка
сама переносится, сама табулируется
сама экранируется \.
>>> s
'Эта очень длинная строка\nсама переносится, сама\tтабулируется\nсама экранируется \\.'
>>> s = """Но если вдруг вам будет очень нужно прописать здесь что-то вроде '\n', то вам нужно воспользоваться экранированием, чтобы \\n не выполнялся"""
>>> print(s)
Но если вдруг вам будет очень нужно прописать здесь что-то вроде '
', то вам нужно воспользоваться экранированием, чтобы \n не выполнялся
Функция print
Тут надо бы вспомнить про функцию print. Как я уже говорил, это функция всеядная и может переварить много чего. Помимо того, что она всеядная, она ещё и достаточно хитрая. Напишите в консоли вот такую команду :
>>> help(print)
Кстати говоря, никогда не стесняйтесь использовать этот официальный help питона: передавая в него название любого встроенного объекта вы получите очень классную справку. Про print питон вам немедленно расскажет следующее:
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
Лаконично, просто и понятно. Вот её сигнатура:
def print(self, *args, sep=' ', end='\n', file=None):
Она говорит нам о том, что:
*args - функция всеядная, т.е. ожидает любых аргументов в любом количестве,
sep=' ' - при выводе нескольких аргументов для их отделения друг от друга по умолчанию используется пробел,
end='\n' - любой вывод по умолчанию заканчивается переводом каретки на новую строку,
file=None - по умолчанию вывод производится на экран (если в этот параметр передать имя конкретного файла, то информация запишется (будет выведена) в такой файл).
Собственно, что это вдруг я её вспомнил? Посмотрите ещё раз внимательно. В числе её параметров присутствуют такие вещи как sep=' ' и end='\n'. Оба этих параметра принимают любые строковые символы, в том числе экранируемые. Зачем это нужно знать? Затем, чтобы иметь возможность оформлять вывод по своему желанию.
>>> a = "Мама"
>>> b = "мыла"
>>> c = "раму"
>>> print(a, b, c) # стандартный принт трёх переменных
Мама мыла раму
>>> print(a, b, c, sep='\t') # делаем разделителем табуляцию
Мама мыла раму
>>> print(a, b, c, sep='\t', end='\n\n') # добавляем лишнюю пустую строку по окончанию вывода
Мама мыла раму
>>> print(a, b, c, sep='42')
Мама42мыла42раму
>>> print(a, b, c, sep='42', end='THE END')
Мама42мыла42рамуTHE END
Этими примерами я хотел показать прежде всего то, что упомянутые мной специальные символы могут корректировать вывод так, как вы бы этого ожидали, вставляя эти же символы в саму строку, тем самым форматируя её.
Но проще и лучше отформатировать строку заранее, чем пытаться подстроить под неё принт.
Префиксы
Кроме самих кавычек и апострофов в питоне существуют так называемые префиксы, которые определяют подвид строки. Их немного, я перечислю все, но остановлюсь только на тех, с которыми вы столкнётесь раньше всего и будете в последствии сталкиваться регулярно. Такими префиксами являются (в скобках указаны альтернативные виды написания:
u (U) - строка символов юникода (если вы не используете Python2, то можете смело о нём забыть),
r (R) - сырая строка;
b (B) - строка байтов;
f (F) - форматированная строка,
fr (rf, fR, rF, Rf, Fr, FR, RF) - сырая форматированная строка
br (rb, rB, bR, Br, Rb, BR, RB) - сырая байтовая строка.
Не знаю, как там у настоящих серьёзных программистов в свитерах из собственной бороды, но в простой мирской жизни вам понадобятся три вида строк: обычные, сырые и форматированные. Ну иногда и "сыроформатированные", но намного реже.
Префиксы указываются до литералов без пробелов, например:
>>> s = r'\a\n'
>>> s
'\\a\\n'
Сырые строки
Сырые строки - это строки, в которых действие экранируемых символов подавляется. Проще говоря - в этих строках всё выходит на принт в первозданном виде.
Повторю пример:
>>> s = '\a\nМама' # обычная строка
>>> print(s)
# в этом месте сработал символ переноса строки "\n"
Мама
>>> s = r'\a\nМама' # сырая строка
>>> print(s)
\\a\\nМама
Сырые строки можно использовать как минимум в трёх случаях:
- в регулярных выражениях,
- для хранения файловых путей Windows, поскольку в них содержатся обратные слэши;
- для хранения сложных математических формул в разметке LATEX.
Байтовые строки
Байтовыми строками являются строки, отражающие двоичную структуру любых данных, в том числе текста, картинок, музыки, видео и т.д. При работе с текстом такие строки возникают при кодировании строки методом encode():
>>> s = 'Mama'.encode()
>>> print(s)
b'Mama'
>>> s = "Мама"
>>> s = s.encode()
>>> print(s)
b'\xd0\x9c\xd0\xb0\xd0\xbc\xd0\xb0'
Если к вам вдруг прилетела байтовая строка, то чаще всего её можно привести в человеческий вид при помощи обратного метода decode():
>>> s = b'\xd0\x9c\xd0\xb0\xd0\xbc\xd0\xb0'
>>> s = s.decode()
>>> print(s)
Мама
Форматированные строки
Форматированная строка, это строка, способная переводить в текстовый вид содержимое других переменных. Это то, чем вы все будете пользоваться неизбежно.
Представьте себе ситуацию, когда содержимое строки должно формироваться динамически. Например, вы пришли в магазин, набрали телегу продуктов, пришли на кассу, а кассир вместо того, чтобы быстро всё посчитать и потребовать с вас нужную сумму, занимается тем, что записывает каждый товар и его стоимость в отдельные строки, потом всё это как-то суммирует и пишет руками новую строку с общей стоимостью. Ну бред же, правда?
Логично предположить, что для таких целей есть некий шаблон, который выводит на печать заранее посчитанную общую стоимость покупок. В шаблоне есть заготовленная стандартная фраза "Общая стоимость покупок - ". А что дальше? Кассир же не будет каждый раз писать туда новую сумму для каждого нового покупателя. Значения должны автоматически в неё подставляться - для этого и существуют форматированные строки.
В версии Python 3.6. наконец появилась замечательная альтернатива старому методу форматирования строк str.format() - префикс f (или в обиходе - f-строки), который делает эту процедуру приятной и лёгкой до невозможности. Но вы должны это увидеть и оценить.
Итак, до версии 3.6 нужно было делать примерно так:
# представим, что общая сумма как-то посчиталась раньше и содержится в переменной total_sum
>>> total_sum = 1000
>>> final_sum_template = 'Общая стоимость покупок - {} руб.'
>>> s = final_sum_template.format(total_sum)
>>> print(s)
Общая стоимость покупок - 1000 руб.
То есть, под значение из total_sum в шаблоне заготовлено отдельное место в виде {}. Для вставки в это место требуемого значения нужно вызвать метод .format(), куда передать переменную или непосредственно само значение - и только тогда строка будет полностью сформирована. В данном примере это выглядит не так жутко. Но представьте ситуацию, когда у вас есть куча значений, которые должны лечь в одну строку. Чтобы не потеряться, в шаблоне нужно было делать именованные аргументы, чтобы потом их можно было вызывать в .format() и передавать туда значения. Например:
>>> name = "Вася"
>>> surname = "Пупкин"
>>> age = 18
>>> template = 'Это {a}. Его фамилия {b}. Вчера ему исполнилось {c} лет.'
>>> s = template.format(a=name, b=surname, c=age)
>>> print(s)
Это Вася. Его фамилия Пупкин. Вчера ему исполнилось 18 лет.
И всё это длинно, долго, муторно... А вот всё то же самое, только в f-строке:
>>> name = "Вася"
>>> surname = "Пупкин"
>>> age = 18
>>> s = f'Это {name}. Его фамилия {surname}. Вчера ему исполнилось {age} лет.'
>>> print(s)
Это Вася. Его фамилия Пупкин. Вчера ему исполнилось 18 лет.
Как минимум, у нас минус одна строка кода - это уже классно. Нет, конечно же, можно метод .format() сразу вызывать у template, но тогда мы рискуем получить очень длинную строку кода. Вдруг предложение в шаблоне уже занимает 80 символов (кстати, в "старом" шаблоне их уже 70)? Но дело даже не в этом. Я надеюсь, вы смогли оценить то, насколько процесс формирования текста упростился в этом месте. По сути это уже готовое предложение без лишней головной боли. Здесь уже нет никаких именованных заготовок, ожидающих передачу аргументов. Здесь заготовки, в которых уже стоят нужные аргументы. Кроме того, f-строки работают заметно быстрее старого метода.
Если вам мало и я вас не убедил, то почитайте вот эту статью. Если же я вас убедил, то у вас мог возникнуть вопрос: "зачем тогда вот это вот всё про устаревший метод?" Дело в том, что его пока ещё не вывели из использования. Кроме того, некоторые библиотеки, особенно те, которые написаны задолго до версии Python 3.6. и до сих пор находятся в строю, упорно не переписываются под использование f-строк. При работе с ними возникает прямая необходимость прибегать к старому методу. Поэтому для интересующихся - ссылка на старый добрый str.format()
To be continued...
-----
Всё это, конечно же, дублируется в отдельном канале в телеге. По всем вопросам обращайтесь через Telegram.
Да, и тег моё - потому что всё написано моими руками, а не тупо понакопировано с других сайтов.
P.S. Большое спасибо всем моим подписчикам за поддержку и активность! Без вас я, возможно, не решился бы продолжать.
Ссылки на предыдущие посты:
1. Предлагаю помощь в освоении Питона
2. ПЕРВОЕ ЗНАКОМСТВО С PYTHON
3. Встроенные типы данных (их назначение, методы и стандартное поведение) - Введение
4. Встроенные типы данных (их назначение, методы и стандартное поведение) - Числа
