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

Строковый тип данных — один из основных типов данных в Python. Он используется для хранения символьной информации: букв, чисел, знаков препинания и других символов. Например, отлично подходит для записи ФИО или адресов клиентов в базах данных.

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

Содержание

• Вспомним, что такое строки
• Работа со строками в Python: базовые операции

• Таблица методов и функций строк
• Примеры кода

Вспомним, что такое строки

Строковый тип данных — это последовательности символов Unicode любой длины, заключённые в одинарные, двойные или тройные кавычки. Символами могут быть буквы, числа, знаки препинания, специальные символы и так далее. Главное — чтобы их с двух сторон окружали кавычки. В Python текстовый тип данных обозначается буквами str (от англ. string — строка).

Например, создадим три переменных, используя разное число кавычек:

s1 = 'Hello, world!'
s2 = "Hello, world2"
s3 = '''Используем тройные
кавычки для вывода
многострочного текста'''

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

# Выведем на печать типы переменных s1, s2, s3
s1 = 'Hello, world!'
print(type(s1))
s2 = "Hello, world2"
print(type(s2))
s3 = '''Используем тройные
кавычки для вывода
многострочного текста'''
print(type(s3))

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

<class 'str'>
<class 'str'>
<class 'str'>

Да. Все три переменные имеют тип str, то есть являются строковыми.

Разберём подробнее, какие операции можно производить над строками, и поговорим про функции и методы этого типа данных.

Работа со строками в Python: базовые операции

Перед тем как перейти к конкретным действиям, напомним что строки в Python — неизменяемый тип данных. Это означает, что строковую переменную нельзя изменить с помощью операторов, функций и методов. Если мы хотим сохранить результат изменения существующей строки, то надо создать новую переменную.

Начнём! Разберём основные виды операций над строками. Запускайте любимый редактор кода и повторяйте действия за нами.

Сложение (конкатенация)

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

Например:

s1 = 'Skill'
s2 = 'box'
s3 = s1 + s2
print(s3)

Результат:

Skillbox

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

s3 = s2 + s1
print(s3)

Результат

boxSkill

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

Вычитание

Настоящей операции вычитания строк, по аналогии с числами, в Python не существует — мы не сможем отнять символы из строки с помощью операции −. Но можно использовать метод replace().

Он создаёт новую строку путём замены частей исходной строки. Лучше всего показать это на примере. Попробуем удалить часть слова, заменив её пустой строкой:

# Вычтем часть "box" из строки "Skillbox"

s1 = 'Skillbox'
s2 = 'box'
s3 = s1.replace(s2, '') # Передаём методу два аргумента — то, что хотим убрать из строки, и то, на что планируем заменить удалённый фрагмент
print(s3)

В результате получим:

Skill

Дублирование (умножение)

В языке Python строки можно умножать на целые числа. Операция работает просто — повторяет содержимое переменной указанное количество раз. Например:

st = 'ab ' * 6
print(st)

В результате получим:

ab ab ab ab ab ab

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

st = 35 * '*'
print(st)

Результат:

***********************************

Принадлежность строки

Иногда разработчикам приходится проверять, есть ли в составе строки определённый фрагмент, который называют подстрокой. Например, мы хотим подтвердить наличие пользователя с определённым именем в нашей базе данных, где имя хранится вместе с фамилией — Иван Иванов. Строка здесь — это Иван Иванов, а нужная нам подстрока — Иван. Как это проверить? Воспользуемся проверкой принадлежности строки.

Для этого воспользуемся оператором in. Он возвращает True, если одна подстрока входит в состав строки, в противном случае возвращает False.

Например:

s1 = 'Иван Иванов'
s2 = 'Иван'

if s2 in s1: # Проверяем, есть ли «содержимое» строки s2 в s1 
    print('Пользователь Иван есть в нашей базе данных')
else:
    print('Пользователь Иван в базе данных отсутствует')

С помощью оператора in можно упростить поиск строк в разных переменных. Например, нам необходимо проверить наличие символа в четырёх строковых переменных. Мы можем написать такой код:

st = 'a'

if st == 'a' or  st == 'b' or  st == 'c' or  st == 'd':
    print('YES')

Выглядит сложно. Упростим его, объединив содержимое переменных в одну строку:

st = 'a'

if st in 'abcd':
    print('YES')

Не забывайте, что регистр символов имеет значение. Например, буквы «A» и «a» компьютер воспринимает как разные.

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

Это количество содержащихся в строке символов, включая пробелы. Чтобы определить длину строки, используется функция len() (от англ. length — длина). Например:

ln = len('Skillbox')
print(ln)
s1 = 'skill'
print(len(s1))

Результат выполнения:

8
5

Доступ по индексу

Чтобы выделить один символ строки, используют индексацию. Нумерация символов начинается с нуля и заканчивается длиной строки −1.

Например, посмотрим на индексацию строковой переменной, значение которой равно 'Skillbox':

Мы видим, что нумерация начинается с нуля, а заканчивается числом 7, то есть равна количеству символов в строке с вычетом единицы.

Чтобы распечатать символы по их индексу, его необходимо указать в квадратных скобках. Вот так:

st = 'Skillbox'
print(st[0])
print(st[1])
print(st[2])
print(st[3])
print(st[4])
print(st[5])
print(st[6])
print(st[7])

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

S
k
i
l
l
b
o
x

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

st = 'Skillbox'
print(st[8])

Результат выполнения:

IndexError: string index out of range

Индексацию также можно начинать с конца строки. В таком случае последний символ будет иметь индекс, равный −1, а индекс первого символа будет равен длине строки со знаком −. Посмотрим на такую индексацию на нашем примере:

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

st = 'Skillbox'
print(st[−9])

В результате получим:

IndexError: string index out of range

Срез строки

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

st[начальный индекс:конечный индекс]

Срез извлекает подстроку, начиная c начального индекса (включительно) и заканчивая последним индексом (не включая его), то есть символ с конечным индексом в срез не входит. Не забывайте, что индексация строки начинается с 0.

Например:

st = 'Skillbox'
print(st[0:3])
print(st[2:5])
print(st[4:7])

Результат выполнения кода:

Ski
ill
lbo

Если не указывать начальный индекс, то срез берётся с начала строки. Если не указывать конечный — то до конца строки. Если опустить оба параметра, то срез возвращает всю строку. Попробуем несколько вариантов:

st = 'Skillbox'
print(st[:6]) # Срез с начала строки
print(st[5:]) # Срез до конца строки
print(st[:])  # Целая строка

Получаем срезы:

Skillb
box
Skillbox

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

Например:

st = 'Skillbox'
print(st[:10])

Получим срез:

Skillbox

Срез, в котором начальный индекс больше или равен конечному, возвращает пустую строку, например:

st = 'Skillbox'
print(st[2:2]) # Конечный индекс равен начальному
print(st[5:3]) # Конечный индекс меньше начального

Этот код вернёт пустые строки, но ошибки не будет. Можете проверить в своём редакторе кода.

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

Например, программный код:

st = 'Skillbox'
print(st[−7:−4]) # Срез с отрицательными индексами
print(st[−4:−4]) # Начальный индекс равен конечному
print(st[−4:]) # Срез до конца строки
print(st[:−3]) # Срез с начала строки
print(st[−7:4]) # Срез с положительным и отрицательным индексами

Полученный результат:

kil # Всё сработало как надо
# Возврат пустой строки, так как начальный индекс равен конечному
lbox # Всё сработало как надо
Skill # Всё сработало как надо
kil # Всё сработало как надо

Шаг извлечения среза

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

Например, если мы возьмём срез st[0:6:2] строки st = 'Python', то получим строку 'Pto':

Рассмотрим пример с отрицательными индексами. Например, срез st[-6:-1:2] строки st = 'Python' тоже будет равен 'Pto':

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

Например, срез st[-3:-7:-2] возвращает строку 'hy'. Как видим, правая граница здесь не включается в срез.

Отрицательный шаг можно использовать с положительными индексами, например:

st = 'Skillbox'
print(st[6:1:−2])

Результат выполнения:

oli

Чтобы вывести символы строки в обратном порядке, удобно использовать срез [::−1], например:

st = 'шорох'
print(st[::−1])  

st = 'город'
print(st[::−1])  

st = 'топор'
print(st[::−1])  

В результате выполнения получим:

хорош
дорог
ропот

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

Таблица методов и функций строк

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

Примеры кода

Рассмотрим несколько практических примеров использования функций и методов.

Методы поиска подстроки

К ним относятся два метода: S.find(str, [start], [end]) и S.rfind(str, [start], [end]).

s = 'SkillboxSkillbox'
str = 'box'

print(s.find(str))  # Возвращает индекс первого совпавшего значения подстроки
print(s.rfind(str)) # Возвращает индекс последнего совпавшего значения подстроки

Результат выполнения кода:

5
13

Если подстроки в строке нет, Python возвращает −1:

S = 'SkillboxSkillbox'
print(S.rfind('abc'))

Результат:

-1

Поиск в срезе:

S = 'Skillbox'
str = 'box'

print(S.find(str,0,7))

Результат:

-1

Здесь подстрока str ищется в срезе S[0:7]. Так как правая граница в срез не включается, Python не находит подстроку и выдаёт −1.

Методы преобразования символов строки в верхний и нижний регистры

Для преобразования используются два метода:

• S.upper() — преобразование всех символов строки S в верхний регистр.
• S.lower() — преобразование всех символов строки S в нижний регистр.

И тот и другой метод возвращают новую строку, а исходная остаётся прежней.

Например:

S = 'Skillbox 23'

print(S.upper())  # Переводит все символы в верхний регистр
print(S.lower())  # Переводит все символы в нижний регистр
print(S) # Проверяем значение исходной строки

В результате получим:

SKILLBOX 23
skillbox 23
Skillbox 23

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

Метод разбиения строки по разделителю

Для разбиения строки по разделителю используется метод S.split([разделитель [, maxsplit]]). Посмотрим на него в коде:

S = 'Cat, Dog,Hamster   Rabbit, Pig'

print(S.split())  # Разделитель не задан. Метод разбивает строку по пробельным символам — пробелу и знаку табуляции
print(S.split(',')) # Разбивает строку по заданному разделителю ','
print(S.split(',', 2)) # Задаёт максимальное количество разбиений, равное 3

Результат:

['Cat,', 'Dog,Hamster', 'Rabbit,', 'Pig']
['Cat', ' Dog', 'Hamster   Rabbit', ' Pig']
['Cat', ' Dog', 'Hamster   Rabbit, Pig']

Методы rjust() и ljust():

S = 'Hi!'
print(S.rjust(10,'*')) # Увеличивает длину строки до 10 и заполняет пробелы слева символами '*'
print(S.ljust(10,'*')) # Увеличивает длину строки до 10 и заполняет пробелы справа символами '*'

В результате выполнения получим:

*******Hi!
Hi!*******

Мы рассмотрели понятия строки и текстового типа данных в Python. Подробно со всеми методами и функциями строк можно ознакомиться в документации.