Строки в Python. Работа со строками, форматирование, методы Split и Strip

Строки – это основа любого Python-приложения. Под ними подразумеваются те объекты, которые состоят из последовательности различных символов. Строки могут хранить не только текстовую информацию, но и знаки, числа, а также – непечатаемые символы. Невозможно представить программирования на Python, не используя строки.

Поэтому очень важно уметь с ними правильно работать и не только понимать базовые моменты, а иметь глубинное представление касаемо того, как происходит обработка информации, содержащейся в них. Давайте теперь более подробно поговорим о том, как это делать.

Строковые операторы

Мы уже работали с операторами + и *, поскольку в программировании они изучаются в первую очередь. Но, как правило, любые первые разделы любого руководства по программированию содержат руководства по созданию калькуляторов и других программ, использующих арифметические операторы. При этом указанные два оператора могут использоваться и при работе со строками.

Оператор сложения строк

Эта процедура в программировании называется конкатенацией. С ее помощью можно получить объединенную строку. Собственно, именно так и работает этот оператор. Он берет строку 1 и строку 2, а потом создает строку 3, которая состоит из них. Также можно объединять большее количество строк.

Приведем пример использования этого оператора.

>>> s = ‘py’

>>> t = ‘th’

>>> u = ‘on’

>>> s + t

‘pyth’

>>> s + t + u

‘python’

>>> print(‘Здравствуй, , ‘ + ‘Вселенная!’)

Здравствуй, Вселенная

Оператор умножения строк

Под умножением строк подразумевается процедура генерации одной строки, которая содержит определенное количество копий исходной строки. Например, если мы имеем строку «п», то после выполнения умножения на 4 мы получим четыре буквы «п».

То же касается любого количества символов, независимо от того, это числа, буквы или знаки. Если умножить, например, слово «слово» на 5, то на выходе получится строка «словословословословослово».

И, естественно, этот оператор может работать как с числами в качестве операнд, так и со строками. Единственное условие, что необходимо иметь хотя бы одно число и хотя бы одну строку в качестве операнд.

Также важно учесть, что Python не допускает использования операндов с отрицательным значением. В этом случае будет возвращена пустая строка.

А теперь перейдем к примеру реального использования.

>>> s = ‘ry. ’

>>> 4 * s

‘ry.ry.ry.ry.’

Оператор принадлежности подстроки

В Python есть отдельный оператор, который можно использовать исключительно со строками. Он помогает определить, является ли подстрока 1 частью большей подстроки 2. Если обнаруживается, что она является ее частью, возвращается значение True, если же нет – False.

Этот оператор звучит и пишется, как английское слово «in» (в).

>>> j = ‘programming’

>>> s in ‘I love programming’

True

Есть и полный антипод этого оператора, который работает по противоположному принципу. Если строка 1 является составной частью строки 2, то этот оператор возвращает значение «ложь», потому что он проверяет отсутствие маленькой строки в больше, и говорит, что это условие истинное исключительно если этот критерий соблюдается.

>>> ‘z’ not in ‘xyz’

False

Встроенные функции строк в Python

В арсенале Python есть несколько функций, которые могут использоваться вместе с данными типа «строки».

• chr(). Превращает целочисленное значение в символьное.

• ord(). Осуществляет противоположное действие. То есть, из символьного типа делает целочисленное значение.

• len(). Позволяет получить длину строки. 

1. Превращает любой объект в строчное значение.

Конечно, этого краткого описания недостаточно. Поэтому рассмотрим каждый из них более подробно.

Функция ord(d)

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

Например, таблицей латинских символов является ASCII. С ними программисты работают чаще всего, поэтому мы приведем два примера с тем, как работает это на практике.

>>> ord(‘a’)

97

>>> ord(‘#’)

35

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

>>> ord(‘€’)

8364

>>> ord(‘∑’)

8721

Функция chr(d)

Как уже писалось выше, эта функция выполняет полностью противоположные действия. То есть, она ищет значение в таблице символов, которое соответствует тому числу, которое программист или пользователь передаст ей в качестве аргумента.

Эта функция также может работать не только с ASCII-таблицей, но и Юникодом.

>>> chr(8364)

‘€’

>>> chr(8721)

‘∑’

Функция len(s)

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

>>> s = ‘Простая строка.’

>>> len(s)

15

Функция str(x)

С ее помощью можно получить объект в виде строки. В языке Python почти нет объектов, которые нельзя было бы выразить в строчном виде. Ну и приведем фрагмент кода, как это используется на практике.

>>> str(49.2)

‘49.2’

>>> str(3+4j)

‘(3+4j)’

>>> str(3 + 29)

’32’

>>> str(‘py’)

‘py’

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

Индексация строк

Каждая строка в Python поддерживает индексацию. Это означает, что каждому символу присвоен его определенный числовой код. По нему программа может получить доступ к ним.

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

Первый символ в строке всегда имеет индекс 0, потом – 1, и так дальше. Следовательно, индекс последнего символа строки не равен ее длине, а на единицу меньше.

Ну и, чтобы достать конкретный символ, необходимо в квадратных скобках написать его порядковый номер – 1, как на примере.

>> s = ‘foobar’

>>> s[0]

‘f’

>>> s[1]

‘o’

>>> s[3]

‘b’

>>> s[5]

‘r’

А что будет, если вызывать индекс, который больше, чем длина строки? В этом случае возникает ошибка IndexError.

Индекс также может быть отрицательным. В этом случае индексация начинается с конца строки. То есть, -1 – это последний символ в строке, а первый равен длине строки с отрицательным значением.

Давайте приведем пример отрицательного индексирования.

>>> s = ‘foobar’

>>> s[-1]

‘r’

>>> s[-2]

‘a’

>>> len(s)

6

>>> s[-len(s)] # отрицательная индексация начинается с -1

‘f’

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

Срезы строк

В Python также можно получать срезы строк. То есть, вытащить подстроку из строки по первому и последнему индексу (или только по первому или последнему).

Чтобы это было более просто понять, давайте приведем пример.

Допустим, у нас есть строка s, которая содержит значение «python». Если мы сделаем срез, начиная с элемента со вторым индексом и с пятым индексом, то вывод интерпретатора будет содержать фразу «tho».

Почему так? Дело в том, что в случае со срезами строк индексы точно так же, учитываются с нуля. Поэтому первое значение по факту является нулевым. Второе же значение должно записываться, как следующее, которое идет за тем, который нам надо получить последним.

То есть, принцип такой. Первое число должно являть собой индекс по системе нумерации Python, а второе – по стандартной порядковой системе. 

В нашем случае – первый символ считаем от 0, и для получения третьего знака необходимо написать индекс 2, а для получения последнего знака необходимо отсчет вести от единицы. 

Если этот принцип покажется нелогичным, то вот более простая формула для наглядности. Срез строки возвращает количество символов, равное второму индексу – первому.

Давайте для наглядности приведем пример.

>>> s = ‘python’

>>> s[2:5]

‘tho’

Количество символов, начиная от первого индекса считается следующим образом:

1. Интерпретатор находит символ с индексом 2 (то есть, буква p).
2. После этого от 5 отнимает 2. Получается 3.
3. И интерпретатор отсчитывает три символа, при этом первый включается. 

Если отпустить первый индекс, то он считается началом строки. 

Соответственно, если опустить второй индекс, то достаются все символы, начиная первым индексом, и до конца строки. 

>>> s = ‘python’

>>> s[:4]

‘pyth’

>>> s[0:4]

‘pyth’

>>> s = ‘python’

>>> s[2:]

‘thon’

>>> s[2:len(s)]

‘thon’

Можно также пропустить оба индекса. В этом случае мы получаем полную строку.

>>> s = ‘python’

>>> t = s[:]

>>> id(s)

59598496

>>> id(t)

59598496

>>> s is t

True

Также со срезами можно использовать отрицательные индексы. 

Шаг для среза строки

Также можно добавить третий индекс через двоеточие. Таким образом программист задает шаг для среза. То есть, через сколько символов должны отбираться символы строки. Например, если использовать строку python и использовать индексы 0:6:2, то тогда отбор осуществляется, начиная первым символом по счету и заканчивая шестым по счету. При этом каждый второй символ не учитывается. 

Теперь давайте приведем код для наглядности. 

>>> s = ‘foobar’

>>> s[0:6:2]

‘foa’

>>> s[1:6:2]

‘obr’

Если задается шаг, то первый и второй индекс также можно не использовать. Соответственно, срез начинается с самого начала или с определенного момента до самого конца, но при этом значения пропускаются в соответствии с тем индексом, который указан третьим по счету. 

Например, так.

>>> s = ‘12345’ * 5

>>> s

‘1234512345123451234512345’

>>> s[::5]

‘11111’

>>> s[4::5]

‘55555’

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

>>> s = ‘python’

>>> s[5:0:-2]

‘nhy’

В этом примере индексы 5:0:-2 означают следующее: интерпретатор начинает последним символом, не включая первый символ, но при этом делает два шага назад. 

Если первый и второй индексы пропускаются при ходе назад, значения по умолчанию считаются следующим образом. Первый индекс указывает на окончание строчки, в то время как второй – на ее начало.

Чтобы эту закономерность понять более глубоко, приведем пример.

>>> s = ‘12345’ * 5

>>> s

‘1234512345123451234512345’

>>> s[::-5]

‘55555’

А теперь задачка. Попробуйте, основываясь на полученной информации, развернуть строку так, чтобы первая буква была первой, вторая – второй. 

А теперь проверьте свой ответ. 

>>> s = ‘Если так говорит товарищ Наполеон, значит, так оно и есть.’

>>> s[::-1]

‘.ьтсе и оно кат ,тичанз ,ноелопаН щиравот тировог кат илсЕ’

Форматирование строки

Как правильно в Python указывать комбинацию строк и числовых переменных, например, при выводе в консоль? Код будет приблизительно следующим.

>>> n = 20

>>> m = 25

>>> prod = n * m

>>> print(‘Произведение’, n, ‘на’, m, ‘равно’, prod)

Произведение 20 на 25 равно 500

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

Она впервые появилась в 3,6 версии этого языка. Ее также часто называют f-string.

В целом, функционал этого инструмента просто невероятен, поэтому его надо рассматривать отдельно. 

Но мы расскажем, как его реализовывать для интерполяции переменной. Можно непосредственно ее указать в f-строковом литерале, и Python автоматически подставит подходящее значение. 

Вот так будет выглядеть код, выполняющий аналогичные действия, но с использованием f-string.

>>> n = 20

>>> m = 25

>>> prod = n * m

>>> print(f’Произведение {n} на {m} равно {prod}’)

Произведение 20 на 25 равно 500

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

Исходя из этого, сформулируем правила использования f-строк. 

1. Перед кавычками необходимо написать букву f. Так интерпретатор поймет, что необходимо использовать f-строки.
2. Введите те переменные, которые необходимо использовать, предварительно заключив их в фигурные скобки {}.

С буквой f можно использовать любые кавычки. 

Изменение строк

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

TypeError: ‘str’ object does not support item assignment

Тем не менее, в этом нет никакой проблемы. Просто технически изменение строки являет собой создание копии строки с нужными изменениями, а потом осуществление перезаписи той переменной, где была старая строка. Python это позволяет сделать в два способа. 

Есть два способа, как можно добиться этой задачи. Например, этот.

>>> s = s[:3] + ‘t’ + s[4:]

>>> s

‘pytton’

Или же можно воспользоваться методом string.replace(x,y).

Этот метод находит подстроку в первом аргументе и заменяет эту часть на содержимое второго аргумента.

>>> s = ‘python’

>>> s = s.replace(‘h’, ‘t’)

>>> s

‘pytton’

А теперь более подробно рассмотрим, что такое методы и как для чего они нужны при работе со строками.

Встроенные методы строк в Python

Мы уже знаем, что Python является объектно-ориентированным языком программирования. Следовательно, любые части информации в нем являются объектами, которые могут выполнять определенные задачи. 

Также вы знаете, что такое функция. Это часть кода, которая работает автономно и выполняет определенные задачи. 

Так вот, метод – это функция, которая ассоциируется с объектом. Она не может выполняться без связи с ним. Даже если выполняется совсем другая задача, метод знает о существовании объекта. 

Чтобы вызвать метод, как мы можем увидеть из примера выше, необходимо после названия переменной, которая является контейнером объекта, поставить точку и написать название метода с аргументами. 

В общем виде это выглядит следующим образом.

obj.foo(<args>)

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

Изменение регистра строки

Время от времени может появляться необходимость редактировать регистр строки. Это делается с помощью нескольких разных методов. Так, можно делать всю строку с большой буквы, каждое слово строки – с большой буквы, конвертировать строчные буквы в прописные и наоборот, а также выполнять ряд других задач.

Поэтому давайте рассмотрим разные инструменты работы над регистрами строк.

string.capitalize(). Позволяет сделать всю строку с большой буквы. Если в ней есть другие большие буквы, они становятся маленькими. 

На практике это работает так.

>>> s = ‘everyTHing yoU Can IMaGine is rEAl’

>>> s.capitalize()

‘Everything you can imagine is real’

Если в строке есть какие-то неалфавитные символы, они не изменяются