С чего обычно начинается индекс в python

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

Все сталкиваются с индексами на самых ранних стадиях освоения языка, как правило, при изучении списков. Вероятно, вы и так знаете, что индексация в Python начинается с нуля. У нас есть список movies , тогда операция movies[0] вернёт первый элемент списка.

Да, для новичков считать от нуля до девяти при работе со списком из десяти элементов поначалу кажется немного странным. Python в этом не уникален — в большинстве языков программирования реализован такой же подход (C, C++, Java, C# и JavaScript).

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

• Она почти никогда не используется в циклах. Да, мы можем перебирать индексы элементов объекта в цикле for вместо перебора собственно элементов, но это не норма.
• Можно использовать отрицательные индексы, они начинаются с -1. -1 возвращает последний элемент, -2 возвращает предпоследний и так далее.
• Для извлечения сразу нескольких элементов можно использовать расширенную форму индексации — срезы. Используя срезы в сочетании с отрицательными индексами можно, например, развернуть последовательность. Также можно указывать шаг среза для составления гибких правил извлечения нужных элементов.

Если вы новичок в Python, и вам пока не знакомы эти концепции, то в этой статье мы как раз рассмотрим несколько практических примеров.

Простая прямая индексация

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

numbers = [42, 1941, 1066, 1969] indexes = "Всё очень просто!" names = ("Moran", "Székely", "Carlin") print(numbers[0]) last_index = len(indexes) - 1 print(indexes[last_index]) print(f"Самым смешным комиком оказался .")

Вывод:

42 ! Самым смешным комиком оказался Carlin.

Опять же, во всех случаях индекс первого элемента равен нулю, а последнего —длина объекта минус единица. Использование индекса за пределами этого диапазона приведёт к тому, что Python выдаст ошибку IndexOutOfBounds .

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

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

numbers = [1, 2, 8, 4] print(numbers) # Изменяем третий элемент списка numbers[2] = 3 print(numbers)

Вывод:

[1, 2, 8, 4] [1, 2, 3, 4]

Обратная индексация в Python

Обратная индексация в Python предполагает доступ к элементам при помощи отрицательных чисел. Она начинается с конца объекта и идёт в обратном порядке. То есть, мы можем получить последний элемент при помощи индекса -1. Доступ к предпоследнему элементу можно получить с помощью -2 и так далее.

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

Давайте возьмём последний символ из строки Zen of Python, используя прямую и обратную индексацию:

saying = "Simple is better than complex" # получаем последний элемент прямой индексацией print(saying[len(saying) - 1]) # используем обратную print(saying[-1])

Вывод:

Обратная индексация также может быть удобна в рамках среза для изменения порядка элементов объекта.

Работа с индексами в цикле for

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

#include int main(void) < const int LEN = 3; char chars[LEN] = ; for(int i = 0; i < LEN; i++) < printf("Найден символ по индексу %d: %c\n", i, chars[i]); >>

Вывод:

Найден символ по индексу 0: A Найден символ по индексу 1: B Найден символ по индексу 2: C

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

chars = ["A", "B", "C"] for char_ in chars: print(char_)

Вывод:

A B C

Так всегда и нужно писать за исключением редких ситуаций, когда нам напрямую нужно оперировать с индексами в рамках логики какого-то алгоритма. Тут поможет функция enumerate , которая позволяет получить и индекс, и значение одновременно. Вот как мы можем получить тот же результат, что и в коде C:

chars = ["A", "B", "C"] for index, char in enumerate(chars): print(f"Найден символ по индексу : ")

Вывод:

Найден символ по индексу 0: A Найден символ по индексу 1: B Найден символ по индексу 2: C

Срезы Python: индексы на стероидах

Срезы — главное, что отличает функционал индексов в Python от многих других языков. Если индекс позволяет нам извлекать один элемент, то срезы позволяют нам извлекать (или присваивать) сразу несколько элементов. Как и в случае с индексами, выражение помещается после имени объекта в квадратные скобки и имеет следующий базовый синтаксис:

• Значение start — это целое число, которое является началом (левой границей) среза. Если его не ставить, то по умолчанию равен нулю, то есть началу последовательности.
• Значение stop — это целое число, представляющее собой конец среза (его правую границу). Очень важно помнить, что правая граница предполагает нужный вам последний индекс + 1. То есть правая граница сама по себе в результат не входит. Если её не ставить, то по умолчанию используется длина объекта («до самого конца»).
• Значение step — целое число, шаг среза, по умолчанию равен 1. Шаг среза последовательно прибавляется к каждому индексу от левой границы до правой, результирующие элементы будут в выборке. Т.е. если шаг равен 1, то берётся каждый элемент, если 2 — через один. А если шаг равен -1, то элементы выбираются справа налево.

Давайте посмотрим на это наглядно, начав со срезов с прямой индексацией:

numbers = [1, 2, 3, 4, 5] # срезы от нуля до двух, с явным или неявным началом среза print("Индексы от нуля до двух") print(numbers[0:3]) print(numbers[:3]) # вариант аналогичный предыдущему # Индексы от 3 до конца списка print("\nИндексы от 3 до конца списка") print(numbers[3:len(numbers)]) print(numbers[3:]) # Делаем неглубокую копию списка print("\nКопия списка") print(numbers[:]) # Получем все элементы через 1 print("\nС шагом 2:") print(numbers[::2])

Вывод:

Индексы от нуля до двух [1, 2, 3] [1, 2, 3] Индексы от 3 до конца списка [4, 5] [4, 5] Копия списка List copy: [1, 2, 3, 4, 5] С шагом 2: Step by two: [1, 3, 5]

Срезы могут быть удобными, например, для удаления фиксированного префикса из строк:

# Удаляем "id-" из строк в списке: order_items = ["id-999", "id-19098", "id-2"] cleaned = [item[3:] for item in order_items] print(cleaned)

Вывод:

['999', '19098', '2']

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

numbers = [1, 2, 3, 4, 5] print(numbers[::-1]) print(numbers[4:2:-1])

Вывод:

[5, 4, 3, 2, 1] [5, 4]

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

Срезы для присваивания

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

count_to_ten = [num for num in range(1,11)] count_to_ten[3:6] = [20, 30] count_to_ten count_to_ten[6:8] = [100, 200, 300, 400] print(count_to_ten)

Вывод:

[1, 2, 3, 20, 30, 7, 100, 200, 300, 400, 10]

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

Задачки по индексации и срезам

Вот несколько упражнений, которые помогут вам закрепить эту тему.

1. Что мы получим в результате запуска приведённого ниже кода? Сможете ли вы заменить все строки, кроме импорта, на один print , который выведет аналогичную строку?

from string import ascii_uppercase subset = "" for idx, letter in enumerate(ascii_uppercase): if idx % 4 == 0: subset = subset + letter print(subset)

2. Используя ascii_uppercase , выведите алфавит в обратном порядке при помощи среза.

3. Находим иголку в стоге сена. При помощи срезов, метода index и функции len выведите строку «иголка», где бы она ни располагалась в example .

example = "сено сено сено иголка сено сено сено, привет, привет, пока."

4. При помощи среза из приведённого ниже списка выведите такой результат: [9, 6, 3]

count_to_ten = [num for num in range(1,11)] print(count_to_ten)

5. Из имеющегося списка при помощи индексов выведите на экран только слово «клубнику».

tokens = "Тут хоть где-нибудь можно купить клубнику?".split(" ") print(tokens)

6. Как думаете, что мы увидим в результате вызова claim.index(«Python») ?

claim = "В том материалы вы узнали про индексы и срезы в Python".split() print(claim)

7. Что увидим на экране в качестве вывода?

greeting = "Hello" print(greeting[4]) print(greeting[5])

Индексы и срезы

Сегодня мы поговорим об операциях взятия индекса и среза.

Взятие элемента по индексу

Как и в других языках программирования, взятие по индексу:

  File 

Как и во многих других языках, нумерация элементов начинается с нуля. При попытке доступа к несуществующему индексу возникает исключение IndexError.

В данном примере переменная a являлась списком, однако взять элемент по индексу можно и у других типов: строк, кортежей.

В Python также поддерживаются отрицательные индексы, при этом нумерация идёт с конца, например:

  File 

Срезы

В Python, кроме индексов, существуют ещё и срезы.

item[START:STOP:STEP] — берёт срез от номера START, до STOP (не включая его), с шагом STEP. По умолчанию START = 0, STOP = длине объекта, STEP = 1. Соответственно, какие-нибудь (а возможно, и все) параметры могут быть опущены.

Также все эти параметры могут быть и отрицательными:

       В последнем примере получился пустой список, так как START < STOP, а STEP отрицательный. То же самое произойдёт, если диапазон значений окажется за пределами объекта:

 
Для вставки кода на Python в комментарий заключайте его в теги 




Модуль csv - чтение и запись CSV файлов
Создаём сайт на Django, используя хорошие практики. Часть 1: создаём проект
Онлайн-обучение Python: сравнение популярных программ


Книги о Python
GUI (графический интерфейс пользователя)
Курсы Python
Модули
Новости мира Python
NumPy
Обработка данных
Основы программирования
Примеры программ
Типы данных в Python
Видео
Python для Web
Работа для Python-программистов


Сделай свой вклад в развитие сайта!
Самоучитель Python
Карта сайта
Отзывы на книги по Python
Реклама на сайте

#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
Индексация и разделение строк в 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] , будет пропущен каждый второй символ. Выводимые символы обозначены красным цветом:
S a m m y S h a r k !






Обратите внимание, что символ пробела с индексом 5 также пропускается, если задан шаг 2.
Если мы используем более крупное значение шага, подстрока будет значительно короче:
print(ss[0:12:4]) 
Output
Sya 
Если мы укажем шаг 4 как последний параметр синтаксиса Python ss[0:12:4] , будет выведен только каждый четвертый символ. Выводимые символы также обозначены красным цветом:
S amm y Sh a rk!
В этом примере символ пробела тоже пропускается.
Поскольку мы выводим всю строку, мы можем опустить два индекса и оставить два двоеточия в синтаксисе, чтобы получить тот же результат:
print(ss[::4]) 
Output
Sya 
Если мы пропустим два индекса и оставим запятые, мы включим в диапазон всю строку, а последний параметр будет определять шаг, то есть, количество пропускаемых символов.






Также мы можем указать отрицательное значение шага и использовать его для вывода исходной строки в обратном порядке, если зададим шаг -1:
print(ss[::-1]) 
Output
!krahS ymmaS 
Два двоеточия без параметров означают вывод всех символов первоначальной строки, шаг 1 означает вывод всех символов без пропуска, а отрицательное значение шага изменяет порядок вывода символов на противоположный.
Давайте повторим эту команду, но используем шаг -2:
print(ss[::-2]) 
Output
!rh ma 
В этом примере, ss[::-2] , мы включаем в диапазон всю первоначальную строку, поскольку индексы не указаны, и задаем обратный порядок вывода отрицательным значением шага. Кроме того, с шагом -2 мы пропускаем каждую вторую букву строки, выводимой в обратном порядке:
! k r a h S [пробел] y m m a S
В этом примере выводится символ пробела.
Задавая третий параметр синтаксиса среза 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() можно использовать для определения длины, количества символов или последовательностей символов и индексов символов или последовательностей символов в строках.
Заключение 
Возможность вызова определенных индексов строк или конкретного среза строки дает дополнительную гибкость при работе с этим типом данных. Поскольку строки относятся к последовательному типу данных, как списки и кортежи, для доступа к ним можно использовать индексы и срезы.
Чтобы продолжить изучение строк, вы можете прочитать дополнительные материалы по форматированию строк и методам строк.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.


Похожие публикации:

Hash mismatch радмир ошибка что делать
Как говорить о деньгах на собеседовании
Как установить json для python
Что такое 256 битное шифрование