Срез строки python: Строки. Функции и методы строк

Строки. Функции и методы строк

S = ‘str’; S = «str»; S = »’str»’; S = «»»str»»»	Литералы строк
S = «s\np\ta\nbbb»	Экранированные последовательности
S = r»C:\temp\new»	Неформатированные строки (подавляют экранирование)
S = b»byte»	Строка байтов
S1 + S2	Конкатенация (сложение строк)
S1 * 3	Повторение строки
S[i]	Обращение по индексу
S[i:j:step]	Извлечение среза
len(S)	Длина строки
S.find(str, [start],[end])	Поиск подстроки в строке. Возвращает номер первого вхождения или -1
S.rfind(str, [start],[end])	Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
S.index(str, [start],[end])	Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
S.rindex(str, [start],[end])	Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
S.replace(шаблон, замена[, maxcount])	Замена шаблона на замену. maxcount ограничивает количество замен
S.split(символ)	Разбиение строки по разделителю
S.isdigit()	Состоит ли строка из цифр
S.isalpha()	Состоит ли строка из букв
S.isalnum()	Состоит ли строка из цифр или букв
S.islower()	Состоит ли строка из символов в нижнем регистре
S.isupper()	Состоит ли строка из символов в верхнем регистре
S.isspace()	Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы (‘\f’), «новая строка» (‘\n’), «перевод каретки» (‘\r’), «горизонтальная табуляция» (‘\t’) и «вертикальная табуляция» (‘\v’))
S.istitle()	Начинаются ли слова в строке с заглавной буквы
S.upper()	Преобразование строки к верхнему регистру
S.lower()	Преобразование строки к нижнему регистру
S.startswith(str)	Начинается ли строка S с шаблона str
S.endswith(str)	Заканчивается ли строка S шаблоном str
S.join(список)	Сборка строки из списка с разделителем S
ord(символ)	Символ в его код ASCII
chr(число)	Код ASCII в символ
S.capitalize()	Переводит первый символ строки в верхний регистр, а все остальные в нижний
S.center(width, [fill])	Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)
S.count(str, [start],[end])	Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию)
S.expandtabs([tabsize])	Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
S.lstrip([chars])	Удаление пробельных символов в начале строки
S.rstrip([chars])	Удаление пробельных символов в конце строки
S.strip([chars])	Удаление пробельных символов в начале и в конце строки
S.partition(шаблон)	Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
S.rpartition(sep)	Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
S.swapcase()	Переводит символы нижнего регистра в верхний, а верхнего – в нижний
S.title()	Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
S.zfill(width)	Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями
S.ljust(width, fillchar=» «)	Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar
S.rjust(width, fillchar=» «)	Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar
S.format(*args, **kwargs)	Форматирование строки

Интерактивный учебник языка Python

1. Строки

Строка считывается со стандартного ввода функцией input(). Напомним, что для двух строк определена операция сложения (конкатенации), также определена операция умножения строки на число.

Строка состоит из последовательности символов. Узнать количество символов (длину строки) можно при помощи функции len.

Любой другой объект в Питоне можно перевести к строке, которая ему соответствует. Для этого нужно вызвать функцию str(), передав ей в качестве параметра объект, переводимый в строку.

На самом деле каждая строка, с точки зрения Питона, — это объект класса str. Чтобы получить по объекту другой объект другого класса, как-то ему соответствующий, можно использовать функцию приведения. Имя этой функции совпадает с именем класса, к которому мы приводим объект. (Для знатоков: эта функция — это конструктор объектов данного класса.) Пример: int — класс для целых чисел. Перевод строки в число осуществляется функцией

int().

What is the answer?
42

s = input()
print(len(s))
t = input()
number = int(t)
u = str(number)
print(s * 3)
print(s + ' ' + u)

2. Срезы (slices)

Срез (slice) — извлечение из данной строки одного символа или некоторого фрагмента подстроки или подпоследовательности.

Есть три формы срезов. Самая простая форма среза: взятие одного символа строки, а именно, S[i] — это срез, состоящий из одного символа, который имеет номер i. При этом считается, что нумерация начинается с числа 0. То есть если S = 'Hello', то S[0] == 'H', S[1] == 'e', S[2] == 'l', S[3] == 'l', S[4] == 'o'.

Заметим, что в Питоне нет отдельного типа для символов строки. Каждый объект, который получается в результате среза S[i] — это тоже строка типа str.

Номера символов в строке (а также в других структурах данных: списках, кортежах) называются

индексом.

Если указать отрицательное значение индекса, то номер будет отсчитываться с конца, начиная с номера -1. То есть S[-1] == 'o', S[-2] == 'l', S[-3] == 'l', S[-4] == 'e', S[-5] == 'H'.

Или в виде таблицы:

Строка 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), можно взять срез S[1:]. Аналогично если опустить первый параметр, то можно взять срез от начала строки. То есть удалить из строки последний символ можно при помощи среза S[:-1]. Срез S[:] совпадает с самой строкой S.

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

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

Если задать срез с тремя параметрами

S[a:b:d], то третий параметр задает шаг, как в случае с функцией range, то есть будут взяты символы с индексами a, a + d, a + 2 * d и т. д. При задании значения третьего параметра, равному 2, в срез попадет кажый второй символ, а если взять значение среза, равное -1, то символы будут идти в обратном порядке. Например, можно перевернуть строку срезом S[::-1].

	
s = 'abcdefg'
print(s[1])
print(s[-1])
print(s[1:3])
print(s[1:-1])
print(s[:3])
print(s[2:])
print(s[:-1])
print(s[::2])
print(s[1::2])
print(s[::-1])
3. Методы 
Метод — это функция, применяемая к объекту, в данном случае — к строке.
Метод вызывается в виде Имя_объекта.Имя_метода(параметры).
Например, S.find("e") — это применение к строке S метода find с одним параметром "e".
3.1. Методы 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, а не индекс относительно среза.
3.2. Метод replace 
Метод replace заменяет все вхождения одной строки на другую. Формат: S.replace(old, new) — заменить в строке S все вхождения подстроки old на подстроку new. Пример:
	
print('Hello'.replace('l', 'L'))
# вернёт 'HeLLo'
Если методу replace задать еще один параметр: S.replace(old, new, count),
то заменены будут не все вхождения, а только не больше, чем первые count из них.
	
print('Abrakadabra'.replace('a', 'A', 2))
# вернёт 'AbrAkAdabra'
3.3. Метод count 
Подсчитывает количество вхождений одной строки в другую строку. Простейшая
форма вызова S.count(T)  возвращает число вхождений строки T внутри строки S. При этом подсчитываются только
непересекающиеся вхождения, например:
  
	
print('Abracadabra'.count('a'))
# вернёт 4
print(('a' * 10).count('aa'))
# вернёт 5
При указании трех параметров S.count(T, a, b),
будет выполнен подсчет числа вхождений строки T в срезе S[a:b].
 Ссылки на задачи доступны в меню слева. Эталонные решения теперь доступны на странице самой задачи. 
работа со строками, форматирование,методы split, strip
В уроке по присвоению типа переменной в Python вы могли узнать, как определять строки: объекты, состоящие из последовательности символьных данных. Обработка строк неотъемлемая частью программирования на python. Крайне редко приложение, не использует строковые типы данных.
Из этого урока вы узнаете: Python предоставляет большую коллекцию операторов, функций и методов для работы со строками. Когда вы закончите изучение этой документации, узнаете, как получить доступ и извлечь часть строки, а также познакомитесь с методами, которые доступны для манипулирования и изменения строковых данных.
 
Ниже рассмотрим операторы, методы и функции, доступные для работы с текстом.
Строковые операторы
Вы уже видели операторы + и * в применении их к числовым значениям в уроке по операторам в Python . Эти два оператора применяются и к строкам.
Оператор сложения строк 
+
+ — оператор конкатенации строк. Он возвращает строку, состоящую из других строк, как показано здесь:
>>> s = 'py'
>>> t = 'th'
>>> u = 'on'

>>> s + t
'pyth'
>>> s + t + u
'python'

>>> print('Привет, ' + 'Мир!')
Go team!!!
Оператор умножения строк 
*
* — оператор создает несколько копий строки. Если s это строка, а n целое число, любое из следующих выражений возвращает строку, состоящую из n объединенных копий s:
 
s * n
n * s
Вот примеры умножения строк:
>>> s = 'py.'

>>> s * 4
'py.py.py.py.'
>>> 4 * s
'py.py.py.py.'
Значение множителя n должно быть целым положительным числом. Оно может быть нулем или отрицательным, но этом случае результатом будет пустая строка:
>>> 'py' * -6
''
Если вы создадите строковую переменную и превратите ее в пустую строку, с помощью 'py' * -6, кто-нибудь будет справедливо считать вас немного глупым. Но это сработает.
Оператор принадлежности подстроки 
in
Python также предоставляет оператор принадлежности, который можно использоваться для манипуляций со строками. Оператор in возвращает True, если подстрока входит в строку, и False, если нет:
>>> s = 'Python'
>>> s in 'I love Python.'
True
>>> s in 'I love Java.'
False
 
Есть также оператор not in, у которого обратная логика:
>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
False
Встроенные функции строк в python
Python предоставляет множество функций, которые встроены в интерпретатор. Вот несколько, которые работают со строками:
Функция
Описание
chr()
Преобразует целое число в символ
ord()
Преобразует символ в целое число
len()
Возвращает длину строки
str()
Изменяет тип объекта на string
Более подробно о них ниже.
Функция ord(c) возвращает числовое значение для заданного символа.
На базовом уровне компьютеры хранят всю информацию в виде цифр. Для представления символьных данных используется схема перевода, которая содержит каждый символ с его репрезентативным номером.
Самая простая схема в повседневном использовании называется ASCII . Она охватывает латинские символы, с которыми мы чаще работает. Для этих символов ord(c) возвращает значение ASCII для символа c:
>>> ord('a')
97
>>> ord('#')
35
ASCII прекрасен, но есть много других языков в мире, которые часто встречаются. Полный набор символов, которые потенциально могут быть представлены в коде, намного больше обычных латинских букв, цифр и символом.
Unicode — это современный стандарт, который пытается предоставить числовой код для всех возможных символов, на всех возможных языках, на каждой возможной платформе. Python 3 поддерживает Unicode, в том числе позволяет использовать символы Unicode в строках.
Функция ord() также возвращает числовые значения для символов Юникода:
>>> ord('€')
8364
>>> ord('∑')
8721
Функция chr(n) возвращает символьное значение для данного целого числа.
chr() действует обратно ord(). Если задано числовое значение n, chr(n) возвращает строку, представляющую символ n:
>>> chr(97)
'a'
>>> chr(35)
'#'
chr() также обрабатывает символы Юникода:
>>> chr(8364)
'€'
>>> chr(8721)
'∑'
Функция len(s) возвращает длину строки.
len(s) возвращает количество символов в строке s:
>>> s = 'Простоя строка.'
>>> len(s)
15
Функция str(obj) возвращает строковое представление объекта.
Практически любой объект в Python может быть представлен как строка. str(obj) возвращает строковое представление объекта obj:
>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('py')
'py'
Индексация строк
Часто в языках программирования, отдельные элементы в упорядоченном наборе данных могут быть доступны с помощью числового индекса или ключа. Этот процесс называется индексация.
В Python строки являются упорядоченными последовательностями символьных данных и могут быть проиндексированы. Доступ к отдельным символам в строке можно получить, указав имя строки, за которым следует число в квадратных скобках [].
Индексация строк начинается с нуля: у первого символа индекс 0, следующего 1 и так далее. Индекс последнего символа в python — ‘‘длина строки минус один’’.
Например, схематическое представление индексов строки 'foobar' выглядит следующим образом:
Отдельные символы доступны по индексу следующим образом:
>>> s = 'foobar'

>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> s[5]
'r'
Попытка обращения по индексу большему чем len(s) - 1, приводит к ошибке IndexError:
>>> s[6]
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    s[6]
IndexError: string index out of range
Индексы строк также могут быть указаны отрицательными числами. В этом случае индексирование начинается с конца строки: -1 относится к последнему символу, -2 к предпоследнему и так далее. Вот такая же диаграмма, показывающая как положительные, так и отрицательные индексы строки 'foobar':
Вот несколько примеров отрицательного индексирования:
>>> s = 'foobar'
>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s)
6
>>> s[-len(s)] 
'f'
Попытка обращения по индексу меньшему чем -len(s), приводит к ошибке IndexError:
>>> s[-7]
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    s[-7]
IndexError: string index out of range
Для любой непустой строки s, код s[len(s)-1] и s[-1] возвращают последний символ. Нет индекса, который применим к пустой строке.
Срезы строк
Python также допускает возможность извлечения подстроки из строки, известную как ‘‘string slice’’. Если s это строка, выражение формы s[m:n] возвращает часть s, начинающуюся с позиции m, и до позиции n, но не включая позицию:
>>> s = 'python'
>>> s[2:5]
'tho'
Помните: индексы строк в python начинаются с нуля. Первый символ в строке имеет индекс 0. Это относится и к срезу.
Опять же, второй индекс указывает символ, который не включен в результат. Символ 'n' в приведенном выше примере. Это может показаться немного не интуитивным, но дает результат: выражение s[m:n] вернет подстроку, которая является разницей n - m, в данном случае 5 - 2 = 3.
Если пропустить первый индекс, срез начинается с начала строки. Таким образом, s[:m] = s[0:m]:
>>> s = 'python'
>>> s[:4]
'pyth'
>>> s[0:4]
'pyth'
Аналогично, если опустить второй индекс s[n:], срез длится от первого индекса до конца строки. Это хорошая, лаконичная альтернатива более громоздкой s[n:len(s)]:
>>> s = 'python'
>>> s[2:]
'thon'
>>> s[2:len(s)]
'thon'
Для любой строки s и любого целого n числа (0 ≤ n ≤ len(s)), s[:n] + s[n:]будет s:
>>> s = 'python'
>>> s[:4] + s[4:]
'python'
>>> s[:4] + s[4:] == s
True
Пропуск обоих индексов возвращает исходную строку. Это не копия, это ссылка на исходную строку:
>>> s = 'python'
>>> t = s[:]
>>> id(s)
59598496
>>> id(t)
59598496
>>> s is t
True
Если первый индекс в срезе больше или равен второму индексу, Python возвращает пустую строку. Это еще один не очевидный способ сгенерировать пустую строку, если вы его искали:
>>> s[2:2]
''
>>> s[4:2]
''
Отрицательные индексы можно использовать и со срезами. Вот пример кода Python:
>>> s = 'python'
>>> s[-5:-2]
'yth'
>>> s[1:4]
'yth'
>>> s[-5:-2] == s[1:4]
True
Шаг для среза строки
Существует еще один вариант синтаксиса среза, о котором стоит упомянуть. Добавление дополнительного : и третьего индекса означает шаг, который указывает, сколько символов следует пропустить после извлечения каждого символа в срезе.
Например , для строки 'python' срез 0:6:2 начинается с первого символа и заканчивается последним символом (всей строкой), каждый второй символ пропускается. Это показано на следующей схеме:
Иллюстративный код показан здесь:
>>> s = 'foobar'
>>> s[0:6:2]
'foa'
>>> s[1:6:2]
'obr'
Как и в случае с простым срезом, первый и второй индексы могут быть пропущены:
>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'
Вы также можете указать отрицательное значение шага, в этом случае Python идет с конца строки. Начальный/первый индекс должен быть больше конечного/второго индекса:
>>> s = 'python'
>>> s[5:0:-2]
'nhy'
В приведенном выше примере, 5:0:-2 означает «начать с последнего символа и делать два шага назад, но не включая первый символ.”
Когда вы идете назад, если первый и второй индексы пропущены, значения по умолчанию применяются так: первый индекс — конец строки, а второй индекс — начало. Вот пример:
>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::-5]
'55555'
Это общая парадигма для разворота (reverse) строки:
>>> s = 'Если так говорит товарищ Наполеон, значит, так оно и есть.'
>>> s[::-1]
'.ьтсе и оно кат ,тичанз ,ноелопаН щиравот тировог кат илсЕ'
Форматирование строки
В Python версии 3.6 был представлен новый способ форматирования строк. Эта функция официально названа литералом отформатированной строки, но обычно упоминается как f-string.
Возможности форматирования строк огромны и не будут подробно описана здесь.
Одной простой особенностью f-строк, которые вы можете начать использовать сразу, является интерполяция переменной. Вы можете указать имя переменной непосредственно в f-строковом литерале (f'string'), и python заменит имя соответствующим значением.
Например, предположим, что вы хотите отобразить результат арифметического вычисления. Это можно сделать с помощью простого print() и оператора ,, разделяющего числовые значения и строковые:
>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('Произведение', n, 'на', m, 'равно', prod)
Произведение 20 на 25 равно 500
Но это громоздко. Чтобы выполнить то же самое с помощью f-строки:
Напишите f или F перед кавычками строки. Это укажет python, что это f-строка вместо стандартной.
Укажите любые переменные для воспроизведения в фигурных скобках ({}).
Код с использованием f-string, приведенный ниже выглядит намного чище:
>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print(f'Произведение {n} на {m} равно {prod}')
Произведение 20 на 25 равно 500
Любой из трех типов кавычек в python можно использовать для f-строки:
>>> var = 'Гав'
>>> print(f'Собака говорит {var}!')
Собака говорит Гав!
>>> print(f"Собака говорит {var}!")
Собака говорит Гав!
>>> print(f'''Собака говорит {var}!''')
Собака говорит Гав!
Изменение строк
Строки — один из типов данных, которые Python считает неизменяемыми, что означает невозможность их изменять. Как вы ниже увидите, python дает возможность изменять (заменять и перезаписывать) строки.
Такой синтаксис приведет к ошибке TypeError:
>>> s = 'python'
>>> s[3] = 't'
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    s[3] = 't'
TypeError: 'str' object does not support item assignment
На самом деле нет особой необходимости изменять строки. Обычно вы можете легко сгенерировать копию исходной строки с необходимыми изменениями. Есть минимум 2 способа сделать это в python. Вот первый:
>>> s = s[:3] + 't' + s[4:]
>>> s
'pytton'
Есть встроенный метод string.replace(x, y):
>>> s = 'python'
>>> s = s.replace('h', 't')
>>> s
'pytton'
Читайте дальше о встроенных методах строк!
Встроенные методы строк в python
В руководстве по типам переменных в python вы узнали, что Python — это объектно-ориентированный язык. Каждый элемент данных в программе python является объектом.
Вы также знакомы с функциями: самостоятельными блоками кода, которые вы можете вызывать для выполнения определенных задач.
Методы похожи на функции. Метод — специализированный тип вызываемой процедуры, тесно связанный с объектом. Как и функция, метод вызывается для выполнения отдельной задачи, но он вызывается только вместе с определенным объектом и знает о нем во время выполнения.
Синтаксис для вызова метода объекта выглядит следующим образом:
obj.foo(<args>)
Этот код вызывает метод .foo() объекта obj. <args> — аргументы, передаваемые методу (если есть).
Вы узнаете намного больше об определении и вызове методов позже в статьях про объектно-ориентированное программирование. Сейчас цель усвоить часто используемые встроенные методы, которые есть в python для работы со строками.
В приведенных методах аргументы, указанные в квадратных скобках ([]), являются необязательными.
Изменение регистра строки
Методы этой группы выполняют преобразование регистра строки.
string.capitalize() приводит первую букву в верхний регистр, остальные в нижний.
s.capitalize() возвращает копию s с первым символом, преобразованным в верхний регистр, и остальными символами, преобразованными в нижний регистр:
>>> s = 'everyTHing yoU Can IMaGine is rEAl'
>>> s.capitalize()
'Everything you can imagine is real'
Не алфавитные символы не изменяются:
>>> s = 'follow us @PYTHON'
>>> s.capitalize()
'Follow us @python'
string.lower() преобразует все буквенные символы в строчные.
s.lower() возвращает копию s со всеми буквенными символами, преобразованными в нижний регистр:
>>> 'everyTHing yoU Can IMaGine is rEAl'.lower()
'everything you can imagine is real'
string.swapcase() меняет регистр буквенных символов на противоположный.
s.swapcase() возвращает копию s с заглавными буквенными символами, преобразованными в строчные и наоборот:
>>> 'everyTHing yoU Can IMaGine is rEAl'.swapcase()
'EVERYthING YOu cAN imAgINE IS ReaL'
string.title() преобразует первые буквы всех слов в заглавные
s.title() возвращает копию, s в которой первая буква каждого слова преобразуется в верхний регистр, а остальные буквы — в нижний регистр:
>>> 'the sun also rises'.title()
'The Sun Also Rises'
Этот метод использует довольно простой алгоритм. Он не пытается различить важные и неважные слова и не обрабатывает апострофы, имена или аббревиатуры:
>>> 'follow us @PYTHON'.title()
'Follow Us @Python'
string.upper() преобразует все буквенные символы в заглавные.
s.upper() возвращает копию s со всеми буквенными символами в верхнем регистре:
>>> 'follow us @PYTHON'.upper()
'FOLLOW US @PYTHON'
Найти и заменить подстроку в строке
Эти методы предоставляют различные способы поиска в целевой строке указанной подстроки.
Каждый метод в этой группе поддерживает необязательные аргументы <start> и <end> аргументы. Они задают диапазон поиска: действие метода ограничено частью целевой строки, начинающейся в позиции символа <start> и продолжающейся вплоть до позиции символа <end>, но не включая его. Если <start> указано, а <end> нет, метод применяется к части строки от <start> конца.
string.count(<sub>[, <start>[, <end>]]) подсчитывает количество вхождений подстроки в строку.
s.count(<sub>) возвращает количество точных вхождений подстроки <sub> в s:
>>> 'foo goo moo'.count('oo')
3
Количество вхождений изменится, если указать <start> и <end>:
>>> 'foo goo moo'.count('oo', 0, 8)
2
string.endswith(<suffix>[, <start>[, <end>]]) определяет, заканчивается ли строка заданной подстрокой.
s.endswith(<suffix>) возвращает, True если s заканчивается указанным <suffix> и False если нет:
>>> 'python'.endswith('on')
True
>>> 'python'.endswith('or')
False
Сравнение ограничено подстрокой, между <start> и <end>, если они указаны:
>>> 'python'.endswith('yt', 0, 4)
True
>>> 'python'.endswith('yt', 2, 4)
False
string.find(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку.
s.find(<sub>) возвращает первый индекс в s который соответствует началу строки <sub>:
>>> 'Follow Us @Python'.find('Us')
7
Этот метод возвращает, -1 если указанная подстрока не найдена:
>>> 'Follow Us @Python'.find('you')
-1
Поиск в строке ограничивается подстрокой, между <start> и <end>, если они указаны:
>>> 'Follow Us @Python'.find('Us', 4)
7
>>> 'Follow Us @Python'.find('Us', 4, 7)
-1
string.index(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку.
Этот метод идентичен .find(), за исключением того, что он вызывает исключение ValueError, если <sub> не найден:
>>> 'Follow Us @Python'.index('you')
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    'Follow Us @Python'.index('you')
ValueError: substring not found
string.rfind(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку, начиная с конца.
s.rfind(<sub>) возвращает индекс последнего вхождения подстроки <sub> в s, который соответствует началу <sub>:
>>> 'Follow Us @Python'.rfind('o')
15
Как и в .find(), если подстрока не найдена, возвращается -1:
>>> 'Follow Us @Python'.rfind('a')
-1
Поиск в строке ограничивается подстрокой, между <start> и <end>, если они указаны:
>>> 'Follow Us @Python'.rfind('Us', 0, 14)
7
>>> 'Follow Us @Python'.rfind('Us', 9, 14)
-1
string.rindex(<sub>[, <start>[, <end>]]) ищет в строке заданную подстроку, начиная с конца.
Этот метод идентичен .rfind(), за исключением того, что он вызывает исключение ValueError, если <sub> не найден:
>>> 'Follow Us @Python'.rindex('you')
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    'Follow Us @Python'.rindex('you')
ValueError: substring not found
string.startswith(<prefix>[, <start>[, <end>]]) определяет, начинается ли строка с заданной подстроки.
s.startswith(<suffix>) возвращает, True если s начинается с указанного <suffix> и False если нет:
>>> 'Follow Us @Python'.startswith('Fol')
True
>>> 'Follow Us @Python'.startswith('Go')
False
Сравнение ограничено подстрокой, между <start> и <end>, если они указаны:
>>> 'Follow Us @Python'.startswith('Us', 7)
True
>>> 'Follow Us @Python'.startswith('Us', 8, 16)
False
Классификация строк
Методы в этой группе классифицируют строку на основе символов, которые она содержит.
string.isalnum() определяет, состоит ли строка из букв и цифр.
s.isalnum() возвращает True, если строка s не пустая, а все ее символы буквенно-цифровые (либо буква, либо цифра). В другом случае False :
>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False
string.isalpha() определяет, состоит ли строка только из букв.
s.isalpha() возвращает True, если строка s не пустая, а все ее символы буквенные. В другом случае False:
>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False
string.isdigit() определяет, состоит ли строка из цифр (проверка на число).
s.digit() возвращает True когда строка s не пустая и все ее символы являются цифрами, а в False если нет:
>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False
string.isidentifier() определяет, является ли строка допустимым идентификатором Python.
s.isidentifier() возвращает True, если s валидный идентификатор (название переменной, функции, класса и т.д.) python, а в False если нет:
>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False
Важно: .isidentifier() вернет True для строки, которая соответствует зарезервированному ключевому слову python, даже если его нельзя использовать:
>>> 'and'.isidentifier()
True
Вы можете проверить, является ли строка ключевым словом Python, используя функцию iskeyword(), которая находится в модуле keyword. Один из возможных способов сделать это:
>>> from keyword import iskeyword
>>> iskeyword('and')
True
Если вы действительно хотите убедиться, что строку можно использовать как идентификатор python, вы должны проверить, что .isidentifier() = True и iskeyword() = False.
string.islower() определяет, являются ли буквенные символы строки строчными.
s.islower() возвращает True, если строка s не пустая, и все содержащиеся в нем буквенные символы строчные, а False если нет. Не алфавитные символы игнорируются:
>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False
string.isprintable() определяет, состоит ли строка только из печатаемых символов.
s.isprintable() возвращает, True если строка s пустая или все буквенные символы которые она содержит можно вывести на экран. Возвращает, False если s содержит хотя бы один специальный символ. Не алфавитные символы игнорируются:
>>> 'a\tb'.isprintable() 
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'a\nb'.isprintable() 
False
Важно: Это единственный .is****() метод, который возвращает True, если s пустая строка. Все остальные возвращаются False.
string.isspace() определяет, состоит ли строка только из пробельных символов.
s.isspace() возвращает True, если s не пустая строка, и все символы являются пробельными, а False, если нет.
Наиболее часто встречающиеся пробельные символы — это пробел ' ', табуляция '\t' и новая строка '\n':
>>> ' \t  \n '.isspace()
True
>>> ' a '.isspace()
False
Тем не менее есть несколько символов ASCII, которые считаются пробелами. И если учитывать символы Юникода, их еще больше:
>>> '\f\u2005\r'.isspace()
True
'\f' и '\r' являются escape-последовательностями для символов ASCII; '\u2005' это escape-последовательность для Unicode.
string.istitle() определяет, начинаются ли слова строки с заглавной буквы.
s.istitle() возвращает True когда s не пустая строка и первый алфавитный символ каждого слова в верхнем регистре, а все остальные буквенные символы в каждом слове строчные. Возвращает False, если нет:
>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True
string.isupper() определяет, являются ли буквенные символы строки заглавными.
s.isupper() возвращает True, если строка s не пустая, и все содержащиеся в ней буквенные символы являются заглавными, и в False, если нет. Не алфавитные символы игнорируются:
>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
False
Выравнивание строк, отступы
Методы в этой группе влияют на вывод строки.
string.center(<width>[, <fill>]) выравнивает строку по центру.
s.center(<width>) возвращает строку, состоящую из s выровненной по ширине <width>. По умолчанию отступ состоит из пробела ASCII:
>>> 'py'.center(10)
'    py    '
Если указан необязательный аргумент <fill>, он используется как символ заполнения:
>>> 'py'.center(10, '-')
'----py----'
Если s больше или равна <width>, строка возвращается без изменений:
>>> 'python'.center(2)
'python'
string.expandtabs(tabsize=8) заменяет табуляции на пробелы
s.expandtabs() заменяет каждый символ табуляции ('\t') пробелами. По умолчанию табуляция заменяются на 8 пробелов:
>>> 'a\tb\tc'.expandtabs()
'a       b       c'
>>> 'aaa\tbbb\tc'.expandtabs()
'aaa     bbb     c'
tabsize необязательный параметр, задающий количество пробелов:
>>> 'a\tb\tc'.expandtabs(4)
'a   b   c'
>>> 'aaa\tbbb\tc'.expandtabs(tabsize=4)
'aaa bbb c'
string.ljust(<width>[, <fill>]) выравнивание по левому краю строки в поле.
s.ljust(<width>) возвращает строку s, выравненную по левому краю в поле шириной <width>. По умолчанию отступ состоит из пробела ASCII:
>>> 'python'.ljust(10)
'python    '
Если указан аргумент <fill> , он используется как символ заполнения:
>>> 'python'.ljust(10, '-')
'python----'
Если s больше или равна <width>, строка возвращается без изменений:
>>> 'python'.ljust(2)
'python'
string.lstrip([<chars>]) обрезает пробельные символы слева
s.lstrip()возвращает копию s в которой все пробельные символы с левого края удалены:
>>> '   foo bar baz   '.lstrip()
'foo bar baz   '
>>> '\t\nfoo\t\nbar\t\nbaz'.lstrip()
'foo\t\nbar\t\nbaz'
Необязательный аргумент <chars>, определяет набор символов, которые будут удалены:
>>> 'https://www.pythonru.com'.lstrip('/:pths')
'www.pythonru.com'
string.replace(<old>, <new>[, <count>]) заменяет вхождения подстроки в строке.
s.replace(<old>, <new>) возвращает копию s где все вхождения подстроки <old>, заменены на <new>:
>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love')
'I love python! I love python! I love python!'
Если указан необязательный аргумент <count>, выполняется количество <count> замен:
>>> 'I hate python! I hate python! I hate python!'.replace('hate', 'love', 2)
'I love python! I love python! I hate python!'
string.rjust(<width>[, <fill>]) выравнивание по правому краю строки в поле.
s.rjust(<width>) возвращает строку s, выравненную по правому краю в поле шириной <width>. По умолчанию отступ состоит из пробела ASCII:
>>> 'python'.rjust(10)
'    python'
Если указан аргумент <fill> , он используется как символ заполнения:
>>> 'python'.rjust(10, '-')
'----python'
Если s больше или равна <width>, строка возвращается без изменений:
>>> 'python'.rjust(2)
'python'
string.rstrip([<chars>]) обрезает пробельные символы справа
s.rstrip() возвращает копию s без пробельных символов, удаленных с правого края:
>>> '   foo bar baz   '.rstrip()
'   foo bar baz'
>>> 'foo\t\nbar\t\nbaz\t\n'.rstrip()
'foo\t\nbar\t\nbaz'
Необязательный аргумент <chars>, определяет набор символов, которые будут удалены:
>>> 'foo.$$$;'.rstrip(';$.')
'foo'
string.strip([<chars>]) удаляет символы с левого и правого края строки.
s.strip() эквивалентно последовательному вызову s.lstrip()и s.rstrip(). Без аргумента <chars> метод удаляет пробелы в начале и в конце:
>>> s = '   foo bar baz\t\t\t'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'
Как в .lstrip() и .rstrip(), необязательный аргумент <chars> определяет набор символов, которые будут удалены:
>>> 'www.pythonru.com'.strip('w.moc')
'pythonru'
Важно: Когда возвращаемое значение метода является другой строкой, как это часто бывает, методы можно вызывать последовательно:
>>> '   foo bar baz\t\t\t'.lstrip().rstrip()
'foo bar baz'
>>> '   foo bar baz\t\t\t'.strip()
'foo bar baz'

>>> 'www.pythonru.com'.lstrip('w.').rstrip('.moc')
'pythonru'
>>> 'www.pythonru.com'.strip('w.moc')
'pythonru'
string.zfill(<width>) дополняет строку нулями слева.
s.zfill(<width>) возвращает копию s дополненную '0' слева для достижения длины строки указанной в <width>:
>>> '42'.zfill(5)
'00042'
Если s содержит знак перед цифрами, он остается слева строки:
>>> '+42'.zfill(8)
'+0000042'
>>> '-42'.zfill(8)
'-0000042'
Если s больше или равна <width>, строка возвращается без изменений:
>>> '-42'.zfill(3)
'-42'
.zfill() наиболее полезен для строковых представлений чисел, но python с удовольствием заполнит строку нулями, даже если в ней нет чисел:
>>> 'foo'.zfill(6)
'000foo'
Методы преобразование строки в список
Методы в этой группе преобразовывают строку в другой тип данных и наоборот. Эти методы возвращают или принимают итерируемые объекты — термин Python для последовательного набора объектов.
Многие из этих методов возвращают либо список, либо кортеж. Это два похожих типа данных, которые являются прототипами примеров итераций в python. Список заключен в квадратные скобки ( []), а кортеж заключен в простые (()).
Теперь давайте посмотрим на последнюю группу строковых методов.
string.join(<iterable>) объединяет список в строку.
s.join(<iterable>) возвращает строку, которая является результатом конкатенации объекта <iterable> с разделителем s.
Обратите внимание, что .join() вызывается строка-разделитель s . <iterable> должна быть последовательностью строковых объектов.
Примеры кода помогут вникнуть. В первом примере разделителем s является строка ', ', а <iterable> список строк:
>>> ', '.join(['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'
В результате получается одна строка, состоящая из списка объектов, разделенных запятыми.
В следующем примере <iterable> указывается как одно строковое значение. Когда строковое значение используется в качестве итерируемого, оно интерпретируется как список отдельных символов строки:
>>> list('corge')
['c', 'o', 'r', 'g', 'e']

>>> ':'.join('corge')
'c:o:r:g:e'
Таким образом, результатом ':'.join('corge') является строка, состоящая из каждого символа в 'corge', разделенного символом ':'.
Этот пример завершается с ошибкой TypeError, потому что один из объектов в <iterable> не является строкой:
>>> '---'.join(['foo', 23, 'bar'])
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    '---'.join(['foo', 23, 'bar'])
TypeError: sequence item 1: expected str instance, int found
Это можно исправить так:
>>> '---'.join(['foo', str(23), 'bar'])
'foo---23---bar'
Как вы скоро увидите, многие объекты в Python можно итерировать, и .join() особенно полезен для создания из них строк.
string.partition(<sep>) делит строку на основе разделителя.
s.partition(<sep>) отделяет от s подстроку длиной от начала до первого вхождения <sep>. Возвращаемое значение представляет собой кортеж из трех частей:
Часть s до <sep>
Разделитель <sep>
Часть s после <sep>
Вот пара примеров .partition()в работе:
>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')
Если <sep> не найден в s, возвращаемый кортеж содержит s и две пустые строки:
>>> 'foo.bar'.partition('@@')
('foo.bar', '', '')
s.rpartition(<sep>) делит строку на основе разделителя, начиная с конца.
s.rpartition(<sep>) работает как s.partition(<sep>), за исключением того, что s делится при последнем вхождении <sep> вместо первого:
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')

>>> 'foo@@bar@@baz'.rpartition('@@')
('foo@@bar', '@@', 'baz')
string.rsplit(sep=None, maxsplit=-1) делит строку на список из подстрок.
Без аргументов s.rsplit() делит s на подстроки, разделенные любой последовательностью пробелов, и возвращает список:
>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foo\n\tbar   baz\r\fqux'.rsplit()
['foo', 'bar', 'baz', 'qux']
Если <sep> указан, он используется в качестве разделителя:
>>> 'foo.bar.baz.qux'.rsplit(sep='.')
['foo', 'bar', 'baz', 'qux']
Если <sep> = None, строка разделяется пробелами, как если бы <sep> не был указан вообще.
Когда <sep> явно указан в качестве разделителя s, последовательные повторы разделителя будут возвращены как пустые строки:
>>> 'foo...bar'.rsplit(sep='.')
['foo', '', '', 'bar']
Это не работает, когда <sep> не указан. В этом случае последовательные пробельные символы объединяются в один разделитель, и результирующий список никогда не будет содержать пустых строк:
>>> 'foo\t\t\tbar'.rsplit()
['foo', 'bar']
Если указан необязательный параметр <maxsplit>, выполняется максимальное количество разделений, начиная с правого края s:
>>> 'www.pythonru.com'.rsplit(sep='.', maxsplit=1)
['www.pythonru', 'com']
Значение по умолчанию для <maxsplit> — -1. Это значит, что все возможные разделения должны быть выполнены:
>>> 'www.pythonru.com'.rsplit(sep='.', maxsplit=-1)
['www', 'pythonru', 'com']
>>> 'www.pythonru.com'.rsplit(sep='.')
['www', 'pythonru', 'com']
string.split(sep=None, maxsplit=-1) делит строку на список из подстрок.
s.split() ведет себя как s.rsplit(), за исключением того, что при указании <maxsplit>, деление начинается с левого края s:
>>> 'www.pythonru.com'.split('.', maxsplit=1)
['www', 'pythonru.com']
>>> 'www.pythonru.com'.rsplit('.', maxsplit=1)
['www.pythonru', 'com']
Если <maxsplit> не указано, между .rsplit() и .split() в python разницы нет.
string.splitlines([<keepends>]) делит текст на список строк.
s.splitlines() делит s на строки и возвращает их в списке. Любой из следующих символов или последовательностей символов считается границей строки:
Разделитель
Значение
\n
Новая строка
\r
Возврат каретки
\r\n
Возврат каретки + перевод строки
\v или же \x0b
Таблицы строк
\f или же \x0c
Подача формы
\x1c
Разделитель файлов
\x1d
Разделитель групп
\x1e
Разделитель записей
\x85
Следующая строка
\u2028
Новая строка (Unicode)
\u2029
Новый абзац (Unicode)
Вот пример использования нескольких различных разделителей строк:
>>> 'foo\nbar\r\nbaz\fqux\u2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']
Если в строке присутствуют последовательные символы границы строки, они появятся в списке результатов, как пустые строки:
>>> 'foo\f\f\fbar'.splitlines()
['foo', '', '', 'bar']
Если необязательный аргумент <keepends> указан и его булевое значение True, то символы границы строк сохраняются в списке подстрок:
>>> 'foo\nbar\nbaz\nqux'.splitlines(True)
['foo\n', 'bar\n', 'baz\n', 'qux']
>>\> 'foo\nbar\nbaz\nqux'.splitlines(8)
['foo\n', 'bar\n', 'baz\n', 'qux']
Заключение
В этом руководстве было подробно рассмотрено множество различных механизмов, которые Python предоставляет для работы со строками, включая операторы, встроенные функции, индексирование, срезы и встроенные методы.
Python есть другие встроенные типы данных. В этих урока вы изучите два наиболее часто используемых:
Методы строк в Python для начинающих
Методы строк для начинающих
У строк в Python есть множество полезных методов для того, чтобы дать
возможность делать со строками различные полезные и нужные действия.
Методы похожи на функции, из тоже можно вызывать и, так же как и функции, они могут
возвращать результат своей работы. Отличие же методов в том, что они привязаны
к определенному типу данных и, например, методы строк могут быть вызваны только
у строк.
Все методы строк можно посмотреть в нашем справочнике, а вот несколько примеров того,
как вызывать методы строк.
string = "Hello world!"
print(string.lower())  # hello world!
print(string.upper())  # HELLO WORLD!
Начинающему программисту важно помнить, что методы не меняют исходную строку. Строки в Python
вообще нельзя изменить.
Если вы хотите поменять все ее символы, например, на символы нижнего регистра, нужно
присвоить строке новое значение
string = "Hello world!"
string = string.lower()
Индексы строк
Бывает так, что иногда появляется необходимость выбирать отдельные символы из строки. В Python для этого необходимо использовать квадратные скобки. В таблице ниже приведены примеры получения символа строки по индексу строки Python, помещенной в переменную string.
Код
Результат
Описание
s[0]
P
Первый символ
s[1]
y
Второй символ
s[-1]
n
Последний символ
s[-2]
o
Предпоследний символ
Как вы видите, необходимо учитывать, что номером индекса первого символа будет [0]
Отрицательный индекс будет отсчитывать символы с конца строки.
Распространенная ошибка: предположим, что мы пытаемся задать индекс s[12]. Но в примере выше мы имеем всего шесть элементов строки, и логично что Python выдаст ошибку следующего содержания:
IndexError: string index out of range
Срезы строк
Срез используется для выделения части строки. Он состоит из индекса и диапазона. Ниже расположены несколько примеров со строкой
string = 'абвгдежзик'
Индекс
0 1 2 3 4 5 6 7 8 9
Символ
а б в г д е ж з и к
Фрагмент кода
Результат
Описание
string[ 2 : 5 ]
вгд
Символы с индексом 2, 3, 4
string[ : 5 ]
абвгд
Первые пять символов
string[ 5 : ]
ежзик
Символы, начиная с индекса 5 и до конца
string[ −2 : ]
ик
Последние два символа
string[ : ]
абвгдежзик
Вся строка
string[1 : 7 : 2]
бге
Со второго по шестой символы, через один
string[ : : −1 ]
кизжедгвба
Обратный шаг, строка наоборот
Базовая структура среза выглядит следующим образом:
Строка[начальный_символ : конечный_символ + 1]
Срезы не включают явное расположение окончания строки. Например, в приведенном выше примере string[2 : 5], Python выведет символы с индексами 2, 3 и 4, но не символ с индексом 5.
Мы можем оставить, вместо индекса начала или окончания строки, пустоту. Пустота на месте индекса начала будет по умолчанию равна нулю. Итак, string[: 5] выведет первые пять символов строки string. А в случае string[5 :], Python покажет символы, начиная с индекса 5 и до конца строки. Если же использовать отрицательные индексы, мы получим символы с конца строки. Например, string[-2 :] — это последние два символа.
Также существует необязательный третий аргумент, который указывает на шаг среза строки. Например, string[1 : 7 : 2] берет каждый второй символ из строки с индексом 1, 3 и 5.
Индексация строк | Python
 Доступ к символам в строках основан на операции индексирования – после строки или имени переменной, ссылающейся на строку, в квадратных скобках указываются номера позиций необходимых символов.
 Так же следует понимать, что этот самый доступ, основан на смещении, т.е. расстоянии символов от левого или правого края строки. Данное расстояние измеряется целыми числами и по сути определяет номер позиции символов в строке – их индекс. Подвох заключается в словосочетании «измеряется целыми числами«, а это означает, что индекс может быть как положительным так и отрицательным: положительные индексы – это отсчет от левого края, а отрицательные – от правого. Причем отсчет символов от левого края начинается с \(0\), а с правого начинается с \(-1\) (минус единицы).
 В самом простом случае можно извлеч один произвольный символ:
>>> 'string'[0]
's'
>>> 
>>> 'string'[5]
'g'
>>> 
>>> 
>>> s = 'STRING'
>>> 
>>> s[0]
'S'
>>> 
>>> s[5]
'G'
 Так же мы можем извлеч срез – последовательность символов внутри исходной строки, которую еще иногда называют подстрокой:
>>> s = 'AAA***BBB^^^'
>>> 
>>> s[0:3]
'AAA'
>>> 
>>> s[3:6]
'***'
>>> 
>>> s[9:12]
'^^^'
 А еще мы можем извлекать символы из строки или среза с указанным шагом:
>>> s = 'a0-b1-c2-d3-e4-f5-g6'
>>> 
>>> s[::3]
'abcdefg' 
>>> 
>>> s[1::3]
'0123456' 
>>> 
>>> s[2::3]
'------'
>>> 
>>> 
>>> s[3:12:3]
'bcd'
>>> s[9:1:-3]
'dcb'
 Как видите, с одной стороны – все вроде бы просто, но с другой – особенно глядя на последние примеры, становится понятно, что какие-то сложности все-таки есть. Давайте разберемся по порядку.
 Извлечение символов — S[i] 
 Извлечение одного символа из строки – это, действительно, самый простой случай. Давайте снова рассмотрим строку:
>>> s = 'STRING'
 Что бы извлеч символы ‘S‘, ‘R‘ и ‘G‘ мы можем выполнить следующие простые операции:
>>> s[0], s[2], s[5]
('S', 'R', 'G')
 Но так как мы уже знаем, что индексы могут быть отрицательными, т.е. отсчитываться от конца строки, то для извлечения тех же символов мы можем выполнить и такие операции:
>>> s[-6], s[-4], s[-1]
('S', 'R', 'G')
 Отрицательные и положительные индексы символов могут быть выражены через длину строки:
>>> s[4], s[-2]
('N', 'N')
>>> 
>>> s[len(s) - 2], s[4 - len(s)]
('N', 'N')
 Визуально отображение индексов на символы строки выглядит вот так:
 
 Если указать индекс, который выходит за пределы строки, то это приведет к ошибке:
>>> s[10], s[-10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
 Отсутствие индекса, так же считается ошибкой.
 Извлечение срезов — S[i:j] 
 Извлечение срезов строк выполняется по двум индексам, которые разделяются двоеточием:
>>> s = '*a*bb*ccc*dddd*'
>>> 
>>> s[1:2]
'a'
>>> 
>>> s[3:5]
'bb'
>>> 
>>> s[6:9]
'ccc'
>>> 
>>> s[10:14]
'dddd'
 Обратите внимание на то, что срез начинается с символа, индекс которого указан первым, а заканчивается перед символом, индекс которого указан вторым:
 
 Тех же результатов можно добиться если указывать отрицательные индексы:
>>> s[-14:-13], s[-12:-10], s[-9:-6], s[-5:-1]
('a', 'bb', 'ccc', 'dddd')
 Во всех предыдущих примерах первый индекс всегда был меньше второго, но если вдруг окажется наоборот, то это не приведет к ошибке, а возвратит пустую строку:
>>> s[5:1]
''
>>> s[-10:-14]
''
 И даже, если индексы окажутся равны, мы все равно увидим пустую строку вместо сообщения об ошибке:
>>> s[1:1]
''
>>> s[-14:-14]
''
 Появится ли сообщение об ошибке если не указать индексы вообще? Нет, вместо этого мы увидим всю строку целиком:
>>> s[:]
'*a*bb*ccc*dddd*'
 Такое поведение связано с тем, что индексы начала и конца среза имеют значения по умолчанию: начало – всегда \(0\), конец – всегда len(s). Так что команда s[:] является эквивалентной команде s[0:len(s)]. Наличие таких предустановленных значений является весьма удобным, если мы хотим извлекать срезы от начала строки до указанного символа, или от некоторого символа до конца строки:
>>> s = '*a*bb*ccc*dddd*'
>>> 
>>> s[:2]    #  эквивалентно s[:-13]
'*a'
>>> 
>>> s[:5]    #  эквивалентно s[:-10]
'*a*bb'
>>> 
>>> s[:-1]    #  эквивалентно s[:14]
'*a*bb*ccc*dddd'
>>> 
>>> s[-3:]    #  эквивалентно s[12:]
'dd*'
>>> 
>>> s[-10:]    #  эквивалентно s[5:]
'*ccc*dddd*'
 
 Снова, обратите внимание на то, что если срез извлекается от начала строки до указанного символа, то сам указанный символ в разрез не включается. А если срез извлекается от указанного символа до конца строки, то этот символ будет включен в начало среза. Такое поведение гарантирует что конкатенация двух таких срезов будет равна исходной строке:
>>> s = 'xxxxYYYY'
>>> 
>>> s[:4] + s[4:]
'xxxxYYYY'
>>> 
>>> s[:-3] + s[-3:]
'xxxxYYYY'
 Операция извлечения среза допускает указание индексов, выходящих за пределы строки:
>>> s = '*a*bb*ccc*dddd*'
>>> 
>>> s[:100]
'*a*bb*ccc*dddd*'
>>> 
>>> s[6:100]
'ccc*dddd*'
>>> 
>>> s[100:]
''
 Извлечение срезов с заданным шагом — S[i:j:k] 
 Что бы извлечь символы из среза с заданным шагом (их еще называют разреженные срезы), необходимо указать значение шага через двоеточие после операции извлечения среза:
>>> s = 'A1-B2-C3-D4-E5-'
>>> 
>>> s[3:12:3]
'BCD'
>>> 
>>> s[:9:2]
'A-2C-'
>>> 
>>> s[3::4]
'B3-'
>>> 
>>> s[::6]
'ACE'
 Очевидно, что тех же результатов мы добьемся если не будем менять значения шага, а значения индексов начала и конца среза поменяем на отрицательные:
>>> s[-12:-3:3], s[:-6:2], s[-12::4]
('BCD', 'A-2C-', 'B3-')
 Визуально все это можно представить вот так:
 
 В возвращаемой строке оказываются только те символы исходной строки, которые обозначены оранжевым цветом. Символы, обозначенные зеленым цветом, входят в состав указанного среза, но не соответствуют значению шага, поэтому мы и не видим их в результирующей строке.
 Величина шага имеет значение по умолчанию, равное \(1\) – это соответствует извлечению всех элементов подряд. А учитывая, что начало среза и его конец так же имеют установленные по умолчанию значения, равные \(0\) и len(s), то мы можем вообще ничего не указывать (кроме двух двоеточий, разумеется):
>>> s = 'A1-B2-C3-D4-E5-'
>>> 
>>> s[::]
'A1-B2-C3-D4-E5-'
 Может ли значение шага быть отрицательным? Да:
>>> 'ABCDEFG'[::-1]
'GFEDCBA'
>>> 
>>> 'ABCDEFG'[::-2]
'GECA'
 По сути, знак указанного числа в шаге указывает направление в котором выполняется извлечение символов из среза. Значение \(-1\) означает, что нужно извлеч каждый последующий символ, двигаясь от правого края к левому. А значение \(-2\) — извлеч каждый второй символ, так же двигаясь от конца к началу строки.
 Давайте выполним несколько примеров и посмотрим, как это можно наглядно представить:
>>> s = 'ABCDEFGHIJKLMNO'
>>> 
>>> s[::2]
'ACEGIKMO'
>>> 
>>> s[::-2]
'OMKIGECA'
>>> 
>>> s[::4]
'AEIM'
>>> 
>>> s[::-4]
'OKGC'
 
 Помните, мы говорили о том, что индекс начала среза должен быть меньше чем индекс его конца? На самом деле такая необходимость связана с направлением в котором извлекаются символы среза. По умолчанию, значение шага равняется \(1\) — это соответствует изъятию каждого символа в направлении от начала строки до ее конца. Именно поэтому мы ранее получали пустую строку, когда указывали левый индекс больше чем правый:
>>> s = 'ABCDEFGHIJKLMNO'
>>> 
>>> s[10:4]    #  по умолчанию шаг равен 1
''
 
 Глядя на пустую строку, котору вернул интерпретатор и картинку становится понятно, что что-то не так. Мы ясно видим, что извлечение начинается с индекса под номером \(10\), т.е. с символа «K» и даже несмотря на то, что извлечение происходит слева направо (так как по умолчанию шаг равен \(1\)), символ «K» просто обязан попасть в результирующую строку. Но его там нет!!!
 Настало время осознать, что индексы символов в строке и их смещения – это не одно и то же. Работая с последовательностями нам проще всего воспринимать индексы символов (номера их позиций) чем их смещений. Я даже уверен что после того как вы разберетесь со смещениями, вы все равно будете представлять себе индексы.
 Индексы и смещения символов 
 Что ж давайте сделаем небольшое отступление и попробуем разобраться. Вот уже знакомая нам строка:
>>> s = 'STRING'
 А вот так мы отображаем индексы на символы:
 
 Почему мы так делаем? Потому что это удобнее чем смещения:
 
 Говоря о смещениях, мы подразумеваем левую границу символов (левую сторону квадратов в которых они изображены на рисунках). Так, например, смещение символа «S» относительно левого края строки равно \(0\) т.е. он вообще не смещен, поэтому операция s[0] его и возвращает. А смещение символа «G» относительно правого края равно \(-1\), поэтому операция s[-1] возвращает «G«. На этом же принципе основаны и все другие операции индексирования, будь-то срезы или срезы с заданным шагом.
 Даже поняв, что такое смещения символов, вы все равно будете опираться на их индексы. Глазами, указателем мыши, пальцем, вы все равно будете отсчитывать непосредственно сами символы, а не их левые границы. Просто потому, что это удобно. Просто потому, что в подавляющем большинстве это прекрасно работает и не вызывает никаких проблем.
 Теперь, когда мы знаем, что такое смещения, нам гораздо проще понять почему операция s[4:2:1] возвращает пустую строку вместо символа «I«:
 
 Глядя на эту картинку, нам начинает казаться, что символ «I» с индексом \(4\) должен попасть в результирующую строку. Но интерпретатор Python ориентируется не по индексам, а смещениям и с его точки зрения все выглядит вот так:
 
 Так как символ «I» располагается перед смещением с номером \(4\), а отсчет ведется именно от смещений, то и в результирующей строке его быть не должно.
 Понимание того, что строки индексируются именно по смещениям символов, проливает свет на многие нюансы. Например, взятие среза от некоторого символа до конца строки:
>>> s[2:6]    #  эквивалентно s[2:]
'RING'
 Если посмотреть на эту операцию в контексте индексов, то можно утверждать, что мы указываем элемент с индексом \(6\), которого на самом деле не существует, но перед которым извлечение символов из строки должно остановиться.
 Если же посмотреть на эту операцию в контексте смещений, то говорить о каких-то не существующих вещах уже не придется. Все эти смещения существуют и именно с ними работает интерпретатор Python.
 Скорее всего, у вас возник вопрос по поводу того как работает операция s[::-1], ведь ее левый индекс по умолчанию равен \(0\), а правый – len(s), но даже не смотря на то, что извлечение символов должно выполняться справа налево, т.е. мы, по идее, должны увидеть пустую строку, мы видим, как все прекрасно работает:
>>> s = 'STRING'
>>> 
>>> s[::-1]
'GNIRTS'
>>> 
>>> s[::-2]
'GIT'
 Такое исключение из правил, создано намеренно, а именно – для удобства. Потому что это, действительно, удобнее чем каждый раз писать, что-то вроде s[len(s):0:-1] или s[len(s):0:-2].
 Отрицательное значение шага 
 Если мы хотим извлекать элементы из срезов строк в обратном порядке, то и границы срезов так же необходимо указывать в обратном порядке:
>>> s = 'ABCDEFGHIJKLMNO'
>>> 
>>> s[11:2:-2]
'LJHFD'
>>> 
>>> s[:4:-3]
'OLIF'
>>> 
>>> s[10::-4]
'KGC'
>>> 
>>> s[-3:-6:-7]
'M'
 
 Помните мы задавались вопросом о том, как работает операция s[::-1]? И был дан расплывчато-туманный ответ, что это яко бы просто техническая особенность, созданная для удобства. Так вот это действительно технически реализованный трюк, который заключается в том, установленные по умолчанию значения начала и конца среза (начало – \(0\), конец – len(s)) меняются местами, если величина шага имеет отрицательное значение:
>>> s[::2], s[0:len(s):2]
('ACEGIKMO', 'ACEGIKMO')
>>> 
>>> s = 'ABCDEFGHIJKLMNO'
>>> s[::-2], s[-1:-len(s)-1:-2]
('OMKIGECA', 'OMKIGECA')
 Возможно вы немного удивились, ожидая вместо команды s[-1:-len(s)-1:-2] увидеть команду s[len(s):0:-2]. Но если вспомнить, что символы извлекаются не по индексам, а по смещениям, так же вспомнив, что извлечение среза выполняется от первого указанного смещения до второго, то станет ясно, что команда s[len(s):0:-2] выдаст не то, что нужно:
>>> s[len(s):0:-2], s[::-2], s[-1:-len(s)-1:-2]
('OMKIGEC', 'OMKIGECA', 'OMKIGECA')
 В заключение, хочется напомнить о двух простых правилах из Дзена Python:
Простое лучше чем сложное;
Сложное лучше чем запутанное.
 Почему именно эти правила. Потому что вам может захотеться использовать в своем коде какие-то, так сказать, хитро-выдуманные трюки с индексированием. С одной стороны: «Почему бы и нет??? Ведь программирование – это еще и способ самовыражения!». Но с другой стороны – это еще замечательный способ вынести мозг и себе, и что хуже всего, другим людям. Так что, если вдруг, вы придумаете, каой-нибудь фокус с индексированием строк, то не поленитесь раскрыть его секрет в комментариях к коду.
 Сам по себе механизм индексирования устроен довольно просто. Тем не менее, даже из такой «простоты» можно слепить что-то вроде этого:
>>> sym = 'ABCDEFGHIJ'
>>> num = '1234567890'
>>> i = 2
>>> 
>>> sym[int(num[i])-len(sym):int(num[len(sym)-i])-i:int(num[i])]
'DG'
 Подобные фокусы имеют полное право на существование, но лучше их оставить для чемпионатов по программированию.
Строки. Функции и методы строк — Документация Python Summary 1
# Литералы строк
S = 'str'; S = "str"; S = '''str'''; S = """str"""
# Экранированные последовательности
S = "s\np\ta\nbbb"
# Неформатированные строки (подавляют экранирование)
S = r"C:\temp\new"
# Строка байтов
S = b"byte"
# Конкатенация (сложение строк)
S1 + S2
# Повторение строки
S1 * 3
# Обращение по индексу
S[i]
# Извлечение среза
S[i:j:step]
# Длина строки
len(S)
# Поиск подстроки в строке. Возвращает номер первого вхождения или -1
S.find(str, [start],[end])
# Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
S.rfind(str, [start],[end])
# Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
S.index(str, [start],[end])
# Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
S.rindex(str, [start],[end])
# Замена шаблона
S.replace(шаблон, замена)
# Разбиение строки по разделителю
S.split(символ)
# Состоит ли строка из цифр
S.isdigit()
# Состоит ли строка из букв
S.isalpha()
# Состоит ли строка из цифр или букв
S.isalnum()
# Состоит ли строка из символов в нижнем регистре
S.islower()
# Состоит ли строка из символов в верхнем регистре
S.isupper()
# Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы ('\f'), "новая строка" ('\n'), "перевод каретки" ('\r'), "горизонтальная табуляция" ('\t') и "вертикальная табуляция" ('\v'))
S.isspace()
# Начинаются ли слова в строке с заглавной буквы
S.istitle()
# Преобразование строки к верхнему регистру
S.upper()
# Преобразование строки к нижнему регистру
S.lower()
# Начинается ли строка S с шаблона str
S.startswith(str)
# Заканчивается ли строка S шаблоном str
S.endswith(str)
# Сборка строки из списка с разделителем S
S.join(список)
# Символ в его код ASCII
ord(символ)
# Код ASCII в символ
chr(число)
# Переводит первый символ строки в верхний регистр, а все остальные в нижний
S.capitalize()
# Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)
S.center(width, [fill])
# Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] (0 и длина строки по умолчанию)
S.count(str, [start],[end])
# Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
S.expandtabs([tabsize])
# Удаление пробельных символов в начале строки
S.lstrip([chars])
# Удаление пробельных символов в конце строки
S.rstrip([chars])
# Удаление пробельных символов в начале и в конце строки
S.strip([chars])
# Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
S.partition(шаблон)
# Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
S.rpartition(sep)
# Переводит символы нижнего регистра в верхний, а верхнего – в нижний
S.swapcase()
# Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
S.title()
# Делает длину строки не меньшей width, по необходимости заполняя первые символы нулями
S.zfill(width)
# Делает длину строки не меньшей width, по необходимости заполняя последние символы символом fillchar
S.ljust(width, fillchar=" ")
# Делает длину строки не меньшей width, по необходимости заполняя первые символы символом fillchar
S.rjust(width, fillchar=" ")
Индексация и разделение строк в 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])
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 — “Sammy”, мы можем сделать это так:
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, выводя все символы между двумя индексами.
Давайте снова посмотрим на пример выше, который выводит подстроку “Shark”:
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], будет выведен только каждый четвертый символ. Выводимые символы также обозначены красным цветом:
Sammy 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[пробел]ymmaS
В этом примере выводится символ пробела.
Задавая третий параметр синтаксиса среза Python, мы указываем шаг подстроки, которую извлекаем из первоначальной строки.
Методы подсчета
Когда мы говорим об индексах символов в строках, стоит упомянуть о некоторых методах подсчета строк или вывода индексов. Это может быть полезно для того, чтобы ограничить количество символов, которые мы хотим включить в форму ввода, или чтобы сравнивать строки. Для подсчета строк, как и других символов последовательных данных, можно использовать несколько методов.
Вначале мы рассмотрим метод len(), который поможет определить длину любого типа данных упорядоченной или неупорядоченной последовательности, включая строки, списки, кортежи и словари.
Давайте выведем длину строки ss:
print(len(ss))
Output
12
Длина строки “Sammy Shark!” составляет 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” появляется в строке “Sammy Shark!” на позиции с индексом 2. Мы можем проверить позиции индекса в строке ss выше.
Давайте посмотрим, где встречается первая последовательность символов “likes” в строке likes:
print(likes.find("likes"))
Ouput
6
Первый экземпляр последовательности символов “likes” начинается с индекса 6, соответствующего позиции символа l в последовательности likes.
Что делать, если, если мы хотим увидеть, где начинается вторая последовательность “likes”? Для этого мы можем передать второй параметр в метод str.find(), который будет начинаться с конкретного индекса. Вместо того, чтобы начинать с начала строки, начнем с индекса 9:
print(likes.find("likes", 9))
Output
34
Во втором примере, который начинается с индекса 9, первая последовательность символов “likes” начинается с индекса 34.
Также мы можем указать в качестве третьего параметра конец диапазона. Как и в случае со срезами, мы можем использовать обратный отсчет, указав отрицательный индекс:
print(likes.find("likes", 40, -6))
Output
64
В последнем примере мы ищем позицию последовательности “likes” между индексами 40 и -6. Поскольку последний параметр отрицательный, отсчет выполняется с конца первоначальной строки.
Методы строки len(), str.count() и str.find() можно использовать для определения длины, количества символов или последовательностей символов и индексов символов или последовательностей символов в строках.
Заключение
Возможность вызова определенных индексов строк или конкретного среза строки дает дополнительную гибкость при работе с этим типом данных. Поскольку строки относятся к последовательному типу данных, как списки и кортежи, для доступа к ним можно использовать индексы и срезы.
Чтобы продолжить изучение строк, вы можете прочитать дополнительные материалы по форматированию строк и методам строк.
 Как индексировать и нарезать строки в Python 3 
 Введение 
 Строковый тип данных Python — это последовательность, состоящая из одного или нескольких отдельных символов, которые могут состоять из букв, цифр, пробелов или символов. Поскольку строка является последовательностью, к ней можно получить доступ так же, как и к другим типам данных на основе последовательностей, посредством индексации и нарезки.
 Из этого туториала Вы узнаете, как получить доступ к строкам с помощью индексации, разрезать их по последовательностям символов, а также познакомиться с некоторыми методами подсчета и определения местоположения символов.
 Как индексируются строки 
 Подобно типу данных списка, элементы которого соответствуют порядковому номеру, каждый из символов строки также соответствует порядковому номеру, начиная с порядкового номера 0.
 За шнурок  Сэмми Шарк!  разбивка индекса выглядит так:
 S
 а
 м
 м
 л
 S
 ч
 а
 r
 к
!
 0
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 Как видите, первый  S  начинается с индекса 0, а строка заканчивается с индексом 11 на !  символ.
 Мы также заметили, что пробельный символ между  Sammy  и  Shark  также соответствует его собственному порядковому номеру. В этом случае порядковый номер, связанный с пробелом, равен 5.
 С восклицательным знаком (! ) также связан порядковый номер. Любой другой символ или знак препинания, например  * # $ &.;? , также является символом и будет связан с его собственным порядковым номером.
 Тот факт, что каждый символ в строке Python имеет соответствующий номер индекса, позволяет нам получать доступ к строкам и управлять ими так же, как и с другими последовательными типами данных.
 Доступ к символам по положительному порядковому номеру 
 Ссылаясь на номера индексов, мы можем выделить один из символов в строке. Мы делаем это, помещая порядковые номера в квадратные скобки. Объявим строку, напечатаем ее и вызовем порядковый номер в квадратных скобках:
  ss = "Сэмми Акула!"
печать (ss [4])
  
  
 Выход 
 г
  
 Когда мы обращаемся к определенному порядковому номеру строки, Python возвращает символ, который находится в этой позиции.Поскольку буква  y  находится под номером 4 в строке  ss = "Sammy Shark!" , когда мы печатаем  ss [4] , мы получаем  y  в качестве вывода.
 Индексные номера позволяют нам получить доступ к определенным символам в строке.
 Доступ к символам по отрицательному номеру индекса 
 Если у нас есть длинная строка, и мы хотим точно определить элемент ближе к концу, мы также можем отсчитывать назад от конца строки, начиная с номера индекса  -1 .
 За ту же струну  Sammy Shark! , отрицательная разбивка индекса выглядит так:
 S
 а
 м
 м
 л
 S
 ч
 а
 r
 к
!
-12
 -11
 -10
 -9
-8
-7
-6
-5
-4
 -3
-2
 -1
 Используя отрицательные индексные числа, мы можем распечатать символ  r , указав его позицию в индексе -3, например:
  печать (ss [-3])
  
  
 Мощность 
 r
  
 Использование отрицательных индексных чисел может быть полезно для выделения одного символа в конце длинной строки.
 Нарезка струн 
 Мы также можем вызвать ряд символов из строки. Допустим, мы хотим просто напечатать слово  Shark . Мы можем сделать это, создав  срез , который представляет собой последовательность символов в исходной строке. С помощью срезов мы можем вызывать несколько символьных значений, создавая диапазон номеров индексов, разделенных двоеточием  [x: y] :
  печать (ss [6:11])
  
  
 Выход 
 Акула
  
 При создании слайса, как в  [6:11] , первый номер индекса — это место, где начинается слайс (включительно), а второй номер индекса — это место, где слайс заканчивается (исключая), поэтому в нашем примере выше диапазон должен быть порядковым номером, который появится сразу после окончания строки.
 При нарезке строк мы создаем подстроку  , которая по сути является строкой, существующей внутри другой строки. Когда мы вызываем  ss [6:11] , мы вызываем подстроку  Shark , которая существует в строке  Sammy Shark! .
 Если мы хотим включить любой конец строки, мы можем опустить одно из чисел в синтаксисе  строка [n: n] . Например, если мы хотим вывести первое слово строки  ss  — «Сэмми» — мы можем сделать это, набрав:
  печать (ss [: 5])
  
  
 Выход 
 Сэмми
  
 Мы сделали это, опустив номер индекса перед двоеточием в синтаксисе среза и включив только номер индекса после двоеточия, который указывает на конец подстроки.
 Чтобы напечатать подстроку, которая начинается в середине строки и печатается до конца, мы можем сделать это, включив только номер индекса перед двоеточием, например:
  печать (ss [7:])
  
  
 Выход 
 hark!
  
 Если включить только номер индекса перед двоеточием и исключить второй номер индекса в синтаксисе, подстрока будет идти от символа вызываемого номера индекса до конца строки.
 Вы также можете использовать отрицательные индексные числа, чтобы разрезать строку.Как мы уже говорили ранее, отрицательные порядковые номера строки начинаются с -1 и отсчитываются оттуда, пока мы не дойдем до начала строки. При использовании отрицательных числовых индексов сначала мы начнем с меньшего числа, поскольку оно встречается раньше в строке.
 Давайте используем два отрицательных индексных числа, чтобы разрезать строку  ss :
  печать (ss [-4: -1])
  
  
 Выход 
 ковчег
  
 Подстрока «ark» печатается из строки «Sammy Shark!» потому что символ «a» встречается в позиции порядкового номера -4, а символ «k» встречается непосредственно перед порядковым номером -1.
 Указание шага при нарезке строк 
 Нарезка строки может принимать третий параметр в дополнение к двум индексным номерам. Третий параметр указывает шаг  , который указывает, на сколько символов нужно продвинуться вперед после извлечения первого символа из строки. До сих пор мы опускали параметр шага, и Python по умолчанию использует шаг, равный 1, так что извлекается каждый символ между двумя индексными номерами.
 Давайте еще раз посмотрим на приведенный выше пример, который выводит подстроку «Акула»:
  печать (ss [6:11])
  
  
 Выход 
 Акула
  
 Мы можем получить те же результаты, включив третий параметр с шагом 1:
.
  печать (ss [6: 11: 1])
  
  
 Выход 
 Акула
  
 Итак, шаг 1 займет каждый символ между двумя индексными номерами среза.Если мы опустим параметр шага, Python по умолчанию будет использовать 1.
 Если вместо этого мы увеличим шаг, мы увидим, что символы пропущены:
  печать (ss [0: 12: 2])
  
  
 Выход 
 SmySak
  
 Указание шага 2 в качестве последнего параметра в синтаксисе Python  ss [0: 12: 2]  пропускает все остальные символы. Давайте посмотрим на символы, выделенные желтым:
 Sammy Shark!
 Обратите внимание, что пробельный символ в индексе номер 5 также пропускается с указанным шагом 2.
 Если мы используем большее число для нашего параметра шага, у нас будет значительно меньшая подстрока:
  печать (ss [0: 12: 4])
  
  
 Выход 
 Sya
  
 Указание шага 4 в качестве последнего параметра в синтаксисе Python  ss [0: 12: 4]  печатает только каждый четвертый символ. Опять же, давайте посмотрим на символы, выделенные желтым:
 Sammy Shark!
 В этом примере также пропускается пробельный символ.
 Поскольку мы печатаем всю строку, мы можем опустить два индексных номера и оставить два двоеточия в синтаксисе для достижения того же результата:
  печать (ss [:: 4])
  
  
 Выход 
 Sya
  
 Если пропустить два индексных номера и оставить двоеточия, вся строка останется в пределах диапазона, а добавление последнего параметра для шага определит количество пропущенных символов.
 Кроме того, вы можете указать отрицательное числовое значение для шага, которое мы можем использовать для печати исходной строки в обратном порядке, если мы установим шаг в -1:
  печать (ss [:: - 1])
  
  
 Выход 
! KrahS ymmaS
  
 Два двоеточия без указанных параметров будут включать все символы из исходной строки, шаг 1 будет включать каждый символ без пропуска, а отрицание этого шага изменит порядок символов на обратный.
 Давайте сделаем это еще раз, но с шагом -2:
  печать (ss [:: - 2])
  
  
 Мощность 
! Rh ma
  
 В этом примере,  ss [:: - 2] , мы имеем дело со всей исходной строкой, так как в параметры не включены номера индексов, и переворачиваем строку через отрицательный шаг. Кроме того, имея шаг -2, мы пропускаем каждую вторую букву перевернутой строки:
! KrahS [пробел] ymmaS
 В этом примере печатается пробельный символ.
 Указывая третий параметр синтаксиса фрагмента Python, вы указываете шаг подстроки, которую вы извлекаете из исходной строки.
 Методы подсчета 
 Пока мы думаем о соответствующих индексных номерах, которые соответствуют символам в строках, стоит рассмотреть некоторые методы, которые подсчитывают строки или возвращают индексные номера. Это может быть полезно для ограничения количества символов, которые мы хотели бы принять в форме пользовательского ввода, или для сравнения строк.Как и другие последовательные типы данных, строки можно подсчитывать несколькими способами.
 Сначала мы рассмотрим метод  len () , который может получить длину любого типа данных, который является последовательностью, упорядоченной или неупорядоченной, включая строки, списки, кортежи и словари.
 Выведем длину строки  ss :
  печать (лен (сс))
  
  
 Выход 
 12
  
 Длина строки «Сэмми Шарк!» состоит из 12 символов, включая пробельный символ и восклицательный знак.
 Вместо использования переменной мы также можем передать строку прямо в метод  len () :
  print (len («Напечатаем длину этой строки.»))
  
  
 Выход 
 38
  
 Метод  len ()  подсчитывает общее количество символов в строке.
 Если мы хотим подсчитать, сколько раз в строке появляется один конкретный символ или последовательность символов, мы можем сделать это с помощью  str.count ()  метод. Давайте поработаем со строкой  ss = "Sammy Shark!"  и посчитайте, сколько раз встречается символ «а»:
  отпечаток (ss.count ("a"))
  
  
 Выход 
 2
  
 Мы можем искать другого персонажа:
  печать (ss.count ("s"))
  
  
 Выход 
 0
  
 Хотя в строке есть буква «S», важно помнить, что каждый символ чувствителен к регистру.Если мы хотим найти все буквы в строке независимо от регистра, мы можем использовать метод  str.lower () , чтобы сначала преобразовать строку во все строчные буквы. Вы можете узнать больше об этом методе в «Введение в строковые методы в Python 3».
 Давайте попробуем  str.count ()  с последовательностью символов:
  Like = "Сэмми любит плавать в океане, запускать серверы и любит улыбаться."
print (like.count ("лайков"))
  
  
 Выход 
 3
  
 В строке  лайков  последовательность символов, эквивалентная «лайкам», встречается в исходной строке 3 раза.
 Мы также можем узнать, в какой позиции символ или последовательность символов встречается в строке. Мы можем сделать это с помощью метода  str.find () , который вернет позицию символа на основе номера индекса.
 Мы можем проверить, где встречается первая буква «m» в строке  ss :
  отпечаток (ss.find ("m"))
  
  
 Выход 
 2
  
 Первый символ «m» встречается в позиции индекса 2 в строке «Sammy Shark!» Мы можем просмотреть позиции порядковых номеров строки  ss  выше.
 Давайте посмотрим, где в строке встречается первая последовательность символов «Нравится».  Нравится :
.
  распечатать (like.find ("лайки"))
  
  
 Выход 
 6
  
 Первый экземпляр последовательности символов «нравится» начинается с позиции номера индекса 6, где располагается символ -1  последовательности  лайков .
 Что, если мы хотим увидеть, где начинается вторая последовательность лайков? Мы можем сделать это, передав второй параметр в  str.find () , который будет запускаться с определенного номера индекса. Итак, вместо того, чтобы начинать с начала строки, давайте начнем после номера индекса 9:
  распечатка (like.find ("лайки", 9))
  
  
 Выход 
 34
  
 В этом втором примере, который начинается с порядкового номера 9, первое появление последовательности символов «нравится» начинается с порядкового номера 34.
 Кроме того, мы можем указать конец диапазона в качестве третьего параметра.Как и при нарезке, мы можем сделать это путем обратного отсчета с использованием отрицательного номера индекса:
  распечатка (like.find ("лайков", 40, -6))
  
  
 Выход 
 64
  
 В этом последнем примере выполняется поиск позиции последовательности «лайков» между порядковыми номерами 40 и -6. Поскольку последний введенный параметр является отрицательным числом, отсчет будет отсчитываться от конца исходной строки.
 Строковые методы  len () ,  str.count ()  и  str.find ()  может использоваться для определения длины, количества символов или последовательностей символов и позиций индекса символов или последовательностей символов в строках.
 Заключение 
 Возможность вызова определенных порядковых номеров строк или определенного фрагмента строки дает нам большую гибкость при работе с этим типом данных. Поскольку строки, такие как списки и кортежи, являются типом данных на основе последовательности, доступ к ним можно получить с помощью индексации и нарезки.
 Вы можете узнать больше о форматировании строк и строковых методах, чтобы продолжить изучение строк.
 Нарезка строки в Python — GeeksforGeeks 
  Нарезка строки Python  — это получение подстроки из заданной строки путем нарезки ее соответственно от начала до конца. 
 Нарезку Python можно выполнить двумя способами.
 Конструктор slice ()
 Расширение индексации
 Конструктор slice () 
 Конструктор  slice ()  создает объект среза, представляющий набор индексов, заданных диапазоном (начало, остановка, шаг).
  Синтаксис: 
 slice (стоп)
 slice (start, stop, step)
  Параметры:  
  start:  Начальный индекс, с которого начинается нарезка объекта. 
  stop:  Индекс окончания, на котором останавливается нарезка объекта. 
  step:  Это необязательный аргумент, который определяет приращение между каждым индексом для нарезки.
  Тип возвращаемого значения:  Возвращает нарезанный объект, содержащий элементы только в заданном диапазоне.
 
 
  Индекс-трекер для положительного и отрицательного индекса:  
 Отрицательный учитывается при отслеживании строки в обратном порядке.
  Пример 
  
  Строка   =   'ASTRING' 
  
  s1   =          ) 
  s2   =   срез   (  1  ,   5  ,   2  ) 
  s3   =   срез   (  -   1  ,   -   12  ,   -   2  ) 
  
  печать   (  «Нарезка струны»  ) 
  печать   (строка [s1]) 
  печать   (строка [s2]) 
  печать   (St кольцо [s3]) 
  Выход: 
Нарезка строк
AST
SR
GITA
 
 Расширение индексации 
 В Python синтаксис индексации можно использовать вместо объекта среза.Это простой и удобный способ разрезать строку как с точки зрения синтаксиса, так и с точки зрения выполнения.
  Синтаксис 
 строка [начало: конец: шаг] 
 start, end и step имеют тот же механизм, что и конструктор  slice () .
  Пример 
  
  Строка   =   'ASTRING' 
  
  печать   (Строка [:   3  9 5]) 9)  печать   (Строка [  1  :   5  :   2  ]) 
  печать   (Строка [  -   1  :   -   12  :   -   2  ]) 
  
  печать   (  "\ n Обратная строка"  ) 
  печать   (строка [::  ] -   1  ]) 
  Выход: 
AST
SR
GITA

Обратная строка
ГНИРЦА
 
  Примечание:  Чтобы узнать больше о строках, щелкните здесь.
 Внимание компьютерщик! Укрепите свои основы с помощью курса  Python Programming Foundation  и изучите основы.
 Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса  Python DS . И чтобы начать свое путешествие по машинному обучению, присоединяйтесь к  Машинное обучение - курс базового уровня 
 
 Python slice () 
 Функция  slice ()  возвращает объект фрагмента, который используется для нарезки любой последовательности (строки, кортежа, списка, диапазона или байтов).
 Пример 
  text = 'Программирование на Python'

 
 # получить объект среза для срезания Python
slice_text = кусок (6) 
печать (текст [срез_текст])

# Вывод: Python  
 slice () Синтаксис 
 Синтаксис  slice () :
 срез (начало, остановка, шаг) 
 slice () Параметры 
  slice ()  может принимать три параметра:
  start (необязательно)  - Начальное целое число, с которого начинается нарезка объекта.По умолчанию  Нет , если не указан.
  stop  - Целое число, до которого выполняется нарезка. Нарезка останавливается на индексе  stop -1 (последний элемент) .
  шаг (необязательно)  - Целочисленное значение, определяющее приращение между каждым индексом для нарезки. По умолчанию  Нет , если не указан.
 slice () Возвращаемое значение 
  slice ()  возвращает объект среза.
  Примечание : Мы можем использовать срез с любым объектом, который поддерживает протокол последовательности (реализует методы  __getitem __ ()  и  __len () __ ).
 Пример 1. Создание объекта среза для нарезки 
  # содержит индексы (0, 1, 2)
результат1 = срез (3)
печать (результат1)

# содержит индексы (1, 3)
 
 результат2 = срез (1, 5, 2) 
печать (срез (1, 5, 2))  
  Выход 
  срез (Нет, 3, Нет)
ломтик (1, 5, 2)  
 Здесь  результат1  и  результат2  являются объектами среза.
 Теперь мы знаем об объектах среза, давайте посмотрим, как мы можем получить подстроку, подсписок, подкортеж и т. Д.от объектов-срезов.
 Пример 2: Получить подстроку с помощью объекта среза 
  # Программа для получения подстроки из заданной строки

py_string = 'Python'

# stop = 3
# содержит индексы 0, 1 и 2
 
 slice_object = кусок (3) 
print (py_string [slice_object]) # Pyt

# start = 1, stop = 6, step = 2
# содержит индексы 1, 3 и 5
slice_object = срез (1, 6, 2)
print (py_string [slice_object]) # yhn  
  Выход 
  Pyt
yhn  
 Пример 3: Получить подстроку с отрицательным индексом 
  py_string = 'Python'

# start = -1, stop = -4, step = -1
# содержит индексы -1, -2 и -3
 
 slice_object = slice (-1, -4, -1) 

print (py_string [slice_object]) # noh  
  Выход 
  №  
 Пример 4: Получить подсписок и подкортеж 
  py_list = ['P', 'y', 't', 'h', 'o', 'n']
py_tuple = ('P', 'y', 't', 'h', 'o', 'n')

# содержит индексы 0, 1 и 2
 
 slice_object = кусок (3) 
print (py_list [slice_object]) # ['P', 'y', 't']

# содержит индексы 1 и 3
 
 slice_object = slice (1, 5, 2) 
print (py_tuple [slice_object]) # ('y', 'h')  
  Выход 
  ['P', 'y', 't']
('y', 'h')  
 Пример 5. Получить подсписок и подкортеж с отрицательным индексом 
  py_list = ['P', 'y', 't', 'h', 'o', 'n']
py_tuple = ('P', 'y', 't', 'h', 'o', 'n')

# содержит индексы -1, -2 и -3
 
 slice_object = slice (-1, -4, -1) 
print (py_list [slice_object]) # ['n', 'o', 'h']

# содержит индексы -1 и -3
 
 slice_object = slice (-1, -5, -2) 
print (py_tuple [slice_object]) # ('n', 'h')  
  Выход 
  ['n', 'o', 'h']
('п', 'ч')  
 Пример 6: Использование синтаксиса индексирования для нарезки 
 Объект среза можно заменить синтаксисом индексации в Python.
 Вы также можете использовать следующий синтаксис для нарезки:
 obj [начало: стоп: шаг] 
 Например,
  py_string = 'Python'

# содержит индексы 0, 1 и 2
 
 print (py_string [0: 3]) # Pyt 

# содержит индексы 1 и 3
 
 print (py_string [1: 5: 2]) # yh 
  
  Выход 
  Pyt
yh  
 Нарезка строк в Python | Finxter 
 Нарезка строк - это концепция выделения подстроки из заданной строки.Используйте нотацию нарезки  s [start: stop: step]  для доступа к каждому элементу  step  -th, начиная с индекса  start  (включительно) и заканчивая индексом  stop  (исключено). Все три аргумента являются необязательными, поэтому вы можете пропустить их, чтобы использовать значения по умолчанию ( start = 0 ,  stop = len (string) ,  step = 1 ). Например, выражение  s [2: 4]  из строки  'hello'  выделяет фрагмент  'll' , а выражение  s [: 3: 2]  выделяет фрагмент  'hl'  .
 Далее рассмотрим несколько примеров.
 Нарезка строки по умолчанию Начало и конец 
 В следующем фрагменте кода вы создаете строку и нарезаете строку, используя только аргументы по умолчанию - это создает копию исходной строки.
 >>> строка = 'привет, мир'
>>> строка [:]
'hello world' 
 Нарезка строки: как пропустить первый символ 
 Следующая операция нарезки строки создает новую строку, начинающуюся после первого символа.Он использует стоп-индекс по умолчанию, поэтому нарезает всю строку, исключая только первый символ.
 >>> строка [1:]
