Работа со строками в Python

Строки в Python могут задаваться либо через одинарные, либо через двойные кавычки. Для тестирования того, как работают строки в Python, давайте создадим новый проект в PyCharm (для разработки на Python я использую популярную среду разработки PyCharm от компании JetBrains. Если среду разработки PyCharm Вы ещё не установили, самое время это сделать для проверки последующих примеров из статьи). Имя проекта и директорию для него можно выбрать на Ваше усмотрение, PyCharm создаст для Вас модуль по умолчанию с именем main.py. Там, где начинается основная логика программы, попробуем поэкспериментировать со строками.

Вариант вывода строки с помощью одинарных кавычек:

if __name__ == '__main__':
    print('Я строка')

Вариант с двойными кавычками также поддерживается в Python:

if __name__ == '__main__':    
    print("Я тоже строка!")

Попробуйте запустить оба варианта. На экране консоли Вы увидите соответствующий вывод:

Я строка

Я тоже строка!

Если Вам нужно внутри строки, которая задана через одинарные или двойные кавычки, также использовать одинарную или двойную кавычку (или несколько таких), то используйте для этой цели символ экранирования - "обратный слеш" \

Вот как это может выглядеть в Вашей программе на Python:

if __name__ == '__main__':
    print('Я строка, а внутри есть \'подстрока\', обособленная также одинарными кавычками, как и я сама')

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

if __name__ == '__main__':
    print("Не важно, как задана строка - через 'одинарные' или \"двойные\" кавычки. Python умеет экранировать любые "
          "кавычки внутри строки!") 

Запустите программу с каждым из вариантов. Результат должен быть следующим:

Я строка, а внутри есть 'подстрока', обособленная также одинарными кавычками, как и я сама

Не важно, как задана строка - через 'одинарные' или "двойные" кавычки. Python умеет экранировать любые кавычки внутри строки!

Попробуйте вывести на экран также такой вариант строки:

if __name__ == '__main__':
    print('C:\some\path\in\my\system\some\name')

Результат может показаться несколько неожиданным. На экране консоли Вы увидите следующее:

C:\some\path\in\my\system\some
ame

Почему наш текст C:\some\path\in\my\system\some\name не вывелся в одной строке? Куда делась буква "n" и почему фраза "ame" вывелась лишь на следующей строке?

Всё дело в том, что с помощью спецсимвола "обратный слеш" ( \ ) экранируются не только сами одинарные и двойные кавычки, но и специальные последовательности символов. В частности, последовательность \n означает "перенос на следующую строку". Именно поэтому сама буква "n" не вывелась на экран, а произошёл перенос на новую строку, и вывелась оставшаяся часть строки "ame". В PyCharm в подобных случаях Вы заметите специфичную синтаксическую подсветку оранжевым цветом. Чтобы отменить режим экранирования для строки и считать все встречающиеся в ней символы "обратного слеша" обычными, а не спецсимволами, укажите перед строкой букву r (r - от английской фразы "raw string", т.е. "сырая строка"):

if __name__ == '__main__':
    print(r'C:\some\path\in\my\system\some\name')

Теперь если запустить Python-скрипт, на экран выведется ровно то, что содержится в строке, без всяких переносов:

C:\some\path\in\my\system\some\name

В Python существует очень удобная возможность определять и выводить на экран многострочный текст. Для этого его необходимо заключить между трижды повторяющимися двойными или одинарными кавычками, т.е. """Ваш_многострочный_текст""" или '''Ваш_многострочный_текст'''. Смотрим пример:

if __name__ == '__main__':
    print("""Это пример
    текста, занимающего
    несколько строк
    """)

На экране будет выведено:

Это пример
      текста, занимающего
      несколько строк

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

Такой же эффект достигается, если заключить Ваш многострочный текст в тройные одинарные кавычки:

if __name__ == '__main__':
    print('''Это
    ещё один пример
    многострочного текста
    ''')

На экране будет выведено:

Это
     ещё один пример
     многострочного текста

Строки также можно сцеплять, или конкатенировать, с помощью оператора +

Ниже пример:

if __name__ == '__main__':
    print('Это' + ' пример' + " сцепления " + 'строк')

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

Это пример сцепления строк

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

if __name__ == '__main__':
    print('Это' ' пример' ' автоматической сцепки' ' строковых литералов')

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

if __name__ == '__main__':
    s1 = ' ещё один'
    s2 = ', но уже с переменными, где необходим оператор +'
    print('Это' + s1 + ' пример' ' автоматической сцепки' ' строковых литералов' + s2)

