Как взять срез строки python

Как взять срез строки python

11.2.2.2 использование срезов для обработки строк

Python. Срезы

Срезы строк

Срезы очень интересный инструмент Python для обработки упорядоченных структур данных, таких как строки, списки, кортежи.

Срезы имеют свой собственный синтакс, напоминающий диапазон значений функции range().
Срез имеет три параметра, начальный индекс START, конечный индекс STOP (не включая элемент STOP), и шаг увеличения или уменьшения индекса STEP:

Несколько примеров с разными параметрами:

[:]/[::] # все элементы,
[::2] # нечетные элементы последовательности,
[1::2] # четные элементы последовательности,
[::-1] # обратный порядок всех элементов последовательности,
[5:] # все элементы, начиная с шестого символа,
[:5] # все элементы до шестого символа (не включая шестой символ),
[-2:1:-1] # все элементы от предпоследнего до второго в обратном порядке (во всех случаях выборки от большего индекса к меньшему необходимо указывать отрицательный шаг!)

Примеры использования срезов:

s = "programming" slice = s[:] # создание копии строки print(slice) # вывод "programming" slice = s[:5] print(slice) # вывод "progr" slice = s[5:] print(slice) # вывод "amming" slice = s[::2] print(slice) # output "pormig" slice = s[1::2] print(slice) # вывод "rgamn" slice = s[::-1] print(slice) # вывод "gnimmargorp" slice = s[2:9:3] print(slice) # вывод "oai" slice = s[10:0:-4] print(slice) # вывод "gmo" slice = s[8:15] print(slice) # вывод "ing" slice = s[12::] print(slice) # вывод пустой строки slice = s[:-5] print(slice) # вывод "progra" slice = s[-8:-4] print(slice) # вывод "gram"

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

s = "programming" for item in s[::2]: # перебор все символов строки s с четными индексами print(item, end=" ") # вывод "p o r m i g" 

Вопросы:

Упражнения:

Упр. 1 «Определите значение среза»

Использование срезов строк в Python

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

# символы от позиции 0 (включен) до позиции 2 (исключен) >>> word[0:2] # 'Py' # символы от позиции 2 (включен) до позиции 5 (исключен) >>> word[2:5] # 'tho' 

Обратите внимание, что начало среза всегда включено, а конец среза всегда исключен. Это гарантирует, что str[:i] + str[i:] всегда равно str :

>>> word[:2] + word[2:] # 'Python' >>> word[:4] + word[4:] # 'Python' 

Индексы срезов имеют полезные значения по умолчанию. Пропущенный первый индекс по умолчанию равен нулю, пропущенный второй индекс по умолчанию равен размеру/длине разрезаемой строки.

# символы от начала до позиции 2, который исключен >>> word[:2] # 'Py' # символы от позиции 4 - включен, до конца строки >>> word[4:] # 'on' # символы от предпоследнего (включенного) до конца >>> word[-2:] # 'on' 

Один из способов запомнить, как работают срезы, состоит в том, чтобы думать об индексах как указатели на промежутки между символами, с левым краем, равным 0 . Тогда правый край последнего символа строки из n символов имеет индекс n , например:

+---+---+---+---+---+---+ | P | y | t | h | o | n | +---+---+---+---+---+---+ 0 1 2 3 4 5 6 -6 -5 -4 -3 -2 -1

Первая строка чисел дает положение индексов 0… 6 , второй ряд дает соответствующие отрицательные показатели. Срез от i до j состоит из всех символов между ребрами, обозначенными i и j соответственно.

Для неотрицательных индексов длина среза является разностью индексов, если оба находятся в пределах границ. Например, длина word[1:3] составляет 2 .

Попытка использовать индекс, который больше длины строки приведет к ошибке:

# в слове всего 6 символов >>> word[42] # Traceback (most recent call last): # File "", line 1, in # IndexError: string index out of range 

Однако индексы срезов вне диапазона обрабатываются изящно и не дают ошибок:

>>> word[4:42] # 'on' >>> word[42:] # '' 

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

>>> 'J' + word[1:] # 'Jython' >>> word[:2] + 'py' # 'Pypy' 

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Преобразование строки в число
• Строку в список, кортеж или множество символов
• Одинарные, двойные и тройные кавычки в строке Python
• Вывод специальных символов в строке Python «как есть»
• Объединение и повторение строк
• Индексирование строк
• Использование срезов строк
• Cрез строки Python от заданного символа/знака до конца строки
• Создание макета для печати базовыми методами строк
• Способы форматирования текстовых строк
• Подсчет повторений слов в тексте, деление строки на список слов
• Удаление слова из строки Python по фрагменту или шаблону
• Удаление пунктуации из строки
• Деление строки по заглавным буквам
• Создание отчетов и писем по шаблонам

Синтаксис Python, срез строки

Данная запись означает срез в данном случае строки. Данная операция так же может быть применена к типам данных list и tuple .

Как это работает

Запись obj[START:STOP:STEP] означает, что из объекта с именем obj взять все члены последовательности от члена с индексом START (включая в последовательность) до члена с индексом STOP (не включая его в последовательность) с шагом STEP .

Все значения START , STOP , STEP имеют значения по умолчанию, т. е. значения могут не указываться и это будет значить

1. START = 0
2. STOP = всей длине объекта obj
3. STEP = 1

Учитывая вышесказанное, данная запись

будет читаться так: взять все члены последовательности между членом с индексом 0 ( START = 0 по умолчанию) и членом с индексом равным длине последовательности ( STOP = всей длине объекта obj ) с шагом 1 ( STEP = 1)

Если же указать шаг с минусом

Каждый член последовательности имеет не только положительный индекс, но также и отрицательный. То есть последний элемент последовательности имеет индекс -1 , предпоследний -2 и т.д.

будет означать: взять все члены последовательности между членом с индексом 0 ( START = 0 по умолчанию) и членом с индексом равным длине последовательности ( STOP = всей длине объекта obj ) с шагом -1. То есть

1. 0-1 = -1, взять последний элемент
2. -1-1 = -2, взять предпоследний элемент
3. и т.д.

То есть буквально означает, взять все элементы последовательности справа налево

Срезы — Python: Списки

Работать с одиночными элементами вы уже умеете. Настало время перейти к очень интересному инструменту, который Python предоставляет для работы с целыми подмножествами элементов списка: к так называемым срезам (slices).

Синтаксис описания срезов

Срезы встроены в язык и снабжены своим собственным синтаксисом — настолько широко они используются. Срез записывается так же, как записывается обращение к элементу списка по индексу:

some_list[START:STOP:STEP] 

Всего у среза три параметра:

• START — индекс первого элемента в выборке
• STOP — индекс элемента списка, перед которым срез должен закончиться. Сам элемент с индексом STOP не будет входить в выборку
• STEP — шаг прироста выбираемых индексов

Математически говоря, во множество будут входить индексы элементов, которые будут выбраны:

Например, срез [3:20:5] означает выборку значений с индексами 3, 8, 13 и 18.

При этом любой из трех параметров среза может быть опущен и вместо соответствующего параметра будет выбрано некое значение по умолчанию:

• Умолчательный START означает «от начала списка»
• Умолчательный STOP означает «до конца списка включительно»
• Умолчательный STEP означает «брать каждый элемент»

Вот несколько примеров с разными наборами параметров:

• [:] или [::] — весь список
• [::2] — нечетные по порядку элементы
• [1::2] — четные по порядку элементы
• [::-1] — все элементы в обратном порядке
• [5:] — все элементы, начиная с шестого
• [:5] — все элементы, не доходя до шестого
• [-2:1:-1] — все элементы от предпоследнего до третьего в обратном порядке. Во всех случаях выборки от большего индекса к меньшему нужно указывать шаг

Срезы могут работать в двух режимах: собственно выборка и присваивание.

Выборка элементов

Срезы-выборки работают со списками, кортежами, строками. Результатом применения выборки всегда становится новое значение соответствующего типа — список, кортеж, строка:

'hello'[2:] # 'llo' (1, "foo", True, None)[2:] # (True, None) [1, 2, 3, 4, 5][2:] # [3, 4, 5] 

Сразу сделаем несколько замечаний по использованию выборок:

• Кортежи чаще всего содержат разнородные элементы, поэтому срезы для них менее полезны, чем распаковка и перепаковка: тяжело удерживать в голове типы элементов вместе с индексами
• При выборке по срезу [:] создается новая копия списка, поэтому именно так обычно список и копируют
• Срез порождает новый список или кортеж, но для каждого выбранного элемента копируется только ссылка

Присваивание срезу

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

l = [1, 2, 3, 4, 5, 6] l[::2] = [0, 0, 0] print(l) # => [0, 2, 0, 4, 0, 6] 

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

l = [1, 2, 3, 4] l[::2] = [5, 6, 7] # Traceback (most recent call last): # File "", line 1, in # ValueError: attempt to assign sequence of size 3 to extended slice of size 2 

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

l = [1, 2, 3] l[2:] = [4, 5] print(l) # => [1, 2, 4, 5] l[1:-1] = [100] print(l) # => [1, 100, 5] l[:] = [] print(l) # => [] 

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

Срезы-значения

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

Значение среза можно сконструировать с помощью функции slice :

first_two = slice(2) each_odd = slice(None, None, 2) print(each_odd) # => slice(None, None, 2) l = [1, 2, 3, 4, 5] print(l[first_two]) # => [1, 2] print(l[each_odd]) # => [1, 3, 5] 

Функция slice принимает от одного до трех параметров — те самые START , STOP и STEP . При вызове функции с одним параметром, функция вызывается с параметром STOP .

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

На месте параметров среза могут быть любые выражения, лишь бы эти выражения вычислялись в целые числа или None .

Соотношение START и STOP

В срезе элемент с индексом STOP не попадает в выборку, в отличие от элемента с индексом START .

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

l == l[:n] + l[n:] 

Посмотрим на такой пример:

s = 'Hello!' print(s[:2] + s[2:]) # => 'Hello!' print(s[:4] + s[4:]) # => 'Hello!' print(s[:0] + s[0:] == s) # => True print(s[:100] + s[100:] == s) # => True 

Открыть доступ

Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно

• 130 курсов, 2000+ часов теории
• 1000 практических заданий в браузере
• 360 000 студентов

Наши выпускники работают в компаниях: