Строки в питоне — это специальный тип данных который с одной стороны позволяет хранить текстовую информацию.

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

text = "привет! =)"

print(f"Первая буква в слове: {text[0]}")  # можем вывести первый элемент
print(f"Вторая буква в слове: {text[1]}")  # можем вывести второй элемент

раз уж это список то можно применять циклы к строке:

text = "привет! =)"

for s in text:
    print(f"Буква {s}")

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

text = "привет! =)"

for i in range(len(text)):
    if (i + 1) % 2 == 0:
        print(f"Буква {text[i]} на {i + 1} позиции")

кстати, когда надо знать позицию элемента в списке вместо range удобнее использовать специальный метод enumerate

text = "привет! =)"

for i, s in enumerate(text):
    if (i + 1) % 2 == 0:
        print(f"Буква {s} на {i + 1} позиции")

работает примерно так

если запустить, выдаст то же самое

как и у любого списка мы можем проверять наличие символа в строке через in

text = "привет! =)"

if 'п' in text:
    print(f"Буква п есть слове '{text}'")

if 'ю' not in text:
    print(f"Буквы ю нет в слове '{text}'")

Допустим есть у нас задача. Есть список чисел:

1 2 3 4 5 6 7 8 9 10

мы запрашиваем у пользователя число. И надо вывести информацию о том сколько чисел и какие остатки от деления они имеют.

Например, пользователь вводит 3, и я вывожу:

казалось бы, как я могу это сделать? Например взять завести три переменные и заполнять их в цикле:

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

mod_0 = 0
mod_1 = 0
mod_2 = 0

for x in arr:
    if x % 3 == 0:
        mod_0 += 1
    if x % 3 == 1:
        mod_1 += 1
    if x % 3 == 2:
        mod_2 += 1

но проблема в том, что пользователь может ведь ввести в принципе какое угодно число. Например, 100 и тогда получается, что мне надо завести 100 переменных, так как остатков от деления на 100 – 100 штук (от 0 до 99)

И как в такой ситуации быть?

Специально для таких случаев существует специальная структура данных которая называется словарик. Оно представляет из себя специальный объект который хранит соответствия типа ключ -> значение.

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

На питоне мы можем записать такую информацию следующим образом:

temperature = {
    "Январь": -20,
    "Февраль": -10,
    "Март": 0,
    "Апрель": 5,
    "Май": 20,
    "Июнь": 25,
}

то есть объявили переменную и особым способом запихали в нее информацию. То, что находится слева от двоеточия – это называется ключ (в нашем случае в качестве ключа у нас название месяца), а то что находится справа от двоеточия называется значением.

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

print(temperature["Апрель"]) # выдаст 5

то есть этот словарик немного напоминает массив только когда мы хотим получить значение какого-то элемента мы передаем не его индекс, а его ключ (например, Апрель)

Помимо того, что мы можем получать значения. Мы можем изменять их, например, поменяем температуру в Апреле:

temperature = {
    "Январь": -20,
    "Февраль": -10,
    "Март": 0,
    "Апрель": 5,
    "Май": 20,
    "Июнь": 25,
}
print(temperature)

temperature["Апрель"] = 10  # обновил значение
print(temperature)

тестим

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

temperature = {
    "Январь": -20,
    "Февраль": -10,
    "Март": 0,
    "Апрель": 5,
    "Май": 20,
    "Июнь": 25,
}
print(temperature)

temperature["Июль"] = 30  # добавил новый ключ
print(temperature)

мы можем проверить наличие какого-то ключа в словарике через оператор in

temperature = {
    "Январь": -20,
    "Февраль": -10,
    "Март": 0,
    "Апрель": 5,
    "Май": 20,
    "Июнь": 25,
}

if "Июнь" in temperature:
    print(f"Температура в июне: {temperature['Июнь']}")
    
if "Сентябрь" not in temperature:
    print(f"У нас нет данных по сентябрю")

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

temperature = {
    "Январь": -20,
    "Февраль": -10,
    "Март": 0,
    "Апрель": 5,
    "Май": 20,
    "Июнь": 25,
}
print(temperature['Сентябрь'])

в этом случае вам надо сначала загнать какое-нибудь значение по умолчанию

