Поиск по сайту:

Как индексировать и нарезать строки в Python 3


Введение

Строковый тип данных Python — это последовательность, состоящая из одного или нескольких отдельных символов, которые могут состоять из букв, цифр, пробелов или символов. Поскольку строка представляет собой последовательность, доступ к ней можно получить теми же способами, что и к другим типам данных, основанным на последовательности, посредством индексации и нарезки.

В этом учебном пособии вы узнаете, как получить доступ к строкам с помощью индексации, разбить их по последовательностям символов и пройтись по некоторым методам подсчета и расположения символов.

Предпосылки

У вас должен быть установлен Python 3 и настроена среда программирования на вашем компьютере или сервере. Если у вас не настроена среда программирования, вы можете обратиться к руководствам по установке и настройке среды программирования на вашем сервере, подходящей для вашей операционной системы (Ubuntu, CentOS, Debian и т. д.).

Как индексируются строки

Как и в случае с типом данных списка, элементы которого соответствуют порядковому номеру, каждый символ строки также соответствует порядковому номеру, начиная с порядкового номера 0.

Для строки Sammy Shark! разбивка индекса выглядит следующим образом:

S a m m y S h a r k !
0 1 2 3 4 5 6 7 8 9 10 11

Как видите, первый S начинается с индекса 0, а строка заканчивается с индексом 11 символом !.

Мы также заметили, что символ пробела между Sammy и Shark также соответствует своему собственному порядковому номеру. В этом случае номер индекса, связанный с пробелом, равен 5.

Восклицательный знак (!) также имеет связанный с ним порядковый номер. Любой другой символ или знак препинания, такой как *#$&.;?, также является символом и будет связан со своим собственным порядковым номером.

Тот факт, что каждый символ в строке Python имеет соответствующий порядковый номер, позволяет нам получать доступ к строкам и манипулировать ими так же, как и с другими последовательными типами данных.

Доступ к символам по положительному номеру индекса

Ссылаясь на порядковые номера, мы можем изолировать один из символов в строке. Мы делаем это, помещая порядковые номера в квадратные скобки. Объявим строку, выведем ее и вызовем порядковый номер в квадратных скобках:

Информация: Чтобы следовать примеру кода в этом руководстве, откройте интерактивную оболочку Python в вашей локальной системе, выполнив команду python3. Затем вы можете копировать, вставлять или редактировать примеры, добавляя их после приглашения >>>.

ss = "Sammy Shark!"
print(ss[4])
Output
y

Когда мы обращаемся к определенному индексу строки, Python возвращает символ, который находится в этой позиции. Поскольку буква y находится под индексом 4 строки ss=Sammy Shark!, когда мы печатаем ss[4], мы получаем y в качестве вывода.

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

Доступ к символам по отрицательному номеру индекса

Если у нас есть длинная строка и мы хотим определить элемент ближе к концу, мы также можем считать в обратном порядке от конца строки, начиная с порядкового номера -1.

Для той же строки Sammy Shark! разбивка отрицательного индекса выглядит следующим образом:

S a m m y S h a r k !
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

Используя числа с отрицательным индексом, мы можем распечатать символ r, ссылаясь на его позицию в индексе -3, например так:

print(ss[-3])
Output
r

Использование отрицательных индексов может быть полезным для изоляции одного символа ближе к концу длинной строки.

Нарезка строк

Мы также можем вызвать диапазон символов из строки. Допустим, мы хотим напечатать только слово Shark. Мы можем сделать это, создав срез, представляющий собой последовательность символов в исходной строке. С помощью срезов мы можем вызывать несколько символьных значений, создавая диапазон номеров индексов, разделенных двоеточием [x:y]:

print(ss[6:11])
Output
Shark

При построении среза, как в [6:11], первый порядковый номер — это место, где начинается срез (включительно), а второй порядковый номер — это место, где слайс заканчивается (исключая), поэтому в нашем примере выше диапазон должен быть номером индекса, который будет встречаться после окончания строки.

При нарезке строк мы создаем подстроку, которая по существу является строкой, существующей внутри другой строки. Когда мы вызываем ss[6:11], мы вызываем подстроку Shark, которая существует в строке Sammy Shark!.

Если мы хотим включить любой конец строки, мы можем опустить одно из чисел в синтаксисе string[n:n]. Например, если мы хотим напечатать первое слово строки ss — \Сэмми — мы можем сделать это, набрав:

print(ss[:5])
Output
Sammy

Мы сделали это, опустив номер индекса перед двоеточием в синтаксисе слайса и включив номер индекса только после двоеточия, который указывает на конец подстроки.

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

print(ss[7:])
Output
hark!

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

Вы также можете использовать отрицательные индексы для нарезки строки. Как мы уже говорили ранее, отрицательные порядковые номера строки начинаются с -1 и отсчитываются от этого числа до тех пор, пока мы не достигнем начала строки. При использовании отрицательных индексов мы начнем сначала с меньшего числа, поскольку оно встречается в строке раньше.

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

print(ss[-4:-1])
Output
ark

Подстрока \ark выводится из строки Sammy Shark! потому что символ \a находится в позиции индекса -4, а символ \k находится перед позиции индекса -1.

Указание шага при разрезании строк

Разделение строк может принимать третий параметр в дополнение к двум порядковым номерам. Третий параметр указывает шаг, который относится к тому, на сколько символов нужно продвинуться вперед после того, как первый символ будет получен из строки. До сих пор мы опускали параметр шага, и Python по умолчанию использует шаг, равный 1, так что извлекается каждый символ между двумя номерами индекса.

Давайте рассмотрим приведенный выше пример, в котором выводится подстрока «Акула»:

print(ss[6:11])
Output
Shark

Мы можем получить те же результаты, включив третий параметр с шагом 1:

print(ss[6:11:1])
Output
Shark

Таким образом, шаг, равный 1, займет каждый символ между двумя порядковыми номерами среза. Если мы опустим параметр шага, Python по умолчанию будет иметь значение 1.

Если вместо этого мы увеличим шаг, мы увидим, что символы пропускаются:

print(ss[0:12:2])
Output
SmySak

Указание шага 2 в качестве последнего параметра в синтаксисе Python ss[0:12:2] пропускает все остальные символы. Давайте рассмотрим выделенные символы:

Sammy Shark!

Обратите внимание, что символ пробела в индексе номер 5 также пропускается с указанным шагом 2.

Если мы используем большее число для нашего параметра шага, у нас будет значительно меньшая подстрока:

print(ss[0:12:4])
Output
Sya

Указание шага, равного 4, в качестве последнего параметра в синтаксисе Python ss[0:12:4] печатает только каждый четвертый символ. Опять же, давайте посмотрим на выделенные символы:

Sаммy Shark!

В этом примере также пропускается символ пробела.

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

print(ss[::4])
Output
Sya

Если пропустить два индекса и сохранить двоеточие, вся строка будет оставаться в пределах диапазона, а добавление последнего параметра для шага будет указывать количество символов, которые нужно пропустить.

Кроме того, вы можете указать отрицательное числовое значение шага, которое мы можем использовать для печати исходной строки в обратном порядке, если мы установим шаг равным -1:

print(ss[::-1])
Output
!krahS ymmaS

Два двоеточия без указанных параметров будут включать все символы исходной строки, шаг 1 будет включать все символы без пропуска, а отрицание этого шага приведет к обратному порядку символов.

Давайте сделаем это снова, но с шагом -2:

print(ss[::-2])
Output
!rh ma

В этом примере ss[::-2] мы имеем дело со всей исходной строкой, поскольку в параметры не включены порядковые номера, и обращаем строку с отрицательным шагом. Кроме того, имея шаг -2, мы пропускаем каждую вторую букву перевернутой строки:

!krahS[пробел]ymm аS

В этом примере печатается символ пробела.

Указав третий параметр синтаксиса фрагмента Python, вы указываете шаг подстроки, которую вы извлекаете из исходной строки.