При запуске скрипта с примером выше на экран будет выведено:

Это ещё один пример автоматической сцепки строковых литералов, но уже с переменными, где необходим оператор +

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

if __name__ == '__main__':
    s = ('Строка, которую '
         'можно удобно перенести')
    print(s)

На экран при запуске этого скрипта будет выведен следующий текст, без всяких переносов:

Строка, которую можно удобно перенести

К строкам можно применять индексирование, чтобы получить определённую часть строки. Индекс начинается с 0. Давайте посмотрим, как это работает:

if __name__ == '__main__':
    some_string = 'Некоторая строка'
    print(some_string[0])

Если запустить этот скрипт, на экран будет выведена первая буква "Н" из строки.

Можно использовать и отрицательные целые числа в качестве индекса. Для получения последнего символа строки можно использовать -1, для предпоследнего -2 и так далее.

if __name__ == '__main__':
    some_string = 'Некоторая строка'
    print(some_string[-1])
    print(some_string[-2])

При запуске скрипта на экране появятся буквы "а" и "к", каждая на отдельной строке.

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

Смотрим пример:

if __name__ == '__main__':
    some_string = 'Некоторая строка'
    print(some_string[0:9])

На экран будет выведена подстрока "Некоторая". Запомните, что при нарезке первый индекс всегда учитывается, второй - нет. В данном примере в 9-й позиции стоит символ пробела, как раз он и не был учтён при изъятии подстроки с 0-го по 9-й индекс.

Индексы для выполнения нарезки имеют полезные значения по умолчанию. Для первого индекса нарезки - это всегда 0, для второго - длина самой строки, для которой выполняется нарезка. Давайте посмотрим на примере, как это работает:

if __name__ == '__main__':
    some_string = 'Некоторая строка'
    print(some_string[:9])
    print(some_string[10:])

На экран будет выведено:

Некоторая

строка

Важной особенностью строк в Python является то, что они неизменные (англ. "immutable"). Поэтому присваивание значения для какой-то индексированной позиции приведёт к ошибке:

if __name__ == '__main__':
    some_string = 'Некоторая строка'
    some_string[2] = '?'

Такой скрипт при выполнении выведет на экран ошибку вида:

Traceback (most recent call last):
 File "C:/Users/компьютер/PycharmProjects/allineed_samples/main.py", line 22, in <module>
 some_string[2] = '?'
TypeError: 'str' object does not support item assignment

В заключение, давайте посмотрим, как вычисляется длина строки. Для этого используется встроенная (англ. "built-in") функция Python c названием len(). Работать с ней проще простого:

if __name__ == '__main__':
    s = ('Строка, которую '
         'можно удобно перенести')
    print("Длина строки '" + s + "' равна ")
    print(len(s))

Вывод скрипта на консоль при запуске:

Длина строки 'Строка, которую можно удобно перенести' равна 
38

Как видим, встроенная функция len() посчитала за нас количество символов в строке s. Есть один момент, на который хотел бы обратить внимание: функция len() возвращает целое число, соответствующее длине строки, поэтому при попытке сцепить её со строкой возникнет ошибка. Например, если скрипт переписать так:

if __name__ == '__main__':
    s = ('Строка, которую '
         'можно удобно перенести')
    print("Длина строки '" + s + "' равна " + len(s))

то при его запуске нас ждёт ошибка:

Traceback (most recent call last):
 File "C:/Users/компьютер/PycharmProjects/allineed_samples/main.py", line 25, in <module>
 print("Длина строки '" + s + "' равна " + len(s))
TypeError: can only concatenate str (not "int") to str

В последней строке ошибки говорится как раз то, что "можно сконкатенировать (т.е. сцепить)  только строку со строкой, но не строку со значением типа int".

Из этой ситуации можно легко выйти, используя другую встроенную функцию Python с названием str(). Она преобразует целое число к строке и уже эту строку можно сцепить с нашей исходной строкой:

if __name__ == '__main__':
    s = ('Строка, которую '
         'можно удобно перенести')
    print("Длина строки '" + s + "' равна " + str(len(s)))

На этот раз запуск скрипта выведет ожидаемый результат:

Длина строки 'Строка, которую можно удобно перенести' равна 38

Пожалуй, всё. На этом обзор основных возможностей по работе со строками в Python завершён. Попробуйте попрактиковаться на приведённых в статье примерах и поделиться результатами и Вашими мыслями в комментариях к статье.