В 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 лет
