Работа со строками
Строками в языках программирования принято называть упорядоченные последовательности символов, которые используются для представления любой текстовой информации. В Python они являются самостоятельным типом данных, а значит при помощи встроенных функций языка над ними можно производить различные операции и форматировать их для вывода.
Создание
Получить новую строку можно несколькими способами: при помощи соответствующего литерала либо же вызвав готовую функцию. Для начала рассмотрим первый метод, который продемонстрирован ниже. Здесь переменная string получает значение some text, благодаря оператору присваивания. Вывести на экран созданную строку помогает функция print.
string = 'some text' print(string) some text
Как видно из предыдущего примера, строковый литерал обрамляется в одиночные кавычки. Если необходимо, чтобы данный символ был частью строки, следует применять двойные кавычки, как это показано в следующем фрагменте кода. Из результатов его работы видно, что новая строка включает в себя текст some ‘new’ text, который легко выводится на экран.
string = "some 'new' text" print(string) some 'new' text
Иногда возникает потребность в создании объектов, включающих в себя сразу несколько строк с сохранением форматирования. Эту задачу поможет решить троекратное применение символа двойных кавычек для выделения литерала. Объявив строку таким образом, можно передать ей текст с неограниченным количеством абзацев, что показано в данном коде.
string = """some 'new' text with new line here""" print(string) some 'new' text with new line here
Специальные символы
Пользоваться тройными кавычками для форматирования строк не всегда удобно, так как это порой занимает слишком много места в коде. Чтобы задать собственное форматирование текста, достаточно применять специальные управляющие символы с обратным слэшем, как это показано в следующем примере. Здесь используется символ табуляции \t, а также знак перехода на новую строку \n. Метод print демонстрирует вывод нового объекта на экран.
string = "some\ttext\nnew line here" print(string) some text new line here
Служебные символы для форматирования строк выполняют свои функции автоматически, но иногда это мешает, к примеру, когда требуется сохранить путь к файлу на диске. Чтобы их отключить, необходимо применить специальный префикс r перед первой кавычкой литерала. Таким образом, обратные слэши будут игнорироваться программой во время ее запуска.
string = r"D:\dir\new"
Следующая таблица демонстрирует перечень всех используемых в языке Python служебных символов для форматирования строк. Как правило, большинство из них позволяют менять положение каретки для выполнения перевода строки, табуляции или возврата каретки.
| Символ | Назначение |
| \n | Перевод каретки на новую строку |
| \b | Возврат каретки на один символ назад |
| \f | Перевод каретки на новую страницу |
| \r | Возврат каретки на начало строки |
| \t | Горизонтальная табуляция |
| \v | Вертикальная табуляция |
| \a | Подача звукового сигнала |
| \N | Идентификатор базы данных |
| \u, \U | 16-битовый и 32-битовый символ Unicode |
| \x | Символ в 16-ричной системе исчисления |
| \o | Символ в 8-ричной системе исчисления |
| \0 | Символ Null |
Очень часто испльзуется \n. С помощью него осуществляется в Python перенос строки. Рассмотрим пример:
print('first\nsecond') first second
Форматирование
Выполнить форматирование отдельных частей строки, задав в качестве ее компонентов некие объекты программы позволяет символ %, указанный после литерала. В следующем примере показано, как строковый литерал включает в себя не только текст, но также строку и целое число. Стоит заметить, что каждой переменной в круглых скобках должен соответствовать специальный символ в самом литерале, обладающий префиксом % и подходящим значением.
string = "text" number = 10 newString = "this is %s and digit %d" % (string, number) print(newString) this is text and digit 10
В приведенном ниже фрагменте кода демонстрируется использование форматирования для вывода строки с выравниванием по правому краю (общая длина символов указана как 10).
string = "text" newString = "%+10s" % string print(newString) text
Данная таблица содержит в себе все управляющие символы для форматирования строк в Python, каждый из которых обозначает определенный объект: числовой либо же символьный.
| Символ | Назначение |
| %d, %i, %u | Число в 10-ричной системе исчисления |
| %x, %X | Число в 16-ричной системе исчисления с буквами в нижнем и верхнем регистре |
| %o | Число в 8-ричной системе исчисления |
| %f, %F | Число с плавающей точкой |
| %e, %E | Число с плавающей точкой и экспонентой в нижнем и верхнем регистре |
| %c | Одиночный символ |
| %s, %r | Строка из литерала и обычная |
| %% | Символ процента |
Более удобное форматирование выполняется с помощью функции format. Ей необходимо передать в качестве аргументов объекты, которые должны быть включены в строку, а также указать места их расположения с помощью числовых индексов, начиная с нулевого.
string = "text" number = 10 newString = "this is and digit ".format(string, number) print(newString) this is text and digit 10
В следующем примере показано как можно отцентрировать строку, воспользовавшись методом format и специальными символами. Изначальный текст здесь перемещается в самый центр строки, в то время как пустое пространство заполняется символом *.
string = "text" newString = "".format(string) print(newString) ***text***
Следующая таблица отображает специальные символы для выравнивания строк и вывода чисел с необходимым форматом знаков для положительных и отрицательных объектов.
| Символ | Назначение |
| ‘ | Выравнивание строки по левому краю с символами-заполнителями справа |
| ‘>’ | Выравнивание строки по правому краю с символами-заполнителями слева |
| ‘=’ | Выравнивание с символами-заполнителями после знака числа, но перед его цифрами |
| ‘^’ | Выравнивание строки по центру с символами-заполнителями с обеих сторон |
| ‘+’ | Применение знака для любых чисел |
| ‘-‘ | Применение знака для отрицательных чисел и ничего для положительных |
| ‘ ‘ | Применение знака для отрицательных чисел и пробела для положительных |
Операции над строками
Прежде чем перейти к функциям для работы со строками, следует рассмотреть основные операции с ними, которые позволяют быстро преобразовывать любые последовательности символов. При помощи знака плюс можно производить конкатенацию строк, соединяя их вместе. В следующем примере продемонстрировано объединение this is new и text.
string = "text" newString = "this is new " + string print(newString) this is new text
Пользуясь символом умножения, программист получает возможность дублировать строку любое количество раз. В данном коде слово text записывается в новую строку трижды.
string = "text " newString = string * 3 print(newString) text text text
Как и в случае с числами, со строками можно использовать операторы сравнения, например двойное равно. Очевидно, что литералы some text и some new text разные, поэтому вызов метода print выводит на экран булево значение False для строк string и newString.
string = "some text" newString = "some new text" print(string == newString) False
Операции над строками позволяют получать из них подстроки, делая срезы, как с обычными элементами последовательностей. В следующем примере, необходимо лишь указать нужный интервал индексов в квадратных скобках, помня, что нумерация осуществляется с нуля.
string = "some text" newString = string[2:4] print(newString) me
Отрицательный индекс позволяет обращаться к отдельным символами строки не с начала, а с конца. Таким образом, элемент под номером -2 в строке some text является буквой x.
string = "some text" print(string[-2]) x
Методы и функции
Очень часто используется для приведения типов к строковому виду функция str. С ее помощью можно создать новую строку из литерала, который передается в качестве аргумента. Данный пример демонстрирует инициализацию переменной string новым значением some text.
string = str("some text") print(string) some text
Аргументом этой функции могут быть переменные разных типов, например числа или списки. Эта функция позволяет в Python преобразовать в строку разные типы данных. Если вы создаете свой класс, то желательно определить для него метод __str__. Этот метод должен возвращать строку, которая будет возвращена в случае, когда в качестве аргумента str будет использован объект вашего класса.
В Python получения длины строки в символах используется функция len. Как видно из следующего фрагмента кода, длина объекта some text равняется 9 (пробелы тоже считаются).
string = "some text" print(len(string)) 9
Метод find позволяет осуществлять поиск в строке. При помощи него в Python можно найти одиночный символ или целую подстроку в любой другой последовательности символов. В качестве результата своего выполнения он возвращает индекс первой буквы искомого объекта, при этом нумерация осуществляется с нуля.
string = "some text" print(string.find("text")) 5
Метод replace служит для замены определенных символов или подстрок на введенную программистом последовательность символов. Для этого необходимо передать функции соответствующие аргументы, как в следующем примере, где пробелы заменяются на символ ‘-‘.
string = "some text" print(string.replace(" ", "-")) some-text
Для того чтобы разделить строку на несколько подстрок при помощи указанного разделителя, следует вызвать метод split. По умолчанию его разделителем является пробел. Как показано в приведенном ниже примере, some new text трансформируется в список строк strings.
string = "some new text" strings = string.split() print(strings) ['some', 'new', 'text']
Выполнить обратное преобразование, превратив список строк в одну можно при помощи метода join. В следующем примере в качестве разделителя для новой строки был указан пробел, а аргументом выступил массив strings, включающий some, new и text.
strings = ["some", "new", "text"] string = " ".join(strings) print(string) some new text
Наконец, метод strip используется для автоматического удаления пробелов с обеих сторон строки, как это показано в следующем фрагменте кода для значения объекта string.
string = " some new text " newString = string.strip() print(newString) some new text
Ознакомиться с функциями и методами, используемыми в Python 3 для работы со строками можно из данной таблицы. В ней также приведены методы, позволяющие взаимодействовать с регистром символов.
| Метод | Назначение |
| str(obj) | Преобразует объект к строковому виду |
| len(s) | Возвращает длину строки |
| find(s, start, end), rfind(s, start, end) | Возвращает индекс первого и последнего вхождения подстроки в s или -1, при этом поиск идет в границах от start до end |
| replace(s, ns) | Меняет выбранную последовательность символов в s на новую подстроку ns |
| split(c) | Разбивает на подстроки при помощи выбранного разделителя c |
| join(c) | Объединяет список строк в одну при помощи выбранного разделителя c |
| strip(s), lstrip(s), rstrip(s) | Убирает пробелы с обоих сторон s, только слева или только справа |
| center(num, c), ljust(num, c), rjust(num, c) | Возвращает отцентрированную строку, выравненную по левому и по правому краю с длиной num и символом c по краям |
| lower(), upper() | Перевод всех символов в нижний и верхний регистр |
| startwith(ns), endwith(ns) | Проверяет, начинается ли или заканчивается строка подстрокой ns |
| islower(), isupper() | Проверяет, состоит ли строка только из символов в нижнем и верхнем регистре |
| swapcase() | Меняет регистр всех символов на противоположный |
| title() | Переводит первую букву каждого слова в верхний регистр, а все остальные в нижний |
| capitalize() | Переводит первую букву в верхний регистр, а все остальные в нижний |
| isalpha() | Проверяет, состоит ли только из букв |
| isdigit() | Проверяет, состоит ли только из цифр |
| isnumeric() | Проверяет, является ли строка числом |
Кодировка
Чтобы задать необходимую кодировку для используемых в строках символов в Python достаточно поместить соответствующую инструкцию в начало файла с кодом, как это было сделано в следующем примере, где используется utf-8. С помощью префикса u, который стоит перед литералом, можно помечать его соответствующей кодировкой. В то же время префикс b применяется для литералов строк с элементами величиной в один байт.
# coding: utf-8 string = u'some text' newString = b'text'
Производить кодирование и декодирование отдельных строк с заданной кодировкой позволяют встроенные методы decode и encode. Аргументом для них является название кодировки, как в следующем примере кода, где применяется наименование utf-8.
string = string.decode('utf8') newString = newString.encode('utf8')
Архимед Python 19/20
Строка считывается со стандартного ввода функцией input() . Напомним, что для двух строк определа операция сложения (конкатенации), также определена операция умножения строки на число.
Строка состоит из последовательности символов. Узнать количество символов (длину строки) можно при помощи функции len :
>>> S = 'Hello' >>> print(len(S)) 5
Срез (slice) — извлечение из данной строки одного символа или некоторого фрагмента подстроки или подпоследовательности.
Есть три формы срезов. Самая простая форма среза: взятие одного символа строки, а именно, S[i] — это срез, состоящий из одного символа, который имеет номер i , при этом считая, что нумерация начинается с числа 0. То есть если , то , , , , .
Номера символов в строке (а также в других структурах данных: списках, кортежах) называются индексом.
Если указать отрицательное значение индекса, то номер будет отсчитываться с конца, начиная с номера -1 . То есть , , , , .
Или в виде таблицы:
| Строка S | H | e | l | l | o |
| Индекс | S[0] | S[1] | S[2] | S[3] | S[4] |
| Индекс | S[-5] | S[-4] | S[-3] | S[-2] | S[-1] |
Если же номер символа в срезе строки S больше либо равен len(S) , или меньше, чем -len(S) , то при обращении к этому символу строки произойдет ошибка IndexError: string index out of range .
Срез с двумя параметрами: S[a:b] возвращает подстроку из b-a символов, начиная с символа c индексом a , то есть до символа с индексом b, не включая его. Например, S[1:4]==’ell’ , то же самое получится если написать S[-4:-1] . Можно использовать как положительные, так и отрицательные индексы в одном срезе, например, S[1:-1] — это строка без первого и последнего символа (срез начинается с символа с индексом 1 и заканчиватеся индексом -1, не включая его).
При использовании такой формы среза ошибки IndexError никогда не возникает. Например, срез S[1:5] вернет строку ‘ello’ , таким же будет результат, если сделать второй индекс очень большим, например, S[1:100] (если в строке не более 100 символов).
Если опустить второй параметр (но поставить двоеточие), то срез берется до конца строки. Например, чтобы удалить из строки первый символ (его индекс равен 0, то есть взять срез, начиная с символа с индексом 1), то можно взять срез S[1:] , аналогично если опустиить первый параметр, то срез берется от начала строки. То есть удалить из строки последний символ можно при помощи среза S[:-1] . Срез S[:] совпадает с самой строкой S .
Если задать срез с тремя параметрами S[a:b:d] , то третий параметр задает шаг, как в случае с функцией range , то есть будут взяты символы с индексами a , a+d , a+2*d и т.д. При задании значения третьего параметра, равному 2, в срез попадет кажый второй символ, а если взять значение среза, равное -1 , то символы будут идти в обратном порядке.
Метод — это функция, применяемая к объекту, в данном случае — к строке. Метод вызывается в виде Имя_объекта.Имя_метода(параметры) . Например, S.find(«e») — это применение к строке S метода find с одним параметром «e» .
Метод find и rfind
Метод find находит в данной строке (к которой применяется метод) данную подстроку (которая передается в качестве параметра). Функция возвращает индекс первого вхождения искомой подстроки. Если же подстрока не найдена, то метод возвращает значение -1. Например:
>>> S = 'Hello' >>> print(S.find('e')) 1 >>> print(S.find('ll')) 2 >>> print(S.find('L')) -1
Аналогично, метод rfind возвращает индекс последнего вхождения данной строки (“поиск справа”).
>>> S = 'Hello' >>> print(S.find('l')) 2 >>> print(S.rfind('l')) 3
Если вызвать метод find с тремя параметрами S.find(T, a, b) , то поиск будет осуществляться в срезе S[a:b] . Если указать только два параметра S.find(T, a) , то поиск будет осуществляться в срезе S[a:] , то есть начиная с символа с индексом a и до конца строки. Метод S.find(T, a, b) возращает индекс в строке S , а не индекс относительно
Метод replace заменяет все вхождения одной строки на другую. Формат: S.replace(old, new) — заменить в строке S все вхождения подстроки old на подстроку new . Пример:
>>> 'Hello'.replace('l', 'L') 'HeLLo'
Если методу replace задать еще один параметр: S.replace(old, new, count) , то заменены будут не все вхождения, а только не больше, чем первые count из них.
>>> 'Abrakadabra'.replace('a', 'A', 2) 'AbrAkAdabra'
Подсчитывает количество вхождений одной строки в другую строку. Простейшая форма вызова S.count(T) возвращает число вхождений строки T внутри строки S . При этом подсчитываются только непересекающиеся вхождения, например:
>>> 'Abracadabra'.count('a') 4 >>> ('a' * 100000).count('aa') 50000
При указании трех параметров , будет выполнен подсчет числа вхождений строки T в срез S[a:b] .
Парсер. Как пропустить строку с ошибкой
Есть .txt файл с массивом типовых строк Я пытаюсь вытащить определенное значение из каждой строки проходя сторки вот так:
import re with open('test.txt') as f: lines = f.readlines() for line in lines: m = re.findall("'(.+?)'", line) print(m[3]) Все работает как нужно. Проблема начинается когда одна из строк не соответствует условию и тогда появляется ошибка:
Traceback (most recent call last): File "test.py", line 79, in print(m[3]) IndexError: list index out of range Собственно вопрос: я хочу чтоб строка которая не соответствует — просто отбрасывалась и цикл шел дальше просто отбрасывая несоответствующие строки
Индексация и разделение строк в Python 3
Тип строки данных Python представляет собой последовательность, составленную из одного или нескольких отдельных символов, в том числе букв, чисел, пробелов или специальных символов. Поскольку строка представляет собой последовательность, к ней можно получить доступ посредством индексации и разделения, как и к другим типам данных на базе последовательностей.
В этом учебном модуле вы узнаете, как получать доступ к строкам через индексацию, как разделять их через последовательности символов и как использовать методы подсчета и определения расположения символов.
Индексация строк
Как и тип данных списка, который содержит элементы, соответствующие индексу, строки также содержат символы, которым соответствуют индексы, начиная с 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 имеет свой индекс, мы можем получать доступ к строкам и совершать с ними манипуляции так же, как и с другими типами последовательных данных.
Доступ к символам через положительный числовой индекс
Используя ссылки на числовые индексы, мы можем изолировать один из символов в строке. Для этого мы поместим индекс в квадратные скобки. Давайте декларируем строку, выведем ее и вызовем индекс в квадратных скобках:
ss = "Sammy Shark!" print(ss[4]) Outputy Когда мы ссылаемся на определенный числовой индекс строки, 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]) Outputr Использование отрицательных индексов может быть полезно для изоляции отдельных символов ближе к концу длинной строки.
Разделение строк
Также мы можем вызвать ряд символов из строки. Допустим, мы хотим вывести слово Shark . Для этого мы можем создать срез, представляющий собой последовательность символов в исходной строке. С помощью срезов мы можем вызывать несколько значений символов, создавая диапазоны символов, разделенные двоеточием [x:y] :
print(ss[6:11]) OutputShark При построении среза, такого как [6:11] , первый индекс соответствует началу среза (включительно), а второй — окончанию среза (не включительно). Поэтому в нашем примере конец диапазона обозначается индексом позиции сразу после конца строки.
При разделении строк на срезы мы создаем подстроки, то есть, строки внутри других строк. Вызывая ss[6:11] , мы вызываем подстроку Shark , существующую в строке Sammy Shark! .
Если мы хотим включить любой конец строки, мы можем пропустить одно из чисел в синтаксисе string[n:n] . Например, если нам нужно вывести первое слово строки ss — “Sammy”, мы можем сделать это так:
print(ss[:5]) OutputSammy Мы пропустили индекс перед двоеточием в синтаксисе среза и указали только индекс после двоеточия, обозначающий конец подстроки.
Чтобы вывести подстроку, начинающуюся в середине строки и идущую до конца строки, мы можем указать только индекс перед двоеточием:
print(ss[7:]) Outputhark! Если мы укажем только индекс перед двоеточием и не укажем второй индекс, подстрока будет идти от соответствующего первому индексу символа до конца строки.
Для создания срезов также можно использовать отрицательные индексы. Как мы уже говорили раньше, отрицательные индексы строки начинаются с -1 и отсчитываются далее к началу строки. При использовании отрицательных индексов, мы начинаем с меньшего числа, потому что соответствующий ему символ идет раньше.
Давайте используем два отрицательных индекса для создания среза строки ss :
print(ss[-4:-1]) Outputark Подстрока “ark” выводится из строки “Sammy Shark!”, потому что символ “a” соответствует индексу -4, а символ “k” находится перед позицией индекса -1.
Определение шага при создании срезов строк
В дополнение к двум индексам при создании срезов можно использовать третий параметр. Третий параметр указывает шаг, означающий, на сколько символов нужно сдвинуться после извлечения первого символа из строки. В предыдущих примерах мы не использовали параметр шага, а по умолчанию Python использует значение шага 1, выводя все символы между двумя индексами.
Давайте снова посмотрим на пример выше, который выводит подстроку “Shark”:
print(ss[6:11]) OutputShark Мы можем получить те же результаты, добавив третий параметр шага со значением 1:
print(ss[6:11:1]) OutputShark Если шаг равен 1, выводятся все символы между двумя индексами среза. Если мы опустим параметр шага, Python будет по умолчанию использовать значение 1.
Если же мы увеличим значение шага, некоторые символы будут пропущены:
print(ss[0:12:2]) OutputSmySak Если мы зададим шаг 2 как последний параметр в синтаксисе Python ss[0:12:2] , будет пропущен каждый второй символ. Выводимые символы обозначены красным цветом:
S a m m y S h a r k !
Обратите внимание, что символ пробела с индексом 5 также пропускается, если задан шаг 2.
Если мы используем более крупное значение шага, подстрока будет значительно короче:
print(ss[0:12:4]) OutputSya Если мы укажем шаг 4 как последний параметр синтаксиса Python ss[0:12:4] , будет выведен только каждый четвертый символ. Выводимые символы также обозначены красным цветом:
S amm y Sh a rk!
В этом примере символ пробела тоже пропускается.
Поскольку мы выводим всю строку, мы можем опустить два индекса и оставить два двоеточия в синтаксисе, чтобы получить тот же результат:
print(ss[::4]) OutputSya Если мы пропустим два индекса и оставим запятые, мы включим в диапазон всю строку, а последний параметр будет определять шаг, то есть, количество пропускаемых символов.
Также мы можем указать отрицательное значение шага и использовать его для вывода исходной строки в обратном порядке, если зададим шаг -1:
print(ss[::-1]) Output!krahS ymmaS Два двоеточия без параметров означают вывод всех символов первоначальной строки, шаг 1 означает вывод всех символов без пропуска, а отрицательное значение шага изменяет порядок вывода символов на противоположный.
Давайте повторим эту команду, но используем шаг -2:
print(ss[::-2]) Output!rh ma В этом примере, ss[::-2] , мы включаем в диапазон всю первоначальную строку, поскольку индексы не указаны, и задаем обратный порядок вывода отрицательным значением шага. Кроме того, с шагом -2 мы пропускаем каждую вторую букву строки, выводимой в обратном порядке:
! k r a h S [пробел] y m m a S
В этом примере выводится символ пробела.
Задавая третий параметр синтаксиса среза Python, мы указываем шаг подстроки, которую извлекаем из первоначальной строки.
Методы подсчета
Когда мы говорим об индексах символов в строках, стоит упомянуть о некоторых методах подсчета строк или вывода индексов. Это может быть полезно для того, чтобы ограничить количество символов, которые мы хотим включить в форму ввода, или чтобы сравнивать строки. Для подсчета строк, как и других символов последовательных данных, можно использовать несколько методов.
Вначале мы рассмотрим метод len() , который поможет определить длину любого типа данных упорядоченной или неупорядоченной последовательности, включая строки, списки, кортежи и словари.
Давайте выведем длину строки ss :
print(len(ss)) Output12 Длина строки “Sammy Shark!” составляет 12 символов, включая символ пробела и символ восклицательного знака.
Вместо использования переменной мы также можем передать строку прямо в метод len() :
print(len("Let's print the length of this string.")) Output38 Метод len() подсчитывает общее количество символов в строке.
Если нам нужно подсчитать, сколько раз в строке встречается определенный символ или последовательность символов, мы можем использовать метод str.count() . Давайте возьмем нашу строку ss = «Sammy Shark!» и подсчитаем, сколько раз в ней встречается символ “a”:
print(ss.count("a")) Output2 Мы можем поискать и другой символ:
print(ss.count("s")) Output0 Хотя в строке есть буква “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")) Output3 В строке likes последовательность символов, эквивалентная “likes”, встречается в исходной строке 3 раза.
Также мы можем определить позицию символа или последовательности символов в строке. Для этого мы можем использовать метод str.find() , который выводит позицию символа на базе номера индекса.
Мы можем посмотреть, где появляется первый символ “m” в строке ss :
print(ss.find("m")) Ouput2 Первый символ “m” появляется в строке “Sammy Shark!” на позиции с индексом 2. Мы можем проверить позиции индекса в строке ss выше.
Давайте посмотрим, где встречается первая последовательность символов “likes” в строке likes :
print(likes.find("likes")) Ouput6 Первый экземпляр последовательности символов “likes” начинается с индекса 6, соответствующего позиции символа l в последовательности likes .
Что делать, если, если мы хотим увидеть, где начинается вторая последовательность “likes”? Для этого мы можем передать второй параметр в метод str.find() , который будет начинаться с конкретного индекса. Вместо того, чтобы начинать с начала строки, начнем с индекса 9:
print(likes.find("likes", 9)) Output34 Во втором примере, который начинается с индекса 9, первая последовательность символов “likes” начинается с индекса 34.
Также мы можем указать в качестве третьего параметра конец диапазона. Как и в случае со срезами, мы можем использовать обратный отсчет, указав отрицательный индекс:
print(likes.find("likes", 40, -6)) Output64 В последнем примере мы ищем позицию последовательности “likes” между индексами 40 и -6. Поскольку последний параметр отрицательный, отсчет выполняется с конца первоначальной строки.
Методы строки len() , str.count() и str.find() можно использовать для определения длины, количества символов или последовательностей символов и индексов символов или последовательностей символов в строках.
Заключение
Возможность вызова определенных индексов строк или конкретного среза строки дает дополнительную гибкость при работе с этим типом данных. Поскольку строки относятся к последовательному типу данных, как списки и кортежи, для доступа к ним можно использовать индексы и срезы.
Чтобы продолжить изучение строк, вы можете прочитать дополнительные материалы по форматированию строк и методам строк.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.