Как работают срезы в python

Python: Срезы строк

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

Подстрока — это некоторая часть строки, которую нужно найти и извлечь.

Представим, что у нас есть дата в таком формате: 12-08-2034. Нам нужно извлечь из нее подстроку, в которую входит только год.

Если подумать логически, то нужно посчитать индекс символа, с которого начинается год, и затем извлечь четыре символа. Индексы в строке начинаются с нуля, значит, первый символ года доступен по индексу 6, а последний символ — по индексу 9. Проверим:

value = '12-08-2034' print(value[6]) # => 2 print(value[9]) # => 4 

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

value = '12-08-2034' year = value[6:10] print(year) # => 2034 

Срезы для строк в Python — это механизм, с помощью которого извлекается подстрока по указанным параметрам. В примере выше мы взяли подстроку с 6 индекса по 10 индекс, не включая, то есть с 6 по 9 включительно. Формула выглядит так:

str[начальный индекс:конечный индекс] # Пара примеров value = '01-12-9873' # Срез строки это всегда строка, # даже если внутри строки было число. value[1:2] # '1' value[3:5] # '12' 

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

value = 'Hexlet' value[3:] # 'let' value[:3] # 'Hex' 

Можно указать даже отрицательные индексы. В таком случае отсчет идет с обратной стороны:

value = 'Hexlet' # Правая граница отрицательная. Считаем -1 от конца строки value[3:-1] # 'le' # Левая граница отрицательная. Считаем -5 от конца строки value[-5:3] # 'ex' 

У срезов два обязательных параметра, но иногда используется и третий.

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

value = 'Hexlet' value[1:5:2] # el # 1:5 это 'exle' # шаг 2 это каждый второй, то есть 'e' и 'l' 

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

value = 'Hexlet' value[:5:2] # 'Hxe' value[1::2] # 'elt' 

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

value = 'Hexlet' # Пропускаем обе границы value[::-1] # 'telxeH' 

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

value = 'Hexlet' # Символ с индексом 1 не будет включен в подстроку value[4:1:-1] # 'elx' 

Срезы можно указывать не только через числа, но и с использованием переменных:

value = 'Hexlet' start = 1 end = 5 value[start:end] # 'exle' 

Соберем все вместе:

value = 'Hexlet' value[::] = 'Hexlet' # Вся строка value[:] = 'Hexlet' # Вся строка value[::2] = 'Hxe' # Четные по порядку символы value[1::2] = 'elt' # Нечетные по порядку символы value[::-1] = 'telxeH' # Вся строка в обратном порядке value[5:] = 't' # Строка, начиная с шестого символа value[:5] = 'Hexle' # Строка до шестого символа value[-2:1:-1] = 'elx' # Все символы с предпоследнего до третьего в обратном порядке. Во всех случаях выборки от большего индекса к меньшему нужно указывать шаг 

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

Задание

В переменной value лежит значение Hexlet . Извлеките из него и выведите на экран срез, который получит подстроку xle . Это задание можно сделать разными способами.

Упражнение не проходит проверку — что делать? ��

Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:

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

В моей среде код работает, а здесь нет ��

Тесты устроены таким образом, что они проверяют решение разными способами и на разных данных. Часто решение работает с одними входными данными, но не работает с другими. Чтобы разобраться с этим моментом, изучите вкладку «Тесты» и внимательно посмотрите на вывод ошибок, в котором есть подсказки.

Мой код отличается от решения учителя ��

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

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

Прочитал урок — ничего не понятно ��

Создавать обучающие материалы, понятные для всех без исключения, довольно сложно. Мы очень стараемся, но всегда есть что улучшать. Если вы встретили материал, который вам непонятен, опишите проблему в «Обсуждениях». Идеально, если вы сформулируете непонятные моменты в виде вопросов. Обычно нам нужно несколько дней для внесения правок.

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

Полезное

Определения

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

#8 – Функции строк. Индексы и срезы

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

Видеоурок

Индексы

Нумерация в списках начинается с нуля, так как список по большей части это просто массив, то как в обычном массиве отсчет ведется от 0. Первый элемент по индексу будет 0, второй — 1, третий — 2 и так далее. Если мы попытаемся взять несуществующий элемент, то это приведет к ошибке.

a = [0, 23, "Hi"] # Список print (a[4]) # Выдаст ошибку, так как элемента не существует

Удобной функцией языка Python является возможность брать элементы с конца при помощи отрицательных индексов. К примеру, если нам нужен второй элемент с конца, то мы можем записать это так:

a = [0, 23, "Hi", 1.56, 9] # Список print (a[-2]) # Будет выведено 1.56

Срезы

Срезы позволяют обрезать список, взяв лишь те элементы, которые нужны. Они работают по следующей схеме: list[НАЧАЛО:КОНЕЦ:ШАГ] .

• Начало — с какого элемента стоит начать (по умолчанию равно 0);
• Конец — по какой элемент мы берем элементы (по умолчанию равно длине списка);
• Шаг — с каким шагом берем элементы, к примеру каждый 2 или 3 (по умолчанию каждый 1).

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

list[::3] # Берем каждый третий элемент list[2::2] # Начиная со второго элемента берем каждый второй элемент list[4:6:] # Начиная с 4 элемента берем все элементы по 6 элемент list[::] # Берем все элементы

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

word = 'FootBALL, baskeTball, skate' # print(word.count('!')) # print(word.capitalize()) # print(word.find('pr')) hobby = word.split(', ') for i in range(len(hobby)): hobby[i] = hobby[i].capitalize() result = ", ".join(hobby) print(result)

Посмотреть остальной код можно после подписки на проект!

Задание к уроку

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

Большое задание по курсу

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

Также стоит посмотреть

Комментарии (8)

Николай 15 марта 2023 в 18:59

Какое отношение первое задание имеет к этой тем. В уроке функция enumate вообще не рассматривалась.

Anna 10 февраля 2023 в 17:06

Выведите в списке третий элемент с конца
list_2 = [3.4, 56, «Some», «Hi», 7, 3.8, 44]
print(list_2[-3])

Anna 10 февраля 2023 в 17:03

используйте функцию enumerate.

Anna 10 февраля 2023 в 17:03

Выведите каждый 3 элемент списка начиная с первого и заканчивая предпоследним.

list = [3.4, 56, «Some», «Hi», 7, 3.8, 44]
print(list[:-1:3])

Муса 04 февраля 2023 в 19:44

У вас написано list[2::2] # Начиная со ВТОРОГО элемента. А там с третьего

Zakhar 21 января 2023 в 22:50

 import random print("Welcome to casino XBET!") user_logins = [''] user_passwords = [''] user_choose = input(('Choose registration or log into: ')) if user_choose == 'registration': user_logins.append(input('Create your login: ')) user_passwords.append(input('Create your password: ')) user_enter_login = input('Enter your login: ') if user_enter_login in user_logins: print('The login is Wright') else: print('The login is wrong') user_enter_password = input('Enter your password: ') if user_enter_password in user_passwords: print("The password is right") else: print('The password is wrong') elif user_choose == 'log into': user_enter_login = input('Enter your login: ') if user_enter_login in user_logins: print('The login is Wright') else: print('The login is wrong') user_enter_password = input('Enter your password: ') if user_enter_password in user_passwords: print("The password is right") else: print('The password is wrong') else: exit() balance = 100 print('Your balance = ', balance) while balance > 0: user_num = int(input("Enter your number 1-10: ")) if user_num == random.randrange(1,10): balance += 10 print('You won 10 USD') print('Your balnce is: ', balance) else: balance -= 10 print("You lose 10 USD") print("Your balance is: ", balance) 

Сделал мини казино с тех знаний которые получил

Борис 18 июля 2023 в 15:39

Антон 12 ноября 2023 в 21:42

Shakhboz 24 декабря 2022 в 17:35

What is enumerate? At least, explain in text. There is nothing about it in the video. Thanks!

Андрей 20 октября 2022 в 12:19

enumerate вообще никак не объясняется в видео. Чтобы решить задание, нужно искать инфу в инете. Странный подход к обучению)

Срезы в Python

К вашему вниманию гайд по слайсингу (AKA суши-оператор, слайс, срез)! Наверно, все пишущие на питоне знают о синтаксисе вырезания частей последовательности — s[a:b] . Сейчас же мы рассмотрим как самые очевидные, так и менее известные факты об операции получения среза.

(Но прежде чем начнём, нужно уточнить, что в Python как и во многих других языках последний элемент не включается в срезы и диапазоны, что соответствует индексации с нуля. seq[начало:конец:шаг] (Для вычисления данного выражения Python вызывает seq.__getitem__ ) — берёт срез от НАЧАЛО, до КОНЕЦ (не включая его), с шагом ШАГ. По умолчанию НАЧАЛО = 0, КОНЕЦ = длине объекта, ШАГ = 1. Соответственно, какие-нибудь, а возможно и все ( seq[:], поговорим об этом позже ) параметры могут быть опущены).

Получение по срезу

«Python»

P

Y

T

H

O

N

>>> some_str = "Python" >>> some_str[:1] # Задаём конечным индексом 1, а т.к. конец не включается, мы получим первый элемент последовательности ('P'). 'P' >>> PYTH = slice(0, 4) # Вместо того чтоб загромождать код вшитыми диапазонами, мы можем проименовать их (например для упрощения разбора накладной). >>> some_str[PYTH] 'Pyth' >>> some_str[::2] # Шагаем через букву. 'Pto'

Немного о NumPy

Оператор [] может принимать несколько индексов или срезов, разделённых запятыми a[m:n, k:l] . В основном это используется в NumPy для получения двумерного среза и a[i, j] для получения одного элемента двумерного массива. Соответственно для вычисления a[i, j] Python вызывает a.__getitem__((i, j)) . Кстати, т.к. » . » (единственный экземпляр класса ellipsis) распознаётся как лексема, то мы его можем использовать так же и в срезах. Применение этому нашлось в том же NumPy для сокращённого создания среза двумерного массива. Детальнее — https://scipy.github.io/old-wiki/pages/Tentative_NumPy_Tutorial.

Удаление по срезу

Так же мы можем удалять элементы последовательности по срезу с учётом того, что она поддерживает удаление элементов (изменяема))). Приведу пример с рантайм классом SupportsDeletion .

>>> import typing >>> @typing.runtime_checkable >>> class SupportsDeletion(typing.Protocol): >>> def __delitem__(self, key: typing.Any) -> typing.Any: >>> . >>> for builtin_type in (list, dict, str, tuple): >>> print(builtin_type.__name__, "->", isinstance(builtin_type, SupportsDeletion)) list -> True dict -> True str -> False tuple -> False

>>> seq = [1, 2, 3, 4] >>> del seq[:3] # Удаляем первых три элемента последовательности. >>> seq [4]

Лайфхаки 🙂

№1 Можно перевернуть последовательность, если запросить срез seq[::-1]

>>> seq = (1, 2, 3, 4, 5, 6) >>> seq[::-1] (6, 5, 4, 3, 2, 1)

№2 Как удалить все элементы списка с помощью слайса, не разрушая сам обьект-список? (Разумеется, тот же результат можно получить вызвав метод .clear() у списка, но мы же сейчас про слайсы говорим + его нет во второй версии питона).

>>> seq = [1, 2, 3, 4, 5, 6] >>> id(seq) 2071031395200 >>> del seq[:] >>> id(seq) 2071031395200 >>> seq []

№3 Помимо очистки списков, нарезку также можно использовать для замены всех элементов списка, не создавая новый объект-список. Это отличная сокращённая запись для очистки списка и затем повторного его заполнения вручную:

>>> seq = [1, 2, 3, 4, 5, 6, 7] >>> original_list = seq >>> seq[:] = [1, 2, 3] >>> seq [1, 2, 3] >>> original_list [1, 2, 3] >>> original_list is seq True

Приведённый выше пример кода заменил все элементы в seq , но не уничтожил и воссоздал список как таковой. По этой причине старые ссылки на оригинальный объект-список по-прежнему действительны.

№4 Создание мелких копий существующих списков:

>>> seq = [1, 2, 3, 4, 5, 6, 7] >>> copied_list = seq[:] >>> copied_list [1, 2, 3, 4, 5, 6, 7] >>> copied_list is seq False

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

Если же вам необходимо продублировать абсолютно всё, включая и элементы, то необходимо создать глубокую копию списка ( copy.deepcopy(x) ). Для этой цели пригодится встроенный модуль в Python copy.

Ключевые выводы

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

Срезы — 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 студентов

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