Строки: индексы, срезы и методы

Считайте символы с нуля, не забывая про пробелы: они тоже символы.

In 2010, — это восемь символов, значит, запятая стоит на восьмом месте, то есть с индексом 7.

1. I — 0, n — 1, пробел — 2, 2 — 3, 0 — 4, 1 — 5, 0 — 6, запятая — 7.
2. Значит, s[7].

s = 'In 2010, someone paid 10k Bitcoin for two pizzas.'
print(s[7])   # I n _ 2 0 1 0 , — запятая восьмая по счёту, индекс 7

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

Буква w встречается в строке один раз — в слове two.

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

1. От конца строки удобнее: ...two pizzas. — после w идёт o pizzas., это девять символов.
2. Значит, w — десятый с конца: s[-10]. Слева это индекс 39.

s = 'In 2010, someone paid 10k Bitcoin for two pizzas.'
print(s[-10])   # десятый символ с конца; то же самое, что s[39]

Отрицательный индекс здесь короче и надёжнее: считать девять символов с конца проще, чем тридцать девять с начала. Оба варианта верны — выбирайте тот, где меньше шансов ошибиться.

Здесь важен именно номер символа — значит, перебирать надо индексы.

У range() есть третий параметр — шаг.

1. Индексы нужны через один: 0, 2, 4, …
2. range(0, len(s), 2) даёт ровно их.
3. Печатаем s[i] на каждом шаге.

s = input()

for i in range(0, len(s), 2):   # шаг 2 — берём каждый второй индекс
    print(s[i])

Можно было бы перебирать все индексы и проверять i % 2 == 0, но шаг у range() делает это без всякой развилки. Заодно видно, зачем нужен перебор по индексам: по символам номер узнать было бы неоткуда.

Номера символов здесь не нужны — только сами символы.

Символ '5' — это текст, а не число; сложить его с числом нельзя, пока не переведёте int().

1. Обнуляем накопитель.
2. Перебираем символы строки.
3. Каждый переводим в число и прибавляем.

s = input()

total = 0
for c in s:
    total += int(c)   # символ '5' — это текст, его надо перевести в число

print(total)

int() тут применяется к одному символу, а не ко всей строке. Разница видна на примере: int('2514') — это число 2514, а сумма цифр — 12.

Ответ известен, как только встретилась первая цифра, — дальше можно не искать.

Нужен флажок: до цикла «не нашли», внутри — поднять и выйти по break.

1. Ставим found = False.
2. Перебираем символы; если символ входит в строку из цифр — поднимаем флажок и прерываем цикл.
3. После цикла печатаем ответ по флажку.

s = input()

found = False
for c in s:
    if c in '0123456789':   # символ — одна из цифр
        found = True
        break               # ответ уже известен

if found:
    print('Цифра')
else:
    print('Цифр нет')

Проверка c in '0123456789' — это оператор принадлежности из третьего занятия: он ищет подстроку. Строка из десяти цифр здесь играет роль списка допустимых символов.

Сравнивать надо символ с соседним — значит, без индексов не обойтись.

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

1. Заводим счётчик.
2. Перебираем индексы от 1 до конца строки.
3. Сравниваем s[i] с s[i - 1] и считаем совпадения.

s = input()

count = 0
for i in range(1, len(s)):   # начинаем с единицы: у s[0] нет предыдущего
    if s[i] == s[i - 1]:
        count += 1

print(count)

Начать перебор с нуля и писать s[i + 1] тоже можно, но тогда цикл должен закончиться на len(s) - 1, иначе последний шаг выйдет за конец строки и программа упадёт с IndexError. Вариант «смотреть назад» такой ошибки не допускает вовсе.

Исходный код печатает cde: срез начинается с индекса 2 и заканчивается перед индексом 5.

Нужное bcdef начинается с b — это индекс 1, а заканчивается на f — это индекс 5, значит, правая граница на единицу больше.

1. b стоит под индексом 1 — это левая граница.
2. f стоит под индексом 5, но правая граница не включается, поэтому пишем 6.

s = 'abcdefg'
print(s[1:6])   # от b включительно до g не включительно

Правило «правая граница не включается» проще запомнить через длину: в срезе s[1:6] ровно 6 − 1 = 5 символов. Так и проверяют себя: разность границ — это длина куска.

Исходный код печатает abc — три символа.

Нужно четыре.

1. Левая граница опущена — срез идёт от начала.
2. Правая граница равна нужному количеству символов: четыре.

s = 'abcdefg'
print(s[:4])   # первые четыре символа

Когда срез начинается с начала строки, правая граница читается просто как «сколько символов взять». Это самый удобный случай — считать индексы не нужно вовсе.

Исходный код печатает gda: идёт с конца и берёт каждый третий символ.

Нужны все символы подряд, кроме самого первого. Значит, шаг должен стать −1, а срез — останавливаться перед a.

1. Шаг −1 разворачивает строку: получилось бы gfedcba.
2. Лишняя a — это символ с индексом 0, и её надо отбросить.
3. Правая граница 0 не включается, поэтому s[:0:-1] даёт ровно gfedcb.

s = 'abcdefg'
print(s[:0:-1])   # разворот, но без символа с индексом 0

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

Левую границу можно опустить — срез начнётся с начала строки.

Правая граница здесь и есть количество символов.

1. Пишем срез от начала до 12: s[:12].

s = 'In 2010, someone paid 10k Bitcoin for two pizzas.'
print(s[:12])

Обратите внимание на результат: In 2010, som — срез не смотрит на слова и режет строку ровно по счёту символов.

Отрицательный индекс отсчитывает с конца.

Правую границу можно опустить — срез дойдёт до конца строки.

1. Девятый символ с конца — это индекс −9.
2. Срез s[-9:] идёт от него до конца.

s = 'In 2010, someone paid 10k Bitcoin for two pizzas.'
print(s[-9:])

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

Обе границы опускаются: нужна вся строка.

А разворачивает её отрицательный шаг.

1. Пишем срез без границ, но с шагом −1: s[::-1].

s = 'In 2010, someone paid 10k Bitcoin for two pizzas.'
print(s[::-1])

s[::-1] — самый известный срез в Python. Им же проверяют палиндромы: слово читается одинаково в обе стороны, если s == s[::-1].

Место разреза — это длина первой части. При чётной длине она равна половине, при нечётной — на единицу больше.

len(s) // 2 + len(s) % 2 даёт нужное число сразу для обоих случаев.

1. Считаем место разреза: half = len(s) // 2 + len(s) % 2.
2. Первая часть — s[:half], вторая — s[half:].
3. Печатаем их в обратном порядке, склеив конкатенацией.

s = input()

# при нечётной длине остаток даёт лишний символ первой половине
half = len(s) // 2 + len(s) % 2

print(s[half:] + s[:half])

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

Первая буква имени — это s[0]. А как добраться до первой буквы фамилии, не зная длины имени?

Найдите пробел методом find() — фамилия начинается сразу за ним.

1. s.find(' ') возвращает индекс пробела.
2. Первая буква фамилии стоит следом: s[space + 1].
3. Буква заглавная, если она совпадает со своей же заглавной версией: c == c.upper().
4. Обе проверки обязательны — соединяем через and.

s = input()

space = s.find(' ')      # где заканчивается имя
first = s[0]             # первая буква имени
second = s[space + 1]    # первая буква фамилии

if first == first.upper() and second == second.upper():
    print('YES')
else:
    print('NO')

Метод title() тут не годится, хотя и кажется подходящим: он ещё и приводит остальные буквы к строчным, и запись «CHRIS ALAN» он объявил бы неверной. Проверять надо ровно то, о чём спрашивают, — первые буквы.

Оператор in различает регистр, поэтому «ХОРОШ» он не найдёт.

Приведите всю строку к одному регистру — и искать станет нечего.

1. Переводим строку в нижний регистр методом lower().
2. Ищем в результате подстроку «хорош» оператором in.

s = input()

