Строки в 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’

Если в строке есть какие-то неалфавитные символы, они не изменяются. Это, в принципе, и логично.

string.lower(). С помощью этого метода можно полностью убрать большие буквы из текста. То есть, весь текст будет написан маленькими буквами.

>>> ‘everyTHing yoU Can IMaGine is rEAl’.lower()

‘everything you can imagine is real’

string.swapcase(). Осуществляет инверсию регистров. Простыми словами, большие буквы становятся маленькими, а маленькие – большими.

>>> ‘everyTHing yoU Can IMaGine is rEAl’.swapcase()

‘EVERYthING YOu cAN imAgINE IS ReaL’

string.title. Делает каждое слово написанным с большой буквы.

>>> ‘the sun also rises’.title()

‘The Sun Also Rises’

Он просто не думает о том, какое слово важное, не смотрит на апострофы, имена или аббревиатуры. Просто все слова, которые есть в строке, делает с большой буквы. Это же накладывает определенные ограничения на этот метод.

string.upper(). Выполняет противоположную функцию строки string.lower. То есть, все буквы делает большими.

>>> ‘follow us @PYTHON’.upper()

‘FOLLOW US @PYTHON’

Найти и заменить подстроку в тексте

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

Методы, которые относятся к этой группе, в целом, имеют аргументы <start> и <end>, которые являются необязательными. С их помощью программист задает диапазон поиска. То есть, с какого символа начинать поиск и когда его прекращать.

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

string.count(<sub>[, <start>[, <end>]]. Функция, предназначенная для определения количества раз, которые эта подстрока входит в большую строку. 

Значение, возвращаемое этой функцией – количество точных вхождений подстроки, указанной в качестве аргумента <sub>.

>>> ‘foo goo moo’.count(‘oo’)

3

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

string.endswith(<suffix>[, <start>[, <end>]]. Этот метод является неким аналогом оператора in, поскольку проверяет, является ли эта подстрока частью большой строки. Тем не менее, он отличается, поскольку проверяет еще одно условие – заканчивается ли строка 1 на подстроку 2? Если оба условия являются истинными, возвращается значение True. Если же они ложные, то тогда получается значение false.

>>> ‘python’.endswith(‘on’)

True

>>> ‘python’.endswith(‘or’)

False

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

string.find(<sub>[, <start>[, <end>]]). Этот оператор выполняет поиск подстроки в рамках того текста, который есть в заданной переменной. 

Приведем пример кода, который демонстрирует работу этой функции.

>>> ‘Follow Us @Python’.find(‘Us’)

7

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

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

string.index(<sub>[, <start>[, <end>]]). Этот метод такой же самый, как и find(), только он выдает ошибку в случае ненахождения необходимого вхождения.

>>> ‘Follow Us @Python’.index(‘you’)

Traceback (most recent call last):

  File «<pyshell#0>», line 1, in <module>

    ‘Follow Us @Python’.index(‘you’)

ValueError: substring not found

string.rfind(<sub>[, <start>[, <end>]]). Функция, аналогичная find(), за исключением того, что поиск подстроки осуществляет, начиная с конца. Точно так же, как и свой сородич, этот метод возвращает вхождение подстроки, но только последнее, соответствующее началу значения, указанного в качестве первого аргумента.

>>> ‘Follow Us @Python’.rfind(‘o’)

15

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

string.rindex(<sub>[, <start>[, <end>]]). Аналог функции index, только выполненный в противоположном направлении. То есть, поиск начинается с конца. И точно так же, как оригинальный метод index(), в случае отсутствия вхождения, возвращает ошибку ValueError.

string.startswith(<prefix>[, <start>[, <end>]]). Проверяет наличие вхождения подстроки в рамках большой строки. Если оно обнаруживается, проверяет второе условие: находится ли она в самом ее начале. Если оба критерия оказываются истинными, то также возвращает значение True.

>>> ‘Follow Us @Python’.startswith(‘Fol’)

True

>>> ‘Follow Us @Python’.startswith(‘Go’)

False

Классификация строк

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

string.isalnum(). Возвращает значение True, если в состав строки входят не только буквы, но и цифры. В ином случае она передает значение False.

>>> ‘abc123’.isalnum()

True

string.isalpha(). Если в состав строки входят исключительно буквы, то она возвращает значение True. В ином же случае возвращает «Ложь».

string.isdigit(). Эта функция не возвращает значение True в случае, если в состав строки входит хотя бы одна буква.

>>> ‘123’.isdigit()

True

>>> ‘123abc’.isdigit()

False

string.isidentifier() – выполняет проверку, можно ли использовать эту строку в качестве идентификатора Python.

string.islower() – проверяет, являются ли все буквы маленькими.

string.isprintable() – проверяет, есть ли непечатаемые символы. Если есть хотя бы один специальный символ, возвращается значение False.

string.isspace() – проверяет, содержит ли строка знаки табуляции, пробелы, новой строки. В этом случае возвращает истину. Поддерживает некоторые другие пробельные символы.

string.istitle(). Этот метод проверяет, входят ли заглавные буквы в строки. Вернее, начинаются ли с заглавной буквы каждые слова. Если да, то возвращается значение True. Если же хотя бы одно слово начинается с маленькой буквы, возвращается значение False. 

string.isupper(). Выполняет проверку на предмет того, являются ли все буквы в строке заглавными. Если да, то возвращает значение True. Если нет – False.

Выравнивание строк, отступы

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

Рассмотрим более подробно эти методы.

string.center(<width>[, <fill>]). Делает строку расположенной по центру и возвращает соответствующий результат. По стандарту отступ являет собой пробел из таблицы ASCII. 

>>> ‘py’.center(10)

‘    py    ‘

Также можно выбрать другой заполнитель. Для этого используется необязательный аргумент <fill>. 

>>> ‘py’.center(10, ‘-‘)

‘—-py—-‘

Задача: что, если используемый аргумент функции будет больше ширины строки? В этом случае изменений строки не будет. 

string.expandtabs(tabsize=8). Этот метод достает в строке табуляции, которые замещает пробелами. 

Также есть набор других методов, которые стоит рассматривать отдельно. Например, string.strip() осуществляет удаление тех символов, которые находятся с краю. Или же та, которая заполняет нулями строку, которая содержит числа.

Методы преобразования строки в список

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

string.join(<iterable>). С помощью этого метода список можно сделать строкой. Он получает строку, в состав которой входят элементы списка. Интерпретатор объединяет их, а потом упаковывает это в строковый объект, который можно присвоить другой переменной и использовать, как обычную строку.

>>> ‘, ‘.join([‘foo’, ‘bar’, ‘baz’, ‘qux’])

‘foo, bar, baz, qux’

string.partition(<sep>). Он берет разделитель, и на его основе осуществляет разделение строки. Например, так.

>>> ‘foo.bar’.partition(‘.’)

(‘foo’, ‘.’, ‘bar’)

>>> ‘foo@@bar@@baz’.partition(‘@@’)

(‘foo’, ‘@@’, ‘bar@@baz’)

Метод возвращает объект из трех частей.

string.rsplit(sep=None, maxsplit=-1). Осуществляет разделение строки на список из подстрок.

>>> ‘foo bar baz qux’.rsplit()

[‘foo’, ‘bar’, ‘baz’, ‘qux’]

>>> ‘foo\n\tbar   baz\r\fqux’.rsplit()

[‘foo’, ‘bar’, ‘baz’, ‘qux’]

Мы разобрали самые распространенные операторы и методы, позволяющие работать с объектами. На самом же деле, их намного больше. Просто невозможно в рамках одной статьи рассмотреть все возможные нюансы их использования.