Наружная нотация – простое иллюстрированное руководство

Автор оригинала: Shubham Sayon.

Резюме: Нарезка – это концепция Python для извлечения подпоследовательности из строки или списка, которая лежит в пределах Начать и Стоп Диапазон индекса. Существует два синтаксических способа определить ломтик. (1) Расширенный нарезной обозначение использует толстую кишку : в string_name [Пуск: Stop: Step] Отказ (2) ломтик () Конструктор определяет диапазон индекса в String_name [Slice (Start: Stop: Step)] Отказ

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

Упражнение : Создайте еще два примера в оболочке интерактивного кода.

Давайте узнаем о нарезной обозначении в пошаговой манере.

Основы индексации

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

Индекс можно рассматривать как положение элемента в упорядоченном типе данных (например, файл или кортеж). Строка может рассматриваться как список символов с каждым символом, имеющим индекс.

• Индексирование начинается с нуля до длины – 1.
• Python также поддерживает негативную индексацию.

Давайте визуализируем индексацию с помощью диаграммы:

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

Введение в нарезку

Определение:

Нарезка относится к концепции в Python, которая позволяет нам извлекать часть строки или списка или любой другой последовательности на основе указанного индекса запуска и остановки.

Синтаксис:

• Нарезка использует [] С началом, остановкой и шагом аргументов разделены : Обозначение.
• Начать Определяет индекс, из которого начинается нарезка/извлечение элементов струны/последовательности.
• Если Начать Индекс не указан, он считается 0.
• Стоп Определяет последний индекс, пока какое нарезка не выполняется, однако, остановка/последний индекс – Исключен при создании подстроки. Это означает, что последний индекс, который принимается во внимание при создании вывода (подстроки), является Стоп-1 Отказ Это очень важный момент, чтобы помнить, чтобы избежать неожиданных результатов и ошибок в коде.
• Если Стоп Индекс не указан, он считается длиной всей строки или заданной последовательности.
• шаг Определяет приращение между каждым индексом при наресении последовательности.
• Это необязательный аргумент. На самом деле все три аргумента являются необязательными. Мы скоро узнаем, как!
• Если шаг Не указано, что он считается значением по умолчанию 1, то есть приращение 1 между индексами.

Пример:

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

name = "FINXTER"
# [start:stop] --> items from start through stop-1
print(name[1:6])
# [:stop] --> items from the beginning of string through stop-1 
print(name[:6])
# [start:] --> items from start through end of string
print(name[1:])
# [start:stop:step] --> items from start through stop with step-size
print(name[1:6:2])
# Entire String!
print(name[:])

Выход:

INXTE
FINXTE
INXTER
IXE
FINXTER

Размер шага в нарезке

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

Используйте Case 1: Пользовательское приращение между индексами Пока нарезка

Как упоминалось ранее, если размер шага не указан, приращение между индексами в указанном диапазоне считается 1. Это означает, что все индексы в указанном диапазоне/ломтике данной строки будут учитываться, и вся подстрока будет сгенерирована как вывод без пропускания ни одного элемента между ними. Однако, если мы хотим создать строку, так что значение между индексами увеличивается по любому значению, отличному от 1, мы можем использовать размер шага для уточнения таких приращений. Другими словами, размер шага можно использовать для пропуска индексов в пределах указанного ломтика.

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

Пример: Учитывая строку «FPIYNTXHTEENR»; Как извлечь элементы на четные позиции/нечетные индексы (учитывая первую позицию как 1)?

name = "FPIYNTXHTOENR"
print(name[1:12:2])

Выход:

PYTHON

Хотя вышеуказанная программа является самоуверенностью; Давайте посмотрим на следующую диаграмму для визуализации вышеуказанного фрагмента, так что концепция поэтапного размера прозрачна.

Используйте корпус 2: размер отрицательного шага

Нарезка предоставляет нам возможность отрицательного размера шага. Поэтому вы можете нарезать последовательность или строку в обратном направлении, используя размер отрицательного шага. Это может быть инструментальным в операциях, таких как изменение строки.

Пример: Учитывая строку «мадам»; Проверьте, является ли строка палиндром с использованием отрицательного размера шага.

# String which reads the same backward as forward is a Palindrome string
name = "MADAM"
# Reversing the string using a negative step-size
palindrome = (name[::-1])
if name == palindrome:
  print(palindrome," is a Palindrome String. ")

Выход:

MADAM  is a Palindrome String.

Нарезка через негативные показатели

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

Пример:

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

string = "HELLO WORLD"
# [-start:-stop]
print(string[-11:-6])
# [:stop]
print(string[:-6])
# [start:]
print(string[-5:])
# Entire String using negative Indexing
print(string[-11:])
# [start:stop:step]
print(string[-11:-6:2])
# -Index and -Step to slice and reverse string
print(string[-1:-6:-1])

Выход:

HELLO
HELLO
WORLD
HELLO WORLD
HLO
DLROW

Использование среза () Конструктор

В приведенных выше примерах мы фактически использовали ломтик () Объект с использованием : Обозначение в квадратных скобках []. ломтик () является встроенным конструктором, который используется для создания объекта среза, который представляет подмножество всей последовательности.

Синтаксис Для использования объекта среза:

• Оба синтаксиса поддерживаются в Python при использовании ломтик () объект.
• Чтобы заменить аргумент с пустой записью, вы можете использовать Нет Отказ Например, чтобы повторить строка [1:] Вы можете использовать строка [ломтик (1, нет)]]

Поскольку у нас уже есть идея о индексации и нарезке, давайте контрастным и сравним ломтик () Объект и основной : Обозначение на основе нарезки в Python.

• string_name [Ломтик (запуск, остановка, шаг)] эквивалентно string_name [Пуск: Stop: Step] где Начать, остановиться и шаг Аргументы имеют подобное значение в обоих случаях. Однако ломтик () Объекты имеют немного другое поведение, основанное на количестве аргументов.

Лучший способ сравнения двух обозначений – визуализировать их с помощью примеров. Таким образом, давайте погрузимся в код, приведенный ниже, чтобы сравнить, а контрастность нарезки с использованием ломтик () и основной : Обозначение –

name = "FINXTER"
print("Original String = ", name)
print("\nScenario 1")
# [start:stop] --> items from start through stop-1
print("Output Using : Notation >> ",name[1:6])
print("Output Using slice Object >> ",name[slice(1,6)])

print("\nScenario 2")
# [:stop] --> items from beginning of string through stop-1 
print("Output Using : Notation >> ",name[:6])
print("Output Using slice Object >> ",name[slice(6)])

print("\nScenario 3")
# [start:] --> items from start through end of string
print("Output Using : Notation >> ",name[1:])
print("Output Using slice Object >> ",name[slice(1,7)])

print("\nScenario 4")
# [start:stop:step] --> items from start through stop with step-size
print("Output Using : Notation >> ",name[1:6:2])
print("Output Using slice Object >> ",name[slice(1,6,2)])

print("\nScenario 5")
# Entire String!
print("Output Using : Notation >> ",name[:])
print("Output Using slice Object >> ",name[slice(7)])

Выход:

Original String =  FINXTER

Scenario 1
Output Using : Notation >>  INXTE
Output Using slice Object >>  INXTE

Scenario 2
Output Using : Notation >>  FINXTE
Output Using slice Object >>  FINXTE

Scenario 3
Output Using : Notation >>  INXTER
Output Using slice Object >>  INXTER

Scenario 4
Output Using : Notation >>  IXE
Output Using slice Object >>  IXE

Scenario 5
Output Using : Notation >>  FINXTER
Output Using slice Object >>  FINXTER

Прощающий синтаксис нарезки

Python действительно прощает, когда дело доходит до нарезки, потому что даже если вы указываете индекс, который превышает фактический максимальный индекс последовательности, вы не получите ошибку, а вывод будет отображаться на экране без каких-либо хлопот. Даже если вы начнете с индекса, который недействителен, вы не найдете ошибку, вместо этого Python просто вернет пустую строку.

Давайте посмотрим на приведенный ниже пример, который разъясняет прощающий синтаксис нарезки в Python:

name = "FINXTER"
# prints entire string
print(name[0:10000])
# prints empty string
print(name[10000:10000])
# prints the element at first index
print(name[0::10000])
# Using None is same as using a zero at beginning
# or Not specifying any arguement 
print(name[None:])
print(name[2:None])

Выход:

FINXTER

F
FINXTER
NXTER

Нарезка с другими типами последовательности

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

Пример:

li = ["apple","banana","Orange"]
tup = ("Python","Java","C++")

#slicing the list
print(li[slice(0,2,1)])
print(li[slice(1)])
print(li[slice(None)])

# slicing the tuple
print(tup[0:2:1])
print(tup[:1])
print(tup[::])

Выход:

['apple', 'banana']
['apple']
['apple', 'banana', 'Orange']
('Python', 'Java')
('Python',)
('Python', 'Java', 'C++')

Заключение

Ключевые вынос из этой статьи:

1. Основы индексации.
2. Нарезка с использованием [Старт: Стоп: Шаг] Обозначение.
3. Нарезка с использованием ломтик () объект.
4. Размер шага и его использование.
5. Нарезка с использованием негативных индексов.
6. Нарезка других последовательных типов данных.

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

Куда пойти отсюда?

Достаточно теории, давайте познакомимся!

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

Практические проекты – это то, как вы обостряете вашу пилу в кодировке!

Вы хотите стать мастером кода, сосредоточившись на практических кодовых проектах, которые фактически зарабатывают вам деньги и решают проблемы для людей?

Затем станьте питоном независимым разработчиком! Это лучший способ приближения к задаче улучшения ваших навыков Python – даже если вы являетесь полным новичком.

Присоединяйтесь к моему бесплатным вебинаре «Как создать свой навык высокого дохода Python» и посмотреть, как я вырос на моем кодированном бизнесе в Интернете и как вы можете, слишком от комфорта вашего собственного дома.

Присоединяйтесь к свободному вебинару сейчас!

Я профессиональный Python Blogger и Content Creator. Я опубликовал многочисленные статьи и создал курсы в течение определенного периода времени. В настоящее время я работаю полный рабочий день, и у меня есть опыт в областях, таких как Python, AWS, DevOps и Networking.

Вы можете связаться со мной @:

• Заработка
• Linkedin.

Оригинал: “https://blog.finxter.com/slice-notation-a-simple-illustrated-guide/”