# приводим к одному регистру, чтобы «ХОРОШ» и «Хорош» тоже нашлись
if 'хорош' in s.lower():
    print('YES')
else:
    print('NO')

Приём «привести к одному регистру перед сравнением» — стандартный. Важно только не перепутать: искомое слово тоже должно быть в нижнем регистре, иначе не найдётся уже ничего.

Цифры и знаки препинания считать не нужно — только буквы.

У цифры и запятой заглавной версии нет: ','.upper() — это по-прежнему запятая. А вот у строчной буквы она есть и отличается от неё самой.

1. Перебираем символы строки.
2. Символ — строчная буква, если он не равен своей же заглавной версии.
3. Считаем такие символы.

s = input()

count = 0
for c in s:
    if c != c.upper():   # у цифр и знаков upper() ничего не меняет
        count += 1

print(count)

Эта проверка одним движением отсеивает и заглавные буквы, и всё небуквенное. На следующем занятии появится метод islower(), и условие станет ещё короче — но приём с upper() стоит понять: он показывает, что «буква» и «не буква» различаются по поведению, а не по внешнему виду.

Считать сами слова не нужно — достаточно посчитать промежутки между ними.

Слов всегда на одно больше, чем пробелов.

1. s.count(' ') даёт число пробелов.
2. Прибавляем единицу — получаем число слов.

s = input()

# слов на одно больше, чем разделяющих их пробелов
print(s.count(' ') + 1)

Приём работает ровно при условии из задачи: пробел между словами один и лишних нет. На восьмом занятии появится метод split(), который разбирает строку на слова по-настоящему — и справляется с двойными пробелами.

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

Дальше каждая из четырёх букв считается методом count().

1. Читаем строку и сразу переводим её в верхний регистр.
2. Четыре раза применяем count() — по букве на каждое основание.
3. Печатаем с подписями.

s = input().upper()   # считаем строчные и заглавные вместе

print('Аденин:', s.count('А'))
print('Гуанин:', s.count('Г'))
print('Цитозин:', s.count('Ц'))
print('Тимин:', s.count('Т'))

.upper() применён прямо к результату input() — отдельная строка для этого не нужна. Заодно исчезает шанс забыть про регистр в одном из четырёх подсчётов.

Цифр всего десять, и каждую можно посчитать методом count().

Перебирать при этом надо не строку, а сами цифры — по ним и идёт цикл.

1. Заводим накопитель.
2. Перебираем символы строки '0123456789'.
3. Для каждой цифры прибавляем к накопителю, сколько раз она встретилась во введённой строке.

s = input()

count = 0
for d in '0123456789':   # цикл идёт по цифрам, а не по строке
    count += s.count(d)

print(count)

Здесь цикл перебирает не то, что кажется: шагов ровно десять, независимо от длины введённой строки. Обратный вариант — перебирать строку и проверять c in '0123456789' — тоже верен; выбирайте тот, который вам понятнее.

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

Годится любое из двух окончаний — значит, or.

1. s.endswith('.com') — заканчивается ли строка на .com.
2. То же для .ru.
3. Соединяем через or.

s = input()

if s.endswith('.com') or s.endswith('.ru'):
    print('YES')
else:
    print('NO')

Через срезы это же пишется как s[-4:] == '.com', и работает не хуже. Метод короче и, главное, не требует считать длину окончания — ошибиться в четвёрке проще, чем кажется.

Это поиск максимума, только сравниваются не сами символы, а их количества.

Количество каждого символа считает count(), а «лучший на данный момент» хранится в отдельной переменной.

1. Берём первый символ строки как первого претендента.
2. Перебираем все символы; если очередной встречается чаще, чем нынешний претендент, — заменяем.
3. После цикла печатаем претендента.

s = input()

best = s[0]                       # первый претендент
for c in s:
    if s.count(c) > s.count(best):
        best = c

print(best)

Это тот же поиск наибольшего, что и в четвёртом занятии, только «больше» означает «чаще». Начальное значение взято не с потолка, а из самой строки — приём надёжнее выдуманного -1, и работает на любых данных.