'ello world' 
 Нарезка строки: как пропустить последний символ 
 Вы можете использовать отрицательные индексы в качестве аргументов запуска или остановки операции нарезки строки. В этом случае Python начинает отсчет справа. Например, отрицательный индекс -1 указывает на последний символ в строке, индекс -2 указывает на второй последний и так далее.
 Если вы хотите пропустить последний символ строки, вы просто используете -1 в качестве индекса остановки операции среза:
 >>> string [: - 1]
'hello worl' 
 Нарезка строки: как пропустить каждый второй символ 
 Вы можете пропустить любой второй символ, используя размер шага 2 с индексами начала и остановки по умолчанию:
 >>> string [:: 2]
'hlowrd' 
 Нарезка строки: установить все три аргумента 
 Если вы установите все три аргумента, вы можете управлять индексом начала, индексом остановки и размером шага.Это позволяет эффективно создавать новые строки:
 >>> string [1: 6: 2]
'el' 
 Нарезка языковых функций применяется не только к спискам, но и к строкам. Поскольку и списки, и строки являются типами упорядочивания, нарезка - лишь одно из нескольких сходств. Например, вы также можете перебирать символы в строке, используя цикл  для  (например,  для c в слове ).
 Головоломка Python Нарезка строки 
 Вот пример головоломки, чтобы проверить и улучшить ваше понимание концепции нарезки строки.
 word = "бендер"
print (word [1: 4]) 
   Что выводит этот фрагмент кода?  
 Только половина пользователей Finxter может решить эту головоломку. У другой половины пользователей возникают проблемы с определением правильного конечного индекса среза. Напомним, конечный индекс не входит в срез. Здесь вы можете увидеть индексы слова-головоломки.
 Вы мастер-кодер?
 Щелкните, чтобы проверить свои навыки нарезки строк Python на Finxter.com приложение.
 Видео по теме 
 
 Работая исследователем распределенных систем, доктор Кристиан Майер обнаружил свою любовь к обучению студентов, изучающих информатику.
 Чтобы помочь студентам достичь более высокого уровня успеха в Python, он основал веб-сайт по обучению программированию Finxter.com. Он является автором популярной книги по программированию Python One-Liners (NoStarch 2020), соавтором серии самоизданных книг по Python для кофе-брейков, энтузиаст информатики, фрилансер и владелец одного из 10 крупнейших блогов Python по всему миру.
 Его страстями являются письмо, чтение и кодирование. Но его самая большая страсть - служить начинающим программистам через Finxter и помогать им повышать свои навыки. Вы можете присоединиться к его бесплатной электронной академии здесь.
 Как нарезать строки в Python? 
 Введение 
 В этом руководстве мы узнаем, как можно нарезать строки в Python.
 Python поддерживает нарезку строк. Это создание новой подстроки из данной строки на основе определенных пользователем начальных и конечных индексов.
 Способы разрезания строк в Python 
 Если вы хотите разрезать строки в Python, это будет так же просто, как эта строка ниже.
 res_s = s [start_pos: end_pos: step]
 
 Здесь
  res_s  хранит возвращенную подстроку,
 s - заданная строка,
  start_pos  - начальный индекс, из которого нам нужно разрезать строку s,
  end_pos  - конечный индекс, перед которым завершится операция нарезки,
 , шаг  - это шаги, которые процесс нарезки будет выполнять от start_pos до end_pos.
  Примечание : Все три вышеперечисленных параметра являются необязательными. По умолчанию для  start_pos  установлено значение  0 ,  end_pos  считается равным длине строки, а  step  устанавливается на  1 .
 Теперь давайте рассмотрим несколько примеров, чтобы понять, как лучше разрезать строки в Python.
 Разрезать строки в Python - примеры 
 Нарезать строки Python можно разными способами.
 Обычно мы получаем доступ к строковым элементам (символам), используя простую индексацию, которая начинается с  0  до  n-1  (n - длина строки).Следовательно, для доступа к  1-му элементу  строки  string1  мы можем просто использовать приведенный ниже код.
 Опять же, есть другой способ получить доступ к этим символам, то есть использовать  с отрицательной индексацией . Отрицательная индексация начинается с -1  до  -n  (n - длина данной строки). Обратите внимание, что отрицательная индексация выполняется с другого конца строки. Следовательно, чтобы получить доступ к первому символу на этот раз, нам нужно следовать приведенному ниже коду.
 Теперь давайте посмотрим на некоторые способы, которыми мы можем разрезать строку, используя вышеупомянутую концепцию.
 1. Разрезать строки в Python с началом и концом 
 Мы можем легко разрезать данную строку, указав начальный и конечный индексы для желаемой подстроки, которую мы ищем. Посмотрите на приведенный ниже пример, в котором объясняется нарезка строк с использованием начальных и конечных индексов как для обычного, так и для отрицательного метода индексации.
 # нарезка строки с двумя параметрами
s = "Привет, мир!"

res1 = s [2: 8]
res2 = s [-4: -1] # использование отрицательной индексации

print ("Результат1 =", res1)
print ("Результат2 =", res2)
 
  Выход :
 Результат1 = llo Wo
Результат2 = rld
 
 Здесь
 Мы инициализируем строку  s  как  «Hello World!» ,
 Сначала мы разрезаем данную строку с начальным индексом  2  и конечным индексом  8 .Это означает, что результирующая подстрока будет содержать символы от  s [2]  до  s [8-1] ,
 Аналогично, для следующей подстроки результирующая подстрока должна содержать символы из  s [ -4] от  до  с [(- 1) -1] .
 Значит, наш выход оправдан.
 2. Разрезать строки, используя только начало или конец 
 Как упоминалось ранее, все три параметра для разрезания строки являются необязательными. Следовательно, мы можем легко выполнять наши задачи, используя один параметр.Посмотрите на приведенный ниже код, чтобы получить четкое представление.
 # нарезка строки с одним параметром
s1 = "Чарли"
s2 = "Иордания"

res1 = s1 [2:] # значение по умолчанию конечной позиции устанавливается равным длине строки
res2 = s2 [: 4] # значение по умолчанию начальной позиции равно 0

print ("Результат1 =", res1)
print ("Результат2 =", res2)
 
  Выход :
 Результат1 = arlie
Результат2 = Йорд
 
 Здесь
 Сначала мы инициализируем две строки,  s1  и  s2 ,
 Для нарезки обеих из них мы просто упоминаем  start_pos  для s1 и  end_pos  только для s2,
 Следовательно, для  res1 , он содержит подстроку s1 от индекса 2 (как упоминалось) до последнего (по умолчанию он установлен в n-1).В то время как для res2 диапазон индексов лежит от 0 до 4 (упоминалось).
 3. Строки среза в Python с параметром шага 
 Значение шага   определяет переход, который операция среза будет выполнять от одного индекса к другому. Внимательно посмотрите на приведенный ниже пример.
 # нарезка строки с параметром шага
s = "Python"
s1 = "Котлин"

res = s [0: 5: 2]
res1 = s1 [-1: -4: -2] # использование отрицательных параметров

print ("Результирующая нарезанная строка =", res)
print ("Результирующая нарезанная строка (отрицательные параметры) =", res1)
 
  Выход :
 Результирующая нарезанная строка = Pto
Результирующая нарезанная строка (отрицательные параметры) = nl
 
 В приведенном выше коде
 Мы инициализируем две строки  s  и  s1  и пытаемся разрезать их для заданных начальных и конечных индексов, как мы делали для нашего первого примера,
 Но на этот раз мы упомянули значение шага , значение , которое по умолчанию было установлено в 1 для предыдущих примеров,
 Для res размер шага 2 означает, что при обходе для получения подстроки с индекса 0 до 4 каждый раз индекс будет увеличиваться на значение 2.То есть первый символ -  s [0]  ('P'), следующие символы в подстроке будут  s [0 + 2]  и  s [2 + 2] , пока индекс просто меньше 5.
 Для следующего, например,  res1 , упомянутый шаг равен (-2). Следовательно, как и в предыдущем случае, символы в подстроке будут иметь вид  s1 [-1] , затем  s1 [(- 1) + (- 2)]  или  s1 [-3] , пока индекс не станет чуть меньше (-4).
 4. Обращение строки с помощью нарезки в Python 
 С помощью нарезки строки с отрицательным индексом в Python мы также можем перевернуть строку и сохранить ее в другой переменной.Для этого нам просто нужно упомянуть шаг , размер , равный  (-1) .
 Давайте посмотрим, как это работает, на примере, приведенном ниже.
 # реверсирование струны с помощью нарезки струны
s = "AskPython"
rev_s = s [:: - 1] # обратная строка, сохраненная в rev_s

печать (rev_s)
 
  Выход :
 Как мы видим, строка s переворачивается и сохраняется в  rev_s .  Примечание : и в этом случае исходная струна остается неповрежденной и нетронутой.
 Заключение 
 Итак, в этом руководстве мы узнали о методологии нарезки строк и ее различных формах.Надеюсь, читатели получили четкое представление о теме.
 Если у вас возникнут дополнительные вопросы по этой теме, воспользуйтесь комментариями ниже.
 Ссылки 
 Строка фрагмента Python - JournalDev 
 Строка Python поддерживает нарезку для создания подстроки. Обратите внимание, что строка Python неизменна, при нарезке из исходной строки создается новая подстрока, а исходная строка остается неизменной.
 Строка фрагмента Python 
 Синтаксис строки фрагмента Python:
 
str_object [start_pos: end_pos: step]
  
 Нарезка начинается с индекса start_pos (включен) и заканчивается индексом end_pos (исключая).Параметр step используется для указания шагов от начала до конца индекса.
 Python Разделение строк всегда следует этому правилу:  s [: i] + s [i:] == s  для любого индекса «i».
 Все эти параметры являются необязательными - значение по умолчанию start_pos равно 0, значение по умолчанию end_pos - длина строки, а значение шага по умолчанию - 1.
 Давайте рассмотрим несколько простых примеров функции среза строки для создания подстроки.
 
s = 'HelloWorld'

печать (s [:])

печать (s [::])
  
 Выход:
 
Привет, мир
Привет, мир
  
 Обратите внимание, что, поскольку ни один из параметров нарезки не был предоставлен, подстрока равна исходной строке.
 Давайте рассмотрим еще несколько примеров разрезания строки.
 
s = 'HelloWorld'
first_five_chars = s [: 5]
печать (first_five_chars)

third_to_fifth_chars = s [2: 5]
печать (third_to_fifth_chars)
  
 Выход:
 
Привет
лло
  
 Обратите внимание, что значение индекса начинается с 0, поэтому start_pos 2 относится к третьему символу в строке.
 Перевернуть строку с помощью нарезки 
 Мы можем перевернуть строку, используя нарезку, указав значение шага как -1.
 
s = 'HelloWorld'
reverse_str = s [:: - 1]
печать (обратная_строчка)
  
 Вывод:  dlroWolleH 
 Давайте посмотрим на некоторые другие примеры использования шагов и отрицательных значений индекса.
 
s1 = s [2: 8: 2]
печать (s1)
  
 Вывод:  loo 
 Здесь подстрока содержит символы из индексов 2,4 и 6.
 
s1 = s [8: 1: -1]
печать (s1)
  
 Вывод:  lroWoll 
 Здесь значения индекса берутся от конца до начала.Подстрока состоит из индексов с 1 по 7 от конца до начала.
 
s1 = s [8: 1: -2]
печать (s1)
  
 Вывод:  lool 
 Срез Python также работает с отрицательными индексами, в этом случае start_pos исключается, а end_pos включается в подстроку.
 
s1 = s [-4: -2]
печать (s1)
  
 Выход:  или 
 Нарезка строки Python корректно обрабатывает индексы вне диапазона.
 
>>> s = 'Python'
>>> s [100:]
''
>>> с [2:50]
'тон'
  
 Вот и все, что касается функции среза строки Python для создания подстроки.
 Вы можете проверить готовый скрипт Python и другие примеры Python в нашем репозитории GitHub.
 Python: срезная нотация в строке 
 Введение 
 Термин нарезка в программировании обычно относится к получению подстроки, подкортежа или подсписка из строки, кортежа или списка соответственно.
 Python предлагает множество простых способов разрезать не только эти три, но и  любой итеративный .Итерируемый   - это, как следует из названия, любой объект, который можно повторять.
 В этой статье мы рассмотрим все, что вам нужно знать о  Slicing Strings в Python .
 Нарезка строки в Python 
 Существует несколько способов разрезания строки, наиболее распространенный из которых - использование оператора :  со следующим синтаксисом:
  строка [начало: конец]
строка [начало: конец: шаг]
  
 Параметр  start,  представляет начальный индекс,  end,  - конечный индекс, а  step,  - количество элементов, которые «перешагнули».
 Давайте продолжим и разрежем строку:
  строка = 'Нет. Я твой отец.'
print (строка [4:20])
  
 При этом будут пропущены первые четыре символа в строке:
  я твой отец
  
 Нахождение префикса и суффикса длины n с помощью среза 
 Чтобы найти префикс или суффикс длины  n  строки, мы будем использовать тот же подход, который можно использовать для поиска хвоста или заголовка списка. Мы разрежем от начала до  n  и от  -n  до конца строки.
 В этом случае  -n  начнет отсчет с конца строки в обратном направлении, что даст нам суффикс:
  п = 4
string = 'Теперь, молодой Скайуокер, ты умрешь.'


печать (строка [: n])

print (строка [-n:])
  
 Это приводит к:
  Сейчас,
умереть.
  
 Переверните строку, используя нотацию срезов 
 Чтобы перевернуть строку, мы можем установить  шаг  нотации среза на  -1 . Это заставляет шаг идти назад, включая каждый элемент, на который он наступает, в результате чего строка печатается в обратном порядке:
  string = 'Я никогда не перейду на темную сторону.Вы потерпели неудачу, ваше высочество. Я джедай, как и мой отец до меня ».
print (строка [:: - 1])
  
 Этот код приведет к:
 Ознакомьтесь с нашим практическим практическим руководством по изучению Git с лучшими практиками, общепринятыми стандартами и включенной шпаргалкой. Прекратите гуглить команды Git и на самом деле  выучите  его!
  .em erofeb rehtaf ym ekil, ideJ a ma I .ssenhgih ruoy, deliaf ev’uoY .edis krad eht ot nrut reven ll’I
  
 Поиск каждого n-го символа в строке 
 Извлечение каждого n-го символа сводится к установке параметра шага на  n .Если вы хотите, чтобы каждый второй символ, вы также перешагнули бы через каждый второй символ:
 
  п = 3
string = 'Всегда есть рыба побольше.