Эта статья была первоначально опубликована в Что такое нарезка на Python?
Нарезка в Python – это функция, которая обеспечивает доступ к частям последовательностей, таких как строки, кортежи и списки. Вы также можете использовать их для изменения или удаления элементов измененных последовательностей, таких как списки. Срезы также могут быть применены к сторонним объектам, таким как массивы Numpy, а также серии Pandas и рамки данных.
Нарезка позволяет чистить чистый, краткий и читаемый код.
В этой статье показано, как получить доступ, изменять и удалять элементы с помощью индексов и ломтиков, а также как использовать встроенный класс Slice ().
Индексация
Вы можете получить доступ к одному элементу последовательности Python (например, String, Tupple или List) с соответствующими целочисленными показателями. Индексы в Python основаны на нулевом уровне. Это означает, что индекс 0 соответствует первому (крайнему левому) элементу последовательности, 1 ко второму элементу, и так далее.
Давайте создадим одну строку, одну кортеж и один список, чтобы проиллюстрировать, как использовать индексы:
>>> str_ = 'Python is awesome!' >>> str_ 'Python is awesome!' >>> tuple_ = (1, 2, 4, 8, 16, 32, 64, 128) >>> tuple_ (1, 2, 4, 8, 16, 32, 64, 128) >>> list_ = [1, 2, 4, 8, 16, 32, 64, 128] >>> list_ [1, 2, 4, 8, 16, 32, 64, 128]
Индексы предоставляются внутри кронштейнов, то есть с синтаксической последовательности [индекс]:
>>> str_[0] 'P' >>> str_[1] 'y' >>> str_[4] 'o' >>> tuple_[0] 1 >>> tuple_[1] 2 >>> tuple_[4] 16 >>> list_[0] 1 >>> list_[1] 2 >>> list_[4] 16
Как вы можете видеть, «P» – первый символ строки «Python потрясающий!» и это соответствует индексу 0, «y» является вторым и имеет индекс 1 и так далее.
Это очень похоже на кортежи и списки.
Python предоставляет возможность использовать негативные целочисленные индексы. Это кажется очень полезным на практике, особенно если вы хотите получить доступ к последнему (самым правому) элементу последовательности.
Индекс -1 соответствует последним элементе -2 на второй последний, и так далее:
>>> str_[-1] '!' >>> str_[-2] 'e' >>> str_[-5] 's' >>> tuple_[-1] 128 >>> tuple_[-2] 64 >>> tuple_[-5] 8 >>> list_[-1] 128 >>> list_[-2] 64 >>> list_[-5] 8
Как вы можете видеть, персонаж «!» это последний элемент в строке ‘ Python потрясающий! И это соответствует индексу -1. Он также имеет индекс 17, который является String_ [17] Возврат «!». Персонаж «E» происходит прямо перед ним и имеет индекс -2 и 16.
Опять же, кортежи и списки ведут себя аналогично.
Вы можете использовать индексы для изменения элементов изменчивой последовательности. В Python строки и кортежи неизменяются, но списки измеряются:
>>> list_[-1] = 100 >>> list_ [1, 2, 4, 8, 16, 32, 64, 100]
Этот пример изменяет последний элемент списка на 100. Поскольку этот список имеет восемь элементов, вы также можете получить доступ к последнему элементу с помощью индекса 7 на основе нуля, то есть вы можете выполнить тот же эффект с утверждением.
Нарезка
Нарезка аналогична индексированию, но возвращает последовательность предметов вместо одного элемента. Индексы, используемые для нарезки, также на основе нуля.
Существует два варианта синтаксиса нарезов: последовательность [Start: Stop] и последовательность [Start: Stop: Step]. Эта статья объясняет оба.
Когда вы используете синтаксическую последовательность [Пуск: Stop], вы получите новую последовательность. Он начнет с элемента, который имеет начало индекса (включительно) и заканчивается перед тем, как элемент с остановкой индекса. Другими словами, последовательность операторов [Start: Stop] возвращает последовательность элементов [Start], последовательность [Stop-1] и все элементы между ними:
>>> str_[1:5] 'ytho' >>> tuple_[2:4] (4, 8) >>> tuple_[2:3] (4,) >>> tuple_[2:2] ()
Как видите, возвращающаяся последовательность может содержать только один элемент при запуске + 1 или его может быть пустой последовательностью при запуске.
Когда вы опускаете запуск, значение 0 принимается, то есть полученная последовательность начинается в начале оригинала:
>>> str_[:2] 'Py' >>> tuple_[:4] (1, 2, 4, 8)
Если вы опускаете остановку, полученная последовательность останавливается в конце оригинала:
>>> str_[2:] 'thon is awesome!' >>> tuple_[4:] (16, 32, 64, 128)
Постоянно, вы можете опустить как начать, так и остановить:
>>> str_[:] 'Python is awesome!' >>> tuple_[:] (1, 2, 4, 8, 16, 32, 64, 128) >>> list_[:] [1, 2, 4, 8, 16, 32, 64, 100]
Вот как вы получаете неглубокую копию последовательности.
Можно применить отрицательные значения запуска и остановки, как с индексами:
>>> str_[-8:] 'awesome!' >>> tuple_[:-1] (1, 2, 4, 8, 16, 32, 64) >>> tuple_[-4:-2] (8, 16) >>> tuple_[3:5] (8, 16)
В случае TUPLE_, значение -4 – при подсчетах от -1 – соответствует тому же элементу, что и значение 3 при подсчете вперед от 0. Это то же самое для значений 5 и -2. Опять же, элемент, который соответствует остановке индекса, не включен в полученную последовательность.
Синтаксическая последовательность [Пуск: Stop: Step] аналогична, но с еще несколькими деталями.
Вы можете использовать шаг, чтобы указать шаг, если хотите пропустить некоторые элементы:
>>> tuple_[1:5:2] (2, 8)
В этом примере этап – 2, поэтому вы начинаете с элемента, который имеет индекс 1 (элемент 2), соберите каждый второй элемент, и останавливаться, прежде чем добраться до элемента с помощью индекса 5 (32). Вы принимаете товар 2, пропустить 4 и взять 8.
Если шаг положительный, и вы опускаете начало, полученная последовательность снова начинается в начале оригинала. Если вы опускаете остановку, операция останавливается в конце оригинала. Однако, если вы опустите шаг, он считается 1, и вы получаете то же поведение, что и при синтаксической последовательности [Пуск: Stop]:
>>> tuple_[:6:2] (1, 4, 16) >>> tuple_[3::2] (8, 32, 128) >>> tuple_[1:5:] (2, 4, 8, 16)
Негативное значение шага, в сочетании с началом, больше, чем остановка, может быть использовано для сбора элементов назад:
>>> tuple_[4:1:-1] (16, 8, 4) >>> tuple_[6:1:-2] (64, 16, 4)
В случаях с отрицательным шагом и опущенным запуском, полученная последовательность начинается в конце оригинала. Если вы опустите, чтобы остановиться, операция останавливается в начале оригинала:
>>> tuple_[:2:-1] (128, 64, 32, 16, 8) >>> tuple_[5::-1] (32, 16, 8, 4, 2, 1)
Эти правила удобно применяются, чтобы получить мелкую копию последовательности с элементами в обратном порядке, пропуская и, как начало, и остановку:
>>> tuple_[::-1] (128, 64, 32, 16, 8, 4, 2, 1)
Вы можете использовать срезы для изменения элементов изменяющихся последовательностей:
>>> list_[1:6:2] [2, 8, 32] >>> list_[1:6:2] = [20, 80, 320] >>> list_ [1, 20, 4, 80, 16, 320, 64, 100]
В этом примере предметы с индексами 1, 3 и 5 доступны и изменены.
Если вы используете синтаксическую последовательность [Пуск: Stop], можно заменить часть последовательности с меньшим или большей:
>>> list_[1:5] [20, 4, 80, 16] >>> list_[1:5] = [0, 0] >>> list_ [1, 0, 0, 320, 64, 100]
В этом примере удаляются четыре элемента ([20, 4, 80, 16]), и вместо этого добавляются два новых ([0, 0]).
Следуя этой логике, вы можете удалить части мусорных последовательностей, заменив их пустыми последовательностями, такими как []:
>>> list_[1:3] [0, 0] >>> list_[1:3] = [] >>> list_ [1, 320, 64, 100]
Также можно удалить части последовательностей, используя срезы в операторе DEL:
>>> list_[:2] [1, 320] >>> del list_[:2] >>> list_ [64, 100]
Таким образом, есть два подхода, чтобы удалить часть списка. Тем не менее, последний кажется более читаемым и легко понятным, потому что использование заявления DEL делает ваше намерение (чтобы что -то удалить) очевидным.
Что такое ломтики?
Срезы-это экземпляры встроенного класса среза Python. Вы создаете их с помощью ломтика оператора (запуск, остановка, шаг). Можно передать экземпляр среза вместо начала: остановите: шаг или запуск: остановите:
>>> s = slice(1, 5, 2) >>> s slice(1, 5, 2) >>> s.start, s.stop, s.step (1, 5, 2) >>> tuple_[s] (2, 8)
Опять же, вы можете опустить шаг и получить поведение начала: Стоп:
>>> s = slice(1, 5) >>> s.start, s.stop, s.step (1, 5, None) >>> tuple_[s] (2, 4, 8, 16)
Если вы передаете один аргумент, Slice использует его как остановку и ведет себя как: Stop:
>>> s = slice(5) >>> s.start, s.stop, s.step (None, 5, None) >>> tuple_[s] (1, 2, 4, 8, 16)
Вы можете манипулировать ломтиками внутри функций и методов:
>>> def get_items_with_slice(sequence, start, stop, step): ... return sequence[slice(start, stop, step)] ... >>> get_items_with_slice([1, 2, 4, 8, 16, 32, 64, 128], 1, 5, None) [2, 4, 8, 16]
Эта функция использует свои собственные аргументы для создания среза и передает его, чтобы получить некоторые данные из последовательности.
Наконец, вот пример того, как вы можете использовать срезы в сочетании с специальным методом Python _ getite _ () Чтобы определить класс, экземпляры которых можно использовать с уведомлением индекса:
>>> class C:
... def __init__(self, *args):
... self.__data = args
... def __getitem__(self, index_or_slice):
... print('index or slice:', index_or_slice)
... return self.__data[index_or_slice]
...
>>> x = C(1, 2, 4, 8, 16, 32, 128)
>>> x[4]
index or slice: 4
16
>>> x[1:5:2]
index or slice: slice(1, 5, 2)
(2, 8)
Если вы передаете целое число в __getItem __ () это будет вести себя как индекс себя. данные. Если вы проходите старт: Stop: Step вместо, ` getItem __ () `на самом деле получает объект Slice в качестве аргумента.
Вы также можете использовать __setitem __ () изменять данные и __delitem __ () Чтобы удалить данные, потенциально в сочетании с ломтиками.
Выводы
Эта статья показывает, как использовать срезы в Python. Они очень мощные и полезны, когда вам нужно извлечь элементы из последовательностей, таких как строки, кортежи и списки. Также, Некоторые сторонние объекты, такие как Numpy Armays и серии Panda и кадры данных.
Вы можете использовать срезы внутри функций и методов. Если вы хотите определить классы с возможностью доступа, изменения или удаления данных с помощью экземпляра [index_or_slice], вам следует реализовать специальные методы __getItem __ (), __setItem __ () или __delitem __ () и, возможно, применить кусочки.
Спасибо за чтение!
Оригинал: “https://dev.to/duomly/what-is-slicing-in-python-58f2”