Строки (str) в Python: методы, функции и способы форматирования

• 14.03.2022
• 1322
• Основы Python
• Типы данных
• Строки

В Python строки являются неизменяемыми, т.е. нельзя перезаписать их значения.

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

Иначе получится ошибка:

s = 'coder'    #Создаем строку из 5 символов и присваиваем ее переменной s
s[0] = 'z'     #Присвоим нулевому индексу значение z
print(s)       #Выведем результат
#builtins.TypeError: 'str' object does not support item assignment

Строки создаются с использованием кавычек или апострофов:

s = 'coder' тоже самое что и s = "coder"
По умолчанию строки хранятся в кодировке UTF-8.

Экранирование в строках

\\ Обратный слеш (\)
\' Апостроф (')
\" Кавычка (")
\n Символ «Перевод строки»
\t Символ «Табуляция»

Примеры:

# Экранированные последовательности начинаются с символа \
print("Текст, который содержит \"текст в кавычках\"")
#Текст, который содержит "текст в кавычках"

print('Текст, который содержит \'текст в апострофах\'')
#Текст, который содержит 'текст в апострофах'

print("Если внутри кавычки другого типа, можно не 'экранировать' символы")
#Если внутри кавычки другого типа, можно не 'экранировать' символы

print('Если внутри кавычки другого типа, можно не "экранировать" символы')
#Если внутри кавычки другого типа, можно не "экранировать" символы

print("Теперь сделаем в строке табуляцию\tи\nперенос, плюс обратный слеш \\")
#Теперь сделаем в строке табуляцию и
#перенос, плюс обратный слеш \

# "Отключить" экранирование можно таким образом
print(r"В этой строке не будет табуляции\tи\nпереноса, но будет 2 обратных слеша \\")
#В этой строке не будет табуляции\tи\nпереноса, но будет 2 обратных слеша \\

Операции над строками

Конкатенация строк

Конкатенация — объединение двух строк в одну, с помощью знака +:

s = 'coder'         #Создаем строку из 5 символов и присваиваем ее переменной s
print(s + 'python') #Добавим к строке s строку 'python'
#coderpython

или так:

s = 'coder'        #Создаем строку и присваиваем ее переменной s
s2 = 'python'      #Создаем вторую строку и присваиваем ее переменной s2
s3 = s + s2        #Объединяем строки
print(s3)          #Выводим переменную, которая содержит конкатенацию строк - coderpython
#coderpython

Повторение строк

Повторение строк мы можем получить с помощью знака *:

s = 'coder'  #Создаем строку и присваиваем ее переменной s
print(s*5)   #Выводим 5 повторений строки
#codercodercodercodercoder

Логическое равенство и сравнение строк

Проверка на равенство

s = 'text'
s2 = 'text2'
print(s == s2)
#False

s = 'text'
s2 = 'text2'
print(s != s2)
#True

Проверка на вхождение подстроки в строку

s = 'coder'
print('o' in s)
#True

Индексация и срезы

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

Индексация

+---+---+---+---+---+---+
| p | y | t | h | o | n |
+---+---+---+---+---+---+
  0   1   2   3   4   5
 -6  -5  -4  -3  -2  -1

Срезы

 +---+---+---+---+---+---+
 | p | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

s = 'python'
print(s[0])  #Выведет символ с индексом 0 - 'p'
print(s[4])  #Выведет символ с индексом 4 - 'o'
print(s[-1]) #Выведет символ с индексом -1 - 'n'
print(s[-3]) #Выведет символ с индексом -3 - 'h'

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

s = 'python'
print(s[1:5])
#ytho

Формула среза выглядит следующим образом:
X[I:J]
Извлечь все содержимое строки Х, начиная со смещения I до смещения J, не включая его.

По умолчанию левая граница среза равна 0, а правая — длине строки.

s = 'python'
print(s[1:])  #Получим все после первого символа - ython
print(s[:5])  #Получим все кроме последнего символа - pytho
print(s[1:4]) #Получим символы с первого смещения до 4 (не включая его) - yth
print(s[:-1]) #Получим все кроме последнего символа - pytho

В формулу среза можно добавить шаг:
X[I:J:Step]
Извлечь все содержимое строки Х, начиная со смещения I до смещения J, не включая его, с шагом Step.

s = 'python'
print(s[0:-1:2]) #Вывести с первого по последний символ с шагом 2
#pto

Основные строковые методы

Длина строки: len(s)
Возвращает количество символов в строке:

s = 'текст'
print(len(s))
#5

Символ Unicode по номеру: chr(i)
Возвращает символа номер i из табл. Unicode:

print(chr(122)) #Выведет z

Номер символа из Unicode: ord(c)
Возвращает номер символа c из табл. Unicode:

print(ord('z')) #Выведет 122

Все буквы строки заглавными: str.upper()
Возвращает копию строки в верхнем регистре:

s = 'здесь текст'
print(s.upper())
#ЗДЕСЬ ТЕКСТ

Все буквы строки маленькие: str.lower()
Возвращает копию строки s в нижнем регистре:

s = 'ЗДЕСЬ текст'
print(s.lower())
#здесь текст

Первый символ строки заглавный: str.capitalize()
Возвращает копию строки с первым символом в верхнем регистре:

s = 'ЗДЕСЬ текст'
print(s.capitalize())
#Здесь текст

Первые символы всех слов строки с большой буквы: str.title()
Возвращает копию строки, в которой первые символы каждого слова преобразованы в верхний регистр:

s = 'ЗДЕСЬ текст'
print(s.title())
#Здесь Текст

Число вхождений в строку: str.count(sub[, start[, end]])
Возвращает число вхождений строки t в строку s (или в срез s[start:end])
start — int, индекс начала поиска, по умолчанию 0, необязательно;
end — int, конец, индекс конца поиска, по умолчанию len(str), необязательно.

s = 'ЗДЕСЬ текст'
print(s.count('т'))
#2

s = 'ЗДЕСЬ текст'
print(s.count('т', 0, 5))
#0

Поиск индекса первого элемента строки: str.find(sub[, start[, end]])
Возвращает позицию самого первого (крайнего слева) вхождения подстроки t в строку s
(или в срез s[start:end]); если подстрока t не найдена, возвращается -1.

s = 'ЗДЕСЬ текст'
print(s.find('Е'))
#2

s = 'ЗДЕСЬ текст'
print(s.find('Е', 4, 7))
#-1

s = 'ЗДЕСЬ текст'
print(s.find('Е', 4))
#-1

Поиск индекса последнего элемента строки: str.rfind(sub[, start[, end]])
Возвращает номер последнего вхождения или -1:

s = 'ЗДЕСЬ текст'
print(s.rfind('е'))
#7

Поиск индекса первого элемента строки: str.index(sub[, start[, end]])
Поиск подстроки в строке. Возвращает номер первого вхождения. Очень похож на метод find(), но здесь в случае если подстрока не найдена будет ответ ValueError.

s = 'ЗДЕСЬ текст'
print(s.index('z'))
#ValueError: substring not found

Поиск индекса последнего элемента строки: str.rindex(sub[, start[, end]])
Тоже поиск подстроки, но возвращается индекс последнего вхождения или ValueError.

s = 'ЗДЕСЬ текст'
print(s.rindex('т'))
#10

Замена символов в строке: str.replace(old, new[, count])
Все вхождения old заменены на new.
Если добавлен опциональный аргумент count, будут заменены не все вхождения old, а столько, сколько указано в count.

s = 'Текст текст'
print(s.replace('е', 'у'))
print(s.replace('е', 'у', 1))
#Тукст тукст
#Тукст текст

Преобразование строки в список: str.split(sep=None, maxsplit=-1)
Разбиение строки по разделителю. Возвращает список слов из строки.
Разделитель задается при помощи параметра sep.
Если разделитель не задан, последовательно расположенные пробелы трактуются как один разделитель.

s = 'Слово. слово. слово'
print(s.split())
print(s.split('.'))
print(s.split('. '))
#['Слово.', 'слово.', 'слово']
#['Слово', ' слово', ' слово']
#['Слово', 'слово', 'слово']

Проверка строки на наличие букв или цифр: str.isalnum()
Метод возвращает True, если в строке есть хотя бы одна буква или цифра.

s1 = 'Текст'
s2 = 'Текст123'
s3 = '#%**-()'
print(s1.isalnum())
print(s2.isalnum())
print(s3.isalnum())
#True
#True
#False

Проверка строки на буквы: str.isalpha()
Возвращает True, если все символы в строке — буквы.

s1 = 'Текст'
s2 = 'Текст123'
s3 = '#%**-()'
print(s1.isalpha())
print(s2.isalpha())
print(s3.isalpha())
#True
#False
#False

Проверка строки на цифры: str.isdigit()
Возвращает True, если все символы в строке — цифры.

s1 = 'Текст'
s2 = 'Текст123'
s3 = '#%**-()'
s4 = '123232'
print(s1.isdigit())
print(s2.isdigit())
print(s3.isdigit())
print(s4.isdigit())
#False
#False
#False
#True

Проверка строки на пробелы: str.isspace()
Возвращает True, если строка состоит из одних пробелов.

s1 = 'Текст'
s2 = 'Текст123'
s3 = '#%**-()'
s4 = ' '
print(s1.isspace())
print(s2.isspace())
print(s3.isspace())
print(s4.isspace())
#False
#False
#False
#True

Разделение строки подстрокой: str.join(iterable)
Разделяет строку заданной подстрокой.

a = '_'
print(a.join('1234567'))
#1_2_3_4_5_6_7

a = ". "
print(a.join(('Тест', 'Тест', 'Тест', 'Тест')))
#Тест. Тест. Тест. Тест

Удаление символов в начале и конце строки: str.strip([chars])
Удаляет из начала и конца строки заданный символ или набор символов.

a = " Тест "
print(a.strip())
a = " Тест "
print(a.strip(), "!")
a = "-----Тест-----"
print(a.strip("-"))
#Тест
#Тест !
#Тест

Удаление символов с конца строки: str.rstrip([chars])
Удаляет из строки последние символы или набор символов (справа).
Если не задавать аргумент chars, то будут удалены пробелы.

a = " Тест "
print(a.rstrip())
a = " Тест "
print(a.rstrip(), "!")
a = "-----Тест-----"
print(a.rstrip("-"))
#Тест
#Тест !
#-----Тест

Проверка начала строки на наличие префикса: str.startswith(prefix[, start[, end]])
Возвращает True, если строка начинается с указанного префикса, иначе возвращает False.
Необязательные аргументы start и end, указывают на начало и конец позиций проверки.

s = 'python'
print(s.startswith('y'))
print(s.startswith('p'))
print(s.startswith('t', 2))
#False
#True
#True

Проверка строки на наличие суффикса:  str.endswith(suffix[, start[, end]])
Возвращает True, если строка заканчивается указанным суффиксом, иначе возвращает False.
Необязательные аргументы start и end, указывают на начало и конец позиций проверки.

s = 'python'
print(s.endswith('y'))
print(s.endswith('n'))
print(s.endswith('o', 0, 5))
#False
#True
#True

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

Для удобного форматирования строк используется метод: str.format().

print('Мое имя {} и мне {} лет'.format('Рома', '25'))
print('Мне {1} лет и меня зовут {0}'.format('Рома', '25'))
print('Мое имя {name} и мне {age} лет'.format(name='Рома', age=25))
#Мое имя Рома и мне 25 лет
#Мне 25 лет и меня зовут Рома
#Мое имя Рома и мне 25 лет

Форматирование строк так же можно осуществлять с помощью: f-строк

name = 'Рома'
age = 25
print(f'Мое имя {name} и мне {age} лет')
#Мое имя Рома и мне 25 лет