Часть 4 - Текстовые строки
Из предыдущих частей мы уже видел с вами строки, но в этой части поговорим о них более детально и начнем с основ.
Для того что бы создать строку в языке Python нам необходимо обернуть ее в одинарные или двойные кавычки:
"Строка"
'Строка'
Интерпретатор выводит строки в одинарных кавычках, но обрабатываются любые.
И так разберемся для чего же у нас есть возможность использовать разные кавычки для строк, основная идея в том что бы использовать те или иные кавычки в сами строках, взглянем на пример:
"Вот строка, а вот текст в 'кавычках'"
'Тоже самое, но "наоборот"'
Также допускается использование трех кавычек:
"""Строка"""
'''Строка'''
Но у них есть особенность - это работа с многострочным текстом, к примеру четверостишье Бунина:
text = """В сухом лесу стреляет длинный кнут,
В кустарнике трещат коровы,
И синие подснежники цветут,
И под ногами лист шуршит дубовый.
"""
Между делом, есть разница между выводом через интерпретатор и функцию print(). Скопируйте код выше в интерпретатор - увидите:
'В сухом лесу стреляет длинный кнут,\nВ кустарнике трещат коровы,\nИ синие подснежники цветут,\nИ под ногами лист шуршит дубовый.\n'
Заметили \n? Это символ переноса строки, о нем мы поговорим позже.
А если вывести через print():
print("В сухом", 'лесу', """стреляет""", '''длинный кнут''')
Получим: В сухом лесу стреляет длинный кнут. Функция print() добавляет пробелы между аргументами.
Наконец, нам могут понадобиться пустые строки, они создаются любым из способов:
''
""
''' '''
""" """
Функция str()
У Python есть отдельная функция которая умеет создавать строку из другого типа данных - str():
str(98.6)
# '98.6'
str(1.0e4)
# '10000.0'
str(True)
# 'True'
Escape последовательность
Как и обещал ранее, подробнее об обратном слеше \ - это escape-последовательность внутри строк. Символ, стоящий перед \, получает особое значение. Наиболее распространённая последовательность \n обозначает переход на новую строку. Благодаря ей можно создать многострочные строки из однострочных. Взглянем на пример:
text = 'Один, \nДва, \nТри.'
print(text)
# Один,
# Два,
# Три.
Кроме того в Python есть последовательность табуляции \t которая помогает выравнивать текст:
print('\tабв')
абв
print('а\tбв')
а бв
print('аб\tв')
аб в
print('абв\t')
абв
В последнем примере табуляция есть, но увидеть мы ее не сможем
Рассмотрим еще один пример последовательности, но уже для работы с кавычками \' и \":
text = "\" Раз! \" Два! \" Три! \""
'" Раз! " Два! " Три! "'
print(text)
" Раз! " Два! " Три! "
Может возникнуть ситуации когда нам понадобится обратный слеш в тексте, для этого используем просто два слеша подряд вот так:
text = "Вот \\ - слеш"
print(text)
# Вот \ - слеш
Объединение строк символом +
Почти как с числами, только наоборот: для строк можно использовать оператор сложения +, который объединяет две и более строки в одну:
'Первый ' + 'Второй'
# 'Первый Второй'
'Первый' + 'Второй'
# 'ПервыйВторой'
'Первый' + ' ' + 'Второй'
# 'Первый Второй'
Строки можно даже объединять без оператора, просто расположив их одну за другой:
"Первый " "Второй"
# 'Первый Второй'
Размножение строк
Точно также как и с оператором + мы можем использовать оператор умножения *, попробуй ввести в интерпретатор следующий код по строчно:
one = "Один " * 3 + '\n'
two = "Два " * 4 + '\n'
three = "Три."
print(one + one + two, three)
Напоминаю про приоритеты, что бы первым будет выполняться оператор умножения * так как он имеет более высокий приоритет.
Извлечение символов при помощи []
Переходим к более интересной работе со строками, для того что бы получить один символ из нашей строки необходимо указать его индекс в квадратных скобках [], напомню что в языке Python есть смещение и мы начинаем с [0]:
string = "абвгд"
string[0]
# а
string[-1]
# д
string[2]
# в
Стоит учесть следующее - если мы укажем индекс больше длины строки, то получим исключение:
[image: 1771167693695-0677e478-1037-4e6e-a20a-bd48c458253d-image.webp]
Строки являются неизменными по этому если мы попробуем по индексу задать новое значение то получим исключение:
name = 'Kirill'
name[0] = 'R'
[image: 1771167852157-d43d70bd-ae42-4f9d-b1c5-835b6b81bcbe-image.webp]
И тут на помощь приходят новые функции replace() и slice(), про них поговорим позже. А пока взглянем на код:
name = 'Kirill'
name.replace('K', 'R')
# 'Ririll'
'R' + name[1:]
# Ririll
Помните про неизменность? Интерпретатор не меняет значение у переменной, а лишь выводит результат замены.
Подстроки и разделение
Из строк можно извлекать подстроки, другими словами - часть строки. Такой проем очень похож на регулярные выражения, они кстати очень часто используются в JavaScript, хотя в Python они тоже есть, но работа с подстроками и разделением совершенно иная.
Нам необходимо задать разделение при помощи квадратных скобок, смещения подстроки в начале и смещение в конце подстроки, а также опционально можно задать шаг между ними. В подстроках будут включены символы расположенные от точки на которую мы указываем смещение начало и до точки указываемой в конце.
От теории к практике - подробнее:
[:] возвращает всю последовательность целиком (фактически срез от начала до конца)
[начало:] берет элементы, начиная с позиции начало, и до самого конца
[:конец] берет элементы от начала и до позиции конец - 1 (правая граница не включается)
[начало:конец] извлекает фрагмент от позиции начало до позиции конец - 1 (правая граница также не включается)
[начало:конец:шаг] извлекает элементы от начало до конец - 1, выбирая каждый шаг элемент (то есть берутся позиции начало, начало + шаг, начало + 2*шаг и т. д., пока не достигнем конец)
Как в предыдущих материалах я описывал смещение происходит слева на право и начинается с 0 и далее, а справа на лево -1, -2 и т.д. Если мы не укажем оператору [:] начало, по умолчанию будет использовать 0, а если не указать конец то будет использовать конец строки.
Хватит теории, сейчас поймем все на практике, напишем простую строку:
text = "привет"
print(text[:])
# привет
Если мы используем оператор [:] без аргументов, то это аналогично что начало у нас 0 и конец до конца строки.
А вот таким образом мы можем получить всем символы, начиная с 2:
text = "привет"
print(text[2:])
ивет
А теперь попробуем указать конец:
text = "привет"
print(text[2:5])
# иве
Помните про массивы списки? Представьте что наше слово привет это список - ["п","р","и","в","е","т"]
У каждого символа/буквы есть свой индекс - п=0, р=1 Так Вам будем проще ориентироваться.
Теперь попробуем задать начало с отрицанием:
text = "привет"
print(text[-2:])
# ет
Поняли что произошло? Произошел реверс, то есть наше начало пошло с конца, попробуй поэтапно начиная с -1 увеличить до -6, и в конечно итоге мы выведем наше привет.
А теперь попробуем начало задать положительным числом, а конец отрицательным:
text = "привет"
print(text[1:-1])
# риве
Мы начали с индекса 1 и закончили индексом -1 тем самым отсекли первый и последний символ.
А теперь попробуем сделать числа все отрицательными:
text = "привет"
print(text-2:-1])
# е
Напоминаю про списки и индексы, -2=е а -1=т Мы начали наше разделение с символа е и закончили на символе т - он не включается в вывод, так как является концом.
Теперь попробуем увеличить шаг:
text = "привет"
print(text::2])
# пие
А теперь мы начали с индекса 0 он же символ п и продолжаем до конца строки, но в этот раз мы перепрыгиваем через один символ так как указали последним аргументом 2.
Мы также можем объединить все:
text = "привет"
print(text[1:6:2])
# рвт
Тут мы начали с 1=р, закончили 6=т и сделал шаг между ними в 2.
Взглянем еще на такой пример:
text = "привет"
print(text[1::2])
# рвт
Получим тоже самое что и в предыдущем, но в чем же разница? А разница в том что мы выводим каждый 2 символ начиная с 1=р.
Мы также можем начинать с каждого второго символа, начиная с 0 до 6(конца):
text = "привет"
print(text[:6:2])
# пие
И на этом еще не все, мы также можем поставить начало и шаг отрицательным, взглянем:
text = "привет"
print(text[-1::-1])
# тевирп
Таким образом Python позволяет передвигаться в обратную сторону, но этот же результат мы можем получить без назначения начало -1, сделав просто шаг -1:
text = "привет"
print(text[::-1])
# тевирп
Сам по себе оператор разделения [:] лоялен к различным смещениями в отличии от поиска по индексу (списки) [].
Если мы укажем смещение меньше чем начало строки то оно обработается как 0, а если укажем смещение больше чем конец строки то обработается как -1. Взглянем на пример:
text = "привет"
print(text[-7:])
# привет
print(text[:50])
# привет
Измерение длины строк - функция len()
Материал будет добавлен по мере написания