Методы подсчета

Пока мы думаем о соответствующих индексах, соответствующих символам в строках, стоит рассмотреть некоторые методы, которые подсчитывают строки или возвращают индексы. Это может быть полезно для ограничения количества символов, которые мы хотели бы принять в форме пользовательского ввода, или для сравнения строк. Как и другие последовательные типы данных, строки можно подсчитывать несколькими способами.

Сначала мы рассмотрим метод len(), который может получить длину любого типа данных, являющегося последовательностью, упорядоченной или неупорядоченной, включая строки, списки, словари.

Выведем длину строки ss:

print(len(ss))
Output
12

Длина строки \Сэмми Акула! состоит из 12 символов, включая пробел и восклицательный знак.

Вместо использования переменной мы также можем передать строку прямо в метод len():

print(len("Let's print the length of this string."))
Output
38

Метод len() подсчитывает общее количество символов в строке.

Если мы хотим подсчитать, сколько раз в строке появляется один конкретный символ или последовательность символов, мы можем сделать это с помощью метода str.count(). Давайте поработаем с нашей строкой ss=Sammy Shark! и подсчитаем, сколько раз появляется символ \a:

print(ss.count("a"))
Output
2

Мы можем искать другого персонажа:

print(ss.count("s"))
Output
0

Хотя в строке присутствует буква \S, важно помнить, что каждый символ чувствителен к регистру. Если мы хотим искать все буквы в строке независимо от регистра, мы можем использовать str.lower(), чтобы сначала преобразовать строку во все строчные буквы. Подробнее об этом методе можно прочитать в статье «Введение в строковые методы в Python 3».

Давайте попробуем использовать str.count() с последовательностью символов:

likes = "Sammy likes to swim in the ocean, likes to spin up servers, and likes to smile."
print(likes.count("likes"))
Output
3

В строке likes последовательность символов, эквивалентная \likes, встречается 3 раза в исходной строке.

Мы также можем найти, в какой позиции в строке встречается символ или последовательность символов. Мы можем сделать это с помощью метода str.find(), и он вернет позицию символа на основе порядкового номера.

Мы можем проверить, где первая буква \m встречается в строке ss:

print(ss.find("m"))
Ouput
2

Первый символ \m находится в индексной позиции 2 в строке \Sammy Shark! Мы можем просмотреть позиции индекса строки ss выше.

Давайте проверим, где находится первая последовательность символов \лайки в строке likes:

print(likes.find("likes"))
Ouput
6

Первый экземпляр последовательности символов \likes начинается с позиции индекса 6, где находится символ l последовательности likes.

Что, если мы хотим увидеть, где начинается вторая последовательность лайков? Мы можем сделать это, передав второй параметр методу str.find(), который будет начинаться с определенного индекса. Итак, вместо того, чтобы начинать с начала строки, давайте начнем после порядкового номера 9:

print(likes.find("likes", 9))
Output
34

Во втором примере, который начинается с порядкового номера 9, первое вхождение последовательности символов \нравится начинается с порядкового номера 34.

Кроме того, мы можем указать конец диапазона в качестве третьего параметра. Подобно нарезке, мы можем сделать это, считая в обратном порядке, используя отрицательное число индекса:

print(likes.find("likes", 40, -6))
Output
64

В этом последнем примере выполняется поиск позиции последовательности «нравится» между порядковыми номерами от 40 до -6. Поскольку последним введенным параметром является отрицательное число, отсчет будет производиться с конца исходной строки.

Строковые методы len(), str.count() и str.find() можно использовать для определения длины, количества символы или последовательности символов, а также индексировать позиции символов или последовательностей символов в строках.

Заключение

Возможность вызывать определенные порядковые номера строк или определенный фрагмент строки дает нам большую гибкость при работе с этим типом данных. Поскольку строки, как и списки и кортежи, представляют собой тип данных, основанный на последовательности, доступ к ним можно получить с помощью индексации и нарезки.

Вы можете прочитать больше о строковых методах, чтобы продолжить изучение строк.