Булевы функции и возврат нескольких значений

Проверка та же, что и на четвёртом занятии: перебрать возможные делители от 2 до num − 1.

Внутри функции сигнальная метка не нужна: как только делитель нашёлся, можно сразу вернуть False — return завершает функцию.

1. Числа меньше двух простыми не бывают — отвечаем False сразу.
2. Перебираем делители от 2 до num − 1.
3. Нашёлся делитель — возвращаем False.
4. Цикл закончился, а делителей нет — значит, число простое: возвращаем True.

def is_prime(num):
    if num < 2:              # единица и всё, что меньше, — не простые
        return False

    for d in range(2, num):
        if num % d == 0:     # нашёлся делитель — дальше не смотрим
            return False

    return True              # делителей не нашлось

# основная программа
print(is_prime(int(input())))

return внутри цикла заменил и сигнальную метку, и break — он делает то же самое, только сразу. Это типичное упрощение, которое появляется, как только код переезжает в функцию.

Сколько чисел придётся перебрать, заранее неизвестно — значит, while.

Начинать надо со следующего числа: у семёрки ответ 11, а не она сама.

1. Берём число на единицу больше данного.
2. Пока оно не простое — увеличиваем на единицу.
3. Как только is_prime() ответил True, возвращаем его.

def is_prime(num):
    if num < 2:
        return False
    for d in range(2, num):
        if num % d == 0:
            return False
    return True

def get_next_prime(num):
    candidate = num + 1              # само число не считается
    while not is_prime(candidate):   # пока не простое — идём дальше
        candidate += 1
    return candidate

# основная программа
print(get_next_prime(int(input())))

while not is_prime(candidate) читается прямо: «пока кандидат не простой». Без булевой функции в заголовке цикла пришлось бы городить перебор делителей — прямо там, где важна только суть.

Длину можно проверить сразу и, если она мала, вернуть False, не проверяя остальное.

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

1. Если длина меньше восьми — сразу False.
2. Заводим три флажка со значением False.
3. Проходим по символам и поднимаем нужный флажок, встретив заглавную, строчную или цифру.
4. Возвращаем True, только если подняты все три.

def is_password_good(password):
    if len(password) < 8:
        return False

    has_upper = False
    has_lower = False
    has_digit = False

    for c in password:
        if c.isupper():
            has_upper = True
        if c.islower():
            has_lower = True
        if c.isdigit():
            has_digit = True

    return has_upper and has_lower and has_digit

# основная программа
print(is_password_good(input()))

Последняя строка возвращает результат логического выражения — не True или False по отдельности, а сразу их связку. Писать if has_upper and … : return True else: return False можно, но это тот же ответ на две строки длиннее.

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

Дальше считают, сколько позиций различаются, и сравнивают счётчик с единицей.

1. Если длины разные — сразу False.
2. Заводим счётчик различий и идём по индексам.
3. Каждое несовпадение увеличивает счётчик.
4. Возвращаем результат сравнения diff == 1.

def is_one_away(word1, word2):
    if len(word1) != len(word2):    # разной длины — сравнивать нечего
        return False

    diff = 0
    for i in range(len(word1)):
        if word1[i] != word2[i]:
            diff += 1

    return diff == 1                # ровно одно различие

# основная программа
print(is_one_away(input(), input()))

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

Функция должна вернуть два значения — перечислите их после return через запятую.

Чтобы напечатать оба через пробел, пригодится распаковка print(*…).

1. Считаем полусумму по каждой координате.
2. Возвращаем оба значения одной инструкцией return.
3. В основной программе печатаем результат распаковкой.

def get_middle_point(x1, y1, x2, y2):
    return (x1 + x2) / 2, (y1 + y2) / 2   # два значения через запятую

# основная программа
x1 = int(input())
y1 = int(input())
x2 = int(input())
y2 = int(input())

print(*get_middle_point(x1, y1, x2, y2))

Деление здесь обычное, а не целочисленное: середина отрезка из целых точек запросто бывает дробной. Поэтому и в ответе 5.0, а не 5.

Порядок важен: сначала длина окружности, потом площадь.

π берут из math — своё приближение писать не нужно.

1. Подключаем модуль math.
2. Возвращаем два выражения через запятую: 2 * math.pi * radius и math.pi * radius ** 2.
3. Читаем радиус как вещественное число и печатаем результат распаковкой.

import math

def get_circle(radius):
    return 2 * math.pi * radius, math.pi * radius ** 2

# основная программа
r = float(input())
print(*get_circle(r))

Читаем радиус через float(), а не int(): во втором примере он равен 1.5. Мелочь, которая ломает программу мгновенно и всегда — стоит сразу смотреть на примеры, прежде чем выбирать преобразование.