[МУЗЫКА] [МУЗЫКА]
[МУЗЫКА] Теперь посмотрим на практике, как работать со строками.
Конечно, мы сейчас изучим еще не все то, что умеют строки делать, но
некоторое дополнительное представление о том, что с ними можно сделать, посмотрим.
Итак, первое, что мы хотим посмотреть, это как выглядят срезы строк на практике.
Давайте создадим какую-то переменную строковую, например,
состоящую из буковок abcdef и выведем несколько срезов,
чтобы убедиться, что они работают.
Итак, нумерация в строке символов идет с нуля.
Если мы хотим вывести самый первый символ, то есть буковку a,
мы должны написать s [0].
Запустим — действительно буква a.
Если мы попытаемся взять какой-то символ, который уже не входит в строку — в нашем
случае это шестой символ, шестой при нумерации с нуля,
— то мы получим ошибку, что индекс находится за пределами строки.
Поэтому нужно проверять, если вы хотите что-то сделать,
проверять, находится ли ваш индекс еще внутри строки.
Для этого нужно пользоваться функцией len — определение длины объекта,
в нашем случае строки.
len (s) нам сообщила, что в строке шесть символов.
Нумерация у них соответственно от нуля до пяти.
Проверим отрицательные индексы, о которых мы уже говорили.
Например, −2 — это предпоследний символ строки.
Да, буковка e стоит на предпоследнем месте.
И еще, конечно же, срезы с двумя параметрами.
Вот этот срез, напоминаю, будет делать у нас все символы, стоящие на четных местах.
При нумерации с нуля буква a начальная будет иметь четный номер 0.
Например, срез с двумя параметрами 0, 2 разделяется двоеточием,
у нас выведет все символы с нулевого по второй, не включая второй.
В Python в большинстве мест правая граница не включительна.
То есть нулевой, первый, а второй уже не входит, так же,
как во многих других местах.
Если мы хотим дойти до конца, мы можем написать,
в принципе, длину строки, 6, или не писать вообще ничего.
То есть такой срез с двумя параметрами тоже будет работать, всё,
кроме нулевого символа, начиная с первого.
Отлично.
И теперь все символы, стоящие на четных местах.
С самого начала ничего не пишем, двоеточие,
до самого конца ничего не пишем и с каким шагом идем, 2.
Вот такая странная запись из: квадратной скобочки, двоеточие, двоеточие, 2.
Вот они, все символы, стоящие на четных местах.
У начальной буквы a ее позиция индекс 0 — это число четное.
Мы могли сделать что-нибудь другое,
все символы, стоящие на нечетных местах.
Со срезами, я надеюсь, более-менее понятно.
Из теоретического рассказа вот так они работают, теперь перейдем к
применению методов для строк.
Методы — это такие функции,
которые привязаны к объекту конкретному, к его содержимому.
Зачем так сделано?
Это сделано в основном для удобства.
Почему?
Потому что, например, есть стандартная функция len.
Она умеет считать длину строки, как мы сейчас убедились,
и умеет считать длину некоторых других объектов.
Тем не менее, когда вы описываете структуру какого-то объекта,
в нем будут храниться данные, и с ним будут какие-то методы, с помощью которых
вы можете на эти данные как-то влиять — писать, читать, преобразовывать.
И вот эти методы описываются рядом с описанием структуры данных.
Это очень удобно для программирования и потом удобно для использования.
Например, если у вас в нескольких совершенно разных объектах есть один и тот
же метод, считать длину, например, этого объекта, то для программиста очень удобно,
когда это называется каким-то стандартным словом, например, словом len.
То есть функция len — это, скорее, исключение.
Логично было бы, если бы это было методом.
Итак, нам интересны методы для начала find и replace.
Заведем какую-нибудь строку,
состоящую из нескольких слов.
Ее можно просто считать input, но мы будем сейчас много экспериментировать,
поэтому чтобы каждый раз не выводить ее, я сделал ее константной.
Итак, и мы хотим, например, найти в ней подстроку abd.
И вывести позицию, начиная с которой у нас встречается эта строка.
Для этого мы можем напечатать s точка — так делается вызов метода,
и вот здесь перечислены все методы, которые у нас есть.
Нам интересен метод find — вот он достаточно быстро нашелся.
В find нужно писать подстроку, которую мы ищем.
Здесь она называется sub.
substring — подстрока.
Мы хотим найти подстроку abd.
Другие параметры можно не писать, вот здесь у вас всплывают подсказки,
а именно, там есть еще два
параметра, о которых мы чуть позже поговорим.
У них есть значения по умолчанию, и поэтому их можно просто пропустить.
Строка abd встречается, начиная с девятой позиции.
Если мы будем искать строку, например, abc,
то у нас найдется первое вхождение с нулевой позиции, с самого начала строки.
Если мы будем искать что-то, чего нет, например,
abe, то у нас получится число −1.
−1 — это признак того, что подстрока вообще не нашлась в этой строке.
Соответственно, можно сделать таким образом проверку,
входит ли строка в подстроку.
Для этого достаточно поискать подстроку методом find и сравнить результат с −1.
Если там оказалась −1, то подстрока не входит.
Ну а если оказалось какое-то другое число, то, значит,
подстрока содержится в нашей строке.
Посмотрим еще одну задачу,
а именно: найти все вхождения подстроки в строку.
Например, здесь у нас подстрока abc входит дважды, и мы хотим вывести все позиции,
начиная с которых у нас входит наша подстрока.
Задача достаточно частая, когда вы пользуетесь поиском по страницам
в браузере, еще что-то, оно подсвечивает все найденные значения.
Вот примерно так это и делается.
Итак, что нам для этого понадобится?
Нам для этого понадобится переменная,
содержащая значения, начиная с какой позиции мы будем искать.
Вначале мы будем искать с нулевой позиции.
Пока s.find метод поиска
уже теперь с двумя параметрами — это подстрока, которую мы ищем, и позиция,
начиная с которой мы ищем, — у меня равно −1.
Здесь я написал лишние скобки, их можно безболезненно удалить.
Итак, пока метод не вернет −1, что мы будем делать?
Мы будем печатать эту самую позицию,
начиная с которой у нас появилась подстрока.
В принципе, можно было ее сохранить куда-нибудь,
чтобы два раза не вызывать метод, но пока и так сойдет.
И менять позицию на то,
что вернул этот метод, +1.
Зачем делается +1?
Если мы этого не сделаем,
то у нас найдется опять то же самое вхождение подстроки, как и было.
То есть мы нашли первое вхождение, начинаем искать следующее,
начиная с той же самой позиции.
Это приведет к тому, что цикл будет вечным, то есть оно будет все
время находить одно и то же значение и так на нем и остановится.
Давайте посмотрим.
Мы ожидаем увидеть два числа: ноль и примерно пять.
Ноль и пять у нас напечаталось, и после этого цикл закончился.
То есть что мы делаем?
Мы находим подстроку, позицию, начиная с которой она начинается,
выводим ее и продолжаем поиск со следующей позиции,
то есть не учитывая вот это уже найденное.
И это позволит нам найти все вхождения подстроки в строку и напечатать позиции,
начиная с которых она входит.
Как видите, мы здесь три раза вызывали метод, это не очень хорошо.
Было бы здорово вызвать один раз и сохранить это значение.
Ну а как это сделать, вы подумайте сами.
[МУЗЫКА]
[МУЗЫКА]