temperature = {
    "Январь": -20,
    "Февраль": -10,
    "Март": 0,
    "Апрель": 5,
    "Май": 20,
    "Июнь": 25,
}

if 'Сентябрь' not in temperature:
    temperature['Сентябрь'] = 0

print(temperature['Сентябрь'])

но так как писать сразу if и присвоение значения по умолчанию лениво, то есть специальная функция которая делает эти два действия в одну строчку

temperature = {
    "Январь": -20,
    "Февраль": -10,
    "Март": 0,
    "Апрель": 5,
    "Май": 20,
    "Июнь": 25,
}

# вместо этого
# if 'Сентябрь' not in temperature:
#     temperature['Сентябрь'] = 0

# пишем так
temperature.setdefault("Сентябрь", 0)
print(temperature['Сентябрь'])  # выдаст 0

# можем поменять значение
temperature['Сентябрь'] = 10
temperature.setdefault("Сентябрь", 0)  # и теперь эта строчка никак не повлияет на значение на ключа
print(temperature['Сентябрь']) # то есть тут все равно будет выдано 10

теперь вернемся к нашей исходной задаче:

Надо вывести информацию о том сколько чисел и какие остатки от деления они имеют. Например, пользователь вводит 3, и я вывожу:

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

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

result = {}  # завожу пустой словарик

for x in arr:
    # устанавливаю значения ключа по умолчанию на 0,
    # эта функция сработает только раз для каждого остатка от деления
    result.setdefault(x % 3, 0)

    result[x % 3] += 1  # увеличиваю значение ключа

# выводим результат
for key in result:
    print(f"{result[key]} числа имеют остаток от деления числа на 3 равным {key}")

запускаем:

теперь можно еще число у юзера запрашивать

r = input("Введите значение: ")
r = int(r)

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

result = {}  # завожу пустой словарик

for x in arr:
    result.setdefault(x % r, 0)
    result[x % r] += 1

for key in result:
    print(f"{result[key]} числа имеют остаток от деления числа на {r} равным {key}")

Если у вас есть какой-то текст и вам надо разбить его на слова. То есть несколько способов это сделать.

Первый вариант

Мы его уже использовали, через функцию split. Он не универсальный, но вполне рабочий для простого текста. Где, например, все слова просто отделены друг от друга пробелами. Например

text = "В лесу родилась елочка"
words = text.split(" ")

print(words[1])  # выведет лесу

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

text = "Там царь Кащей над златом чахнет; там русский дух… там Русью пахнет!"
words = text.split(" ")

print(words)

то есть при таком разбиении у нас слова вместе со знаками препинания получаются.

поэтому

Второй вариант

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

import re

text = "Там царь Кащей над златом чахнет; там русский дух… там Русью пахнет!"
words = re.split("\W+", text)

print(words)

получим такое:

уже лучше, но есть пустые строки, надо их убрать

import re

text = "Там царь Кащей над златом чахнет; там русский дух… там Русью пахнет!"
words = re.split("\W+", text)
words = [i for i in words if i]  # убираем пустые строки

print(words)

пробуем

Рекомендация к заданию

Если будете искать самое длинное слово, то скорее всего вы решите фиксировать информацию об этом в словарик. Ну типа ключ – это слово, а значение — это сколько раз слово встречается в тексте.

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

То есть, сначала считаем, что ключ с наибольшем значением – это первый ключ. А получить значением первого ключа можно так

first_key = list(some_dict)[0]

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

for key in some_dict:
    if some_dict[key] > some_dict[first_key]:
        print(f"значение ключа {key} больше чем значение ключа {first_key}"

Если у вас есть многострочный текст то вы можете прератить в массив строк есть специальный метод splitlines

text = """У лукоморья дуб зелёный;
Златая цепь на дубе том:
И днём и ночью кот учёный
Всё ходит по цепи кругом;
"""

rows = text.splitlines()

# получим массив строк, с каждой из которых можно работать по отдельности
print(rows[2])

либо как с обычными массивом

text = """У лукоморья дуб зелёный;
Златая цепь на дубе том:
И днём и ночью кот учёный
Всё ходит по цепи кругом;
"""

rows = text.splitlines()

for i, row in enumerate(rows):
    print(f"{i}-ая строка: {row} | в ней {len(row)} символов")