Индексация строк
Доступ к символам в строках основан на операции индексирования – после строки или имени переменной, ссылающейся на строку, в квадратных скобках указываются номера позиций необходимых символов.
Так же следует понимать, что этот самый доступ, основан на смещении, т.е. расстоянии символов от левого или правого края строки. Данное расстояние измеряется целыми числами и по сути определяет номер позиции символов в строке – их индекс. Подвох заключается в словосочетании «измеряется целыми числами«, а это означает, что индекс может быть как положительным так и отрицательным: положительные индексы – это отсчет от левого края, а отрицательные – от правого. Причем отсчет символов от левого края начинается с \(0\), а с правого начинается с \(-1\) (минус единицы).
В самом простом случае можно извлеч один произвольный символ:
Так же мы можем извлеч срез – последовательность символов внутри исходной строки, которую еще иногда называют подстрокой:
А еще мы можем извлекать символы из строки или среза с указанным шагом:
Как видите, с одной стороны – все вроде бы просто, но с другой – особенно глядя на последние примеры, становится понятно, что какие-то сложности все-таки есть. Давайте разберемся по порядку.
Извлечение символов — S[i]
Извлечение одного символа из строки – это, действительно, самый простой случай. Давайте снова рассмотрим строку:
Что бы извлеч символы ‘ S ‘, ‘ R ‘ и ‘ G ‘ мы можем выполнить следующие простые операции:
Но так как мы уже знаем, что индексы могут быть отрицательными, т.е. отсчитываться от конца строки, то для извлечения тех же символов мы можем выполнить и такие операции:
Отрицательные и положительные индексы символов могут быть выражены через длину строки:
Визуально отображение индексов на символы строки выглядит вот так:
Если указать индекс, который выходит за пределы строки, то это приведет к ошибке:
Отсутствие индекса, так же считается ошибкой.
Извлечение срезов — S[i:j]
Извлечение срезов строк выполняется по двум индексам, которые разделяются двоеточием:
Обратите внимание на то, что срез начинается с символа, индекс которого указан первым, а заканчивается перед символом, индекс которого указан вторым:
Тех же результатов можно добиться если указывать отрицательные индексы:
Во всех предыдущих примерах первый индекс всегда был меньше второго, но если вдруг окажется наоборот, то это не приведет к ошибке, а возвратит пустую строку:
И даже, если индексы окажутся равны, мы все равно увидим пустую строку вместо сообщения об ошибке:
Появится ли сообщение об ошибке если не указать индексы вообще? Нет, вместо этого мы увидим всю строку целиком:
Такое поведение связано с тем, что индексы начала и конца среза имеют значения по умолчанию: начало – всегда \(0\), конец – всегда len(s) . Так что команда s[:] является эквивалентной команде s[0:len(s)] . Наличие таких предустановленных значений является весьма удобным, если мы хотим извлекать срезы от начала строки до указанного символа, или от некоторого символа до конца строки:
Снова, обратите внимание на то, что если срез извлекается от начала строки до указанного символа, то сам указанный символ в разрез не включается. А если срез извлекается от указанного символа до конца строки, то этот символ будет включен в начало среза. Такое поведение гарантирует что конкатенация двух таких срезов будет равна исходной строке:
Операция извлечения среза допускает указание индексов, выходящих за пределы строки:
Извлечение срезов с заданным шагом — S[i:j:k]
Что бы извлечь символы из среза с заданным шагом (их еще называют разреженные срезы), необходимо указать значение шага через двоеточие после операции извлечения среза:
Очевидно, что тех же результатов мы добьемся если не будем менять значения шага, а значения индексов начала и конца среза поменяем на отрицательные:
Визуально все это можно представить вот так:
В возвращаемой строке оказываются только те символы исходной строки, которые обозначены оранжевым цветом. Символы, обозначенные зеленым цветом, входят в состав указанного среза, но не соответствуют значению шага, поэтому мы и не видим их в результирующей строке.
Величина шага имеет значение по умолчанию, равное \(1\) – это соответствует извлечению всех элементов подряд. А учитывая, что начало среза и его конец так же имеют установленные по умолчанию значения, равные \(0\) и len(s) , то мы можем вообще ничего не указывать (кроме двух двоеточий, разумеется):
Может ли значение шага быть отрицательным? Да:
По сути, знак указанного числа в шаге указывает направление в котором выполняется извлечение символов из среза. Значение \(-1\) означает, что нужно извлеч каждый последующий символ, двигаясь от правого края к левому. А значение \(-2\) — извлеч каждый второй символ, так же двигаясь от конца к началу строки.
Давайте выполним несколько примеров и посмотрим, как это можно наглядно представить:
Помните, мы говорили о том, что индекс начала среза должен быть меньше чем индекс его конца? На самом деле такая необходимость связана с направлением в котором извлекаются символы среза. По умолчанию, значение шага равняется \(1\) — это соответствует изъятию каждого символа в направлении от начала строки до ее конца. Именно поэтому мы ранее получали пустую строку, когда указывали левый индекс больше чем правый:
Глядя на пустую строку, котору вернул интерпретатор и картинку становится понятно, что что-то не так. Мы ясно видим, что извлечение начинается с индекса под номером \(10\), т.е. с символа » K » и даже несмотря на то, что извлечение происходит слева направо (так как по умолчанию шаг равен \(1\)), символ » K » просто обязан попасть в результирующую строку. Но его там нет.
Настало время осознать, что индексы символов в строке и их смещения – это не одно и то же. Работая с последовательностями нам проще всего воспринимать индексы символов (номера их позиций) чем их смещений. Я даже уверен что после того как вы разберетесь со смещениями, вы все равно будете представлять себе индексы.
Индексы и смещения символов
Что ж давайте сделаем небольшое отступление и попробуем разобраться. Вот уже знакомая нам строка:
А вот так мы отображаем индексы на символы:
Почему мы так делаем? Потому что это удобнее чем смещения:
Говоря о смещениях, мы подразумеваем левую границу символов (левую сторону квадратов в которых они изображены на рисунках). Так, например, смещение символа » S » относительно левого края строки равно \(0\) т.е. он вообще не смещен, поэтому операция s[0] его и возвращает. А смещение символа » G » относительно правого края равно \(-1\), поэтому операция s[-1] возвращает » G «. На этом же принципе основаны и все другие операции индексирования, будь-то срезы или срезы с заданным шагом.
Даже поняв, что такое смещения символов, вы все равно будете опираться на их индексы. Глазами, указателем мыши, пальцем, вы все равно будете отсчитывать непосредственно сами символы, а не их левые границы. Просто потому, что это удобно. Просто потому, что в подавляющем большинстве это прекрасно работает и не вызывает никаких проблем.
Теперь, когда мы знаем, что такое смещения, нам гораздо проще понять почему операция s[4:2:1] возвращает пустую строку вместо символа » I «:
Глядя на эту картинку, нам начинает казаться, что символ » I » с индексом \(4\) должен попасть в результирующую строку. Но интерпретатор Python ориентируется не по индексам, а смещениям и с его точки зрения все выглядит вот так:
Так как символ » I » располагается перед смещением с номером \(4\), а отсчет ведется именно от смещений, то и в результирующей строке его быть не должно.
Понимание того, что строки индексируются именно по смещениям символов, проливает свет на многие нюансы. Например, взятие среза от некоторого символа до конца строки:
Если посмотреть на эту операцию в контексте индексов, то можно утверждать, что мы указываем элемент с индексом \(6\), которого на самом деле не существует, но перед которым извлечение символов из строки должно остановиться.
Если же посмотреть на эту операцию в контексте смещений, то говорить о каких-то не существующих вещах уже не придется. Все эти смещения существуют и именно с ними работает интерпретатор Python.
Скорее всего, у вас возник вопрос по поводу того как работает операция s[::-1] , ведь ее левый индекс по умолчанию равен \(0\), а правый – len(s) , но даже не смотря на то, что извлечение символов должно выполняться справа налево, т.е. мы, по идее, должны увидеть пустую строку, мы видим, как все прекрасно работает:
Такое исключение из правил, создано намеренно, а именно – для удобства. Потому что это, действительно, удобнее чем каждый раз писать, что-то вроде s[len(s):0:-1] или s[len(s):0:-2] .
Отрицательное значение шага
Если мы хотим извлекать элементы из срезов строк в обратном порядке, то и границы срезов так же необходимо указывать в обратном порядке:
Помните мы задавались вопросом о том, как работает операция s[::-1] ? И был дан расплывчато-туманный ответ, что это яко бы просто техническая особенность, созданная для удобства. Так вот это действительно технически реализованный трюк, который заключается в том, установленные по умолчанию значения начала и конца среза (начало – \(0\), конец – len(s) ) меняются местами, если величина шага имеет отрицательное значение:
Возможно вы немного удивились, ожидая вместо команды s[-1:-len(s)-1:-2] увидеть команду s[len(s):0:-2] . Но если вспомнить, что символы извлекаются не по индексам, а по смещениям, так же вспомнив, что извлечение среза выполняется от первого указанного смещения до второго, то станет ясно, что команда s[len(s):0:-2] выдаст не то, что нужно:
В заключение, хочется напомнить о двух простых правилах из Дзена Python:
- Простое лучше чем сложное;
- Сложное лучше чем запутанное.
Почему именно эти правила. Потому что вам может захотеться использовать в своем коде какие-то, так сказать, хитро-выдуманные трюки с индексированием. С одной стороны: «Почему бы и нет. Ведь программирование – это еще и способ самовыражения!». Но с другой стороны – это еще замечательный способ вынести мозг и себе, и что хуже всего, другим людям. Так что, если вдруг, вы придумаете, каой-нибудь фокус с индексированием строк, то не поленитесь раскрыть его секрет в комментариях к коду.
Сам по себе механизм индексирования устроен довольно просто. Тем не менее, даже из такой «простоты» можно слепить что-то вроде этого:
Подобные фокусы имеют полное право на существование, но лучше их оставить для чемпионатов по программированию.
Источник
Индексы и срезы строк
На самом деле в Python строка представляются как упорядоченная коллекция символов. И ключевое слово здесь – «упорядоченная». Это значит, что у каждого символа в строке есть свой порядковый номер – индекс, по которому мы можем его получить. Например, когда мы создаем строку
то формируется следующая коллекция:
Каждый символ имеет свой индекс, начиная с нулевого. Первый символ в Python всегда имеет нулевой индекс.
Для обращения к тому или иному символу используется следующий синтаксис:
и так далее. Но, если указать неверный индекс, например:
то возникнет ошибка. Поэтому здесь следует быть аккуратным и не выходить за пределы этого списка. В частности, последний «рабочий» индекс можно определить с помощью функции len – длины строки:
lastIndex = len( ) – 1
То есть, к последнему индексу мы можем обратиться так:
Но это не очень удобно. Поэтому разработчики языка Python решили, что отрицательные индексы будут означать движение по строке с конца в начало. И предыдущую запись можно переписать так:
Видите? Это намного удобнее. То есть, у строк есть еще такие отрицательные индексы:
Также в Python можно использовать доступ к отдельному символу непосредственно у строкового литерала:
Иногда это бывает удобно.
Срезы
Часто в программировании требуется выбрать не один какой-то символ, а сразу несколько. Для этого используются так называемые срезы. Их работу проще показать на конкретных примерах. Пусть у нас есть наша строка:
и мы хотим выделить последнее слово «World!». Для этого в квадратных скобках указывается начальный индекс и через двоеточие – конечный. Если мы запишем все вот в таком виде:
то получим результат «World» без восклицательного знака. Дело в том, что последний индекс исключается из интервала, то есть, интервал определяется как
Поэтому, мы должны записать срез так:
Другой пример для выделения символов «llo»:
и так далее. В Python допускается не указывать начальное или конечное значения, или даже, оба из них. Например:
выделяет слово «Hello», а вот так:
получим «World!». Наконец, записав все в таком виде:
получим ту же самую строку, не копию! Это можно проверить так:
Увидим одно и то же значение id для обеих переменных, это означет, что они ссылаются на один и тот же объект.
В срезах на Python можно дополнительно указывать шаг через двоеточие. Например, так:
мы здесь ставим еще одно двоеточие и указываем шаг 2, то есть, идем через символ: «HloWrd». Также это можно комбинировать с граничными значениями:
и использовать отрицательный шаг:
в этом случае символы будут перебираться в обратном порядке.
Строка – неизменяемый объект
Далее, при работе со строками следует помнить, что это неизменяемый объект, то есть, мы не можем изменять в строковом объекте уже существующие символы, то есть, вот такая запись:
приведет к ошибке, говорящая о том, что строка не может быть изменена. Тогда как в Python нам изменять строки? Для этого создается новая строка с нужным содержимым. Например, изменим строку
Это можно сделать так:
В результате строка myStr ссылается на новую измененную строку, а msg осталась прежней.
Задания для самоподготовки
1. Напишите программу подсчета букв ‘a’ в строке «abrakadabra».
2. Из строки «abrakadabra» удалите все сочетания «ab».
3. Напишите программу определения слова палиндрома (это слова, которые одинаково читаются в обоих направлениях, например, анна, abba и т.п.). Слово вводится с клавиатуры.
4. Напишите программу определения количества вхождений фраз «ra» в слове «abrakadabra».
5. Разделите введенное с клавиатуры предложение на слова (слова разделяются пробелом).
Видео по теме
#1. Первое знакомство с Python Установка на компьютер
#2. Варианты исполнения команд. Переходим в PyCharm
#3. Переменные, оператор присваивания, функции type и id
#4. Числовые типы, арифметические операции
#5. Математические функции и работа с модулем math
#6. Функции print() и input(). Преобразование строк в числа int() и float()
#7. Логический тип bool. Операторы сравнения и операторы and, or, not
#8. Введение в строки. Базовые операции над строками
#9. Знакомство с индексами и срезами строк
#10. Основные методы строк
#11. Спецсимволы, экранирование символов, row-строки
#12. Форматирование строк: метод format и F-строки
#13. Списки — операторы и функции работы с ними
#14. Срезы списков и сравнение списков
#15. Основные методы списков
#16. Вложенные списки, многомерные списки
#17. Условный оператор if. Конструкция if-else
#18. Вложенные условия и множественный выбор. Конструкция if-elif-else
#19. Тернарный условный оператор. Вложенное тернарное условие
#20. Оператор цикла while
#21. Операторы циклов break, continue и else
#22. Оператор цикла for. Функция range()
#23. Примеры работы оператора цикла for. Функция enumerate()
#24. Итератор и итерируемые объекты. Функции iter() и next()
#25. Вложенные циклы. Примеры задач с вложенными циклами
#26. Треугольник Паскаля как пример работы вложенных циклов
#27. Генераторы списков (List comprehensions)
#28. Вложенные генераторы списков
#29. Введение в словари (dict). Базовые операции над словарями
#30. Методы словаря, перебор элементов словаря в цикле
#31. Кортежи (tuple) и их методы
#32. Множества (set) и их методы
#33. Операции над множествами, сравнение множеств
#34. Генераторы множеств и генераторы словарей
#35. Функции: первое знакомство, определение def и их вызов
#36. Оператор return в функциях. Функциональное программирование
#37. Алгоритм Евклида для нахождения НОД
#38. Именованные аргументы. Фактические и формальные параметры
#39. Функции с произвольным числом параметров *args и **kwargs
#40. Операторы * и ** для упаковки и распаковки коллекций
#41. Рекурсивные функции
#42. Анонимные (lambda) функции
#43. Области видимости переменных. Ключевые слова global и nonlocal
#44. Замыкания в Python
#45. Введение в декораторы функций
#46. Декораторы с параметрами. Сохранение свойств декорируемых функций
#47. Импорт стандартных модулей. Команды import и from
#48. Импорт собственных модулей
#49. Установка сторонних модулей (pip install). Пакетная установка
#50. Пакеты (package) в Python. Вложенные пакеты
#51. Функция open. Чтение данных из файла
#52. Исключение FileNotFoundError и менеджер контекста (with) для файлов
#53. Запись данных в файл в текстовом и бинарном режимах
#54. Выражения генераторы
#55. Функция-генератор. Оператор yield
#56. Функция map. Примеры ее использования
#57. Функция filter для отбора значений итерируемых объектов
#58. Функция zip. Примеры использования
#59. Сортировка с помощью метода sort и функции sorted
#60. Аргумент key для сортировки коллекций по ключу
#61. Функции isinstance и type для проверки типов данных
#62. Функции all и any. Примеры их использования
#63. Расширенное представление чисел. Системы счисления
#64. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы
#65. Модуль random стандартной библиотеки
© 2021 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Источник
