Основы программирования на Python

# Стоимость покупки: цена умножается на количество
price = 149.50
count = int(input())
total = price * count
print("Итого:", total, "руб.")

🔍 Разбор по строкам
• Комментарий. Всё, что идёт после # до конца строки, интерпретатор пропускает. Комментарии пишутся для человека.
• Создаём переменную price и кладём в неё дробное число. Разделитель дробной части — точка, а не запятая.
• Функция input() читает строку с клавиатуры, а int() превращает её в целое число. Без int() в переменной оказался бы текст.
• Вычисляем произведение. Справа от = сначала считается выражение, и только потом результат попадает в total.
• Выводим результат. Аргументы print перечисляются через запятую и в выводе разделяются пробелом автоматически.

a = 7
b = 2.5
name = "Илья"
is_ready = True
print(type(a))
print(a + int(b))
print(name * 2)
print(int(is_ready) + 5)

🔍 Разбор по строкам
• Целое число. Тип int Python определяет сам — объявлять его не нужно.
• Есть точка и дробная часть — значит, тип float.
• Текст в кавычках — тип str. Кавычки можно брать любые, главное открыть и закрыть одинаковыми.
• Логическое значение. True и False пишутся с заглавной буквы и без кавычек.
• Функция type() показывает тип значения. Полезна, когда программа ведёт себя странно.
• int(2.5) даёт 2: дробная часть отбрасывается, а не округляется. Поэтому 7 + 2 = 9.
• Умножение строки на число повторяет её. Это законная операция, в отличие от сложения строки с числом.
• True при преобразовании к числу равен 1, а False — 0. Отсюда 1 + 5 = 6.

a = 17
b = 5
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a // b)
print(a % b)
print(a ** b)

🔍 Разбор по строкам
• Первое число — делимое.
• Второе число — делитель.
• Сложение — привычная операция.
• Вычитание.
• Умножение обозначается звёздочкой.
• Обычное деление. Запомни: результат всегда float, даже если делится нацело.
• Целочисленное деление // — сколько раз делитель полностью помещается в делимое. Главный инструмент при работе с цифрами числа.
• Остаток от деления %. Ключевая операция: проверка чётности, кратности, получение последней цифры.
• Возведение в степень **. Именно две звёздочки, а не знак ^.

n = int(input())
x, y = int(input()), int(input())
a, b = map(int, input().split())
nums = list(map(int, input().split()))
print(n, x, y, a, b, nums)

🔍 Разбор по строкам
• Одно число на отдельной строке — базовый случай.
• Два числа на разных строках. Слева от = перечисляем две переменные, справа — два значения.
• Два числа в одной строке через пробел. split() режет строку по пробелам, map(int, ...) применяет int к каждому куску.
• Неизвестно сколько чисел в строке — оборачиваем в list() и получаем список. Этот приём понадобится в заданиях с массивами.
• Выводим всё сразу, чтобы убедиться, что данные прочитаны верно.

a, b, c = map(int, input().split())
if a >= b and a >= c:
    m = a
elif b >= a and b >= c:
    m = b
else:
    m = c
print("Максимум:", m)

🔍 Разбор по строкам
• Читаем три числа из одной строки и раскладываем по трём переменным.
• Первое условие: a не меньше обоих остальных. Строка обязательно заканчивается двоеточием.
• Тело ветки сдвинуто вправо на 4 пробела. Именно отступ, а не скобки, показывает Python, что строка относится к if.
• elif — «иначе если». Проверяется только тогда, когда предыдущее условие оказалось ложным.
• Тело второй ветки.
• else срабатывает, когда все условия выше ложны. Условия после него не пишут — оно ловит все оставшиеся случаи.
• Тело последней ветки: остаётся единственный вариант.
• Вывод не имеет отступа, значит, выполняется всегда, независимо от выбранной ветки.

command = input()
match command:
    case "старт":
        print("Запускаю программу")
    case "стоп":
        print("Останавливаю программу")
    case "пауза" | "ждать":
        print("Ставлю на паузу")
    case _:
        print("Неизвестная команда")

🔍 Разбор по строкам
• Читаем команду. Здесь int() не нужен: работаем с текстом.
• Открываем конструкцию. Значение command вычисляется один раз и дальше только сравнивается.
• Первый образец. Если строка совпала — выполняется тело этой ветки, остальные пропускаются.
• Тело первой ветки со сдвигом на восемь пробелов: это уже второй уровень вложенности.
• Второй образец.
• Тело второй ветки.
• Вертикальная черта означает «или». Ветка сработает и на «пауза», и на «ждать».
• Тело третьей ветки.
• Подчёркивание — образец «что угодно». Это аналог else и ставится последним.
• Тело ветки по умолчанию.

age = int(input())
is_student = input() == "да"
if age < 7:
    price = 0
else:
    if is_student:
        price = 150
    else:
        price = 300
print("Билет стоит", price)

🔍 Разбор по строкам
• Читаем возраст.
• Сравнение == само по себе даёт True или False, поэтому в is_student сразу попадает логическое значение. Отдельный if здесь не нужен.
• Внешнее условие: дошкольникам билет бесплатный.
• Тело внешнего if.
• Ветка «иначе» для всех, кому 7 лет и больше.
• Вложенный if внутри else. Он проверяется только для тех, кто прошёл внешнюю проверку.
• Второй уровень вложенности — отступ 8 пробелов.
• Вложенный else на том же уровне, что и вложенный if.
• Цена для взрослого.
• Вывод без отступа выполняется в любом случае.

x = int(input())
print(0 < x < 100)
print(not (x % 2 == 0))
print(x % 3 == 0 or x % 5 == 0)
print(x % 3 == 0 and x % 5 == 0)

🔍 Разбор по строкам
• Читаем число.
• Python разрешает двойное неравенство — так же, как в математике. Это короче, чем x > 0 and x < 100.
• Проверка на нечётность: остаток от деления на 2 не равен нулю. not переворачивает результат.
• Число кратно 3 или 5 — достаточно одного совпадения.
• Число кратно 3 и 5 одновременно, то есть кратно 15. Нужны оба совпадения.

total = 0
for i in range(1, 11):
    total = total + i
print("Сумма чисел от 1 до 10:", total)

🔍 Разбор по строкам
• Создаём накопитель и обнуляем его до цикла. Если объявить его внутри, он будет сбрасываться на каждой итерации.
• Переменная i по очереди принимает значения от 1 до 10. Она создаётся автоматически.
• Тело цикла: прибавляем текущее значение к накопителю. Краткая форма записи — total += i.
• Вывод стоит после цикла, без отступа. Если сдвинуть его вправо, результат напечатается десять раз.

for i in range(5):
    print(i, end=" ")
print()
for i in range(2, 9, 3):
    print(i, end=" ")
print()
for i in range(10, 0, -2):
    print(i, end=" ")

🔍 Разбор по строкам
• Один аргумент — перебор от нуля. Пятёрка не выводится, потому что правая граница не включается.
• Параметр end=" " заменяет перевод строки на пробел, поэтому числа печатаются в одну строку.
• Пустой print() просто переводит курсор на новую строку.
• Два аргумента задают начало и конец, третий — шаг. Получаем 2, 5 и 8.
• Тело второго цикла.
• Снова перевод строки.
• Отрицательный шаг даёт обратный отсчёт. Начало больше конца — это обязательное условие для убывания.
• Тело третьего цикла.

n = int(input())
s = 0
k = 0
while n > 0:
    s = s + n % 10
    k = k + 1
    n = n // 10
print("Сумма цифр:", s)
print("Количество цифр:", k)

🔍 Разбор по строкам
• Читаем число. Количество его цифр заранее неизвестно, поэтому for не подходит — нужен while.
• Накопитель для суммы цифр.
• Счётчик количества цифр.
• Условие продолжения: пока в числе осталась хотя бы одна цифра. Как только n станет нулём, цикл прекратится.
• Берём последнюю цифру через остаток и добавляем её к сумме.
• Увеличиваем счётчик на единицу.
• Самая важная строка. Отрезаем последнюю цифру. Если её забыть, условие никогда не станет ложным и программа зациклится навсегда.
• Выводим сумму цифр.
• Выводим их количество. Обрати внимание: исходное значение n потеряно — цикл его «съел». Если оно нужно дальше, сохрани копию до цикла.

for i in range(2, 100):
    if i % 7 != 0:
        continue
    print("Первое число, кратное 7:", i)
    break

🔍 Разбор по строкам
• Перебираем числа от 2 до 99.
• Проверяем, что число не кратно семи.
• continue досрочно завершает текущую итерацию и переходит к следующему числу. Всё, что ниже, пропускается.
• Сюда программа доберётся только для чисел, кратных семи.
• break полностью прерывает цикл. Без него вывелись бы все числа, кратные семи, а нам нужно только первое.

for i in range(1, 4):
    for j in range(1, 4):
        print(i, "x", j, "=", i * j)
    print("---")

🔍 Разбор по строкам
• Внешний цикл. Он сделает три итерации.
• Внутренний цикл. Он полностью проходит все свои три итерации на каждом шаге внешнего. Итого 3 × 3 = 9 строк вывода.
• Тело внутреннего цикла, отступ 8 пробелов.
• Разделитель с отступом 4 пробела: он относится к внешнему циклу и печатается трижды, после каждой группы.

a = [5, 3, 9, 1, 7]
print(len(a))
print(a[0], a[4], a[-1])
for x in a:
    print(x, end=" ")
print()
for i in range(len(a)):
    print(i, a[i])

🔍 Разбор по строкам
• Создаём список из пяти чисел. Квадратные скобки — признак списка.
• len() возвращает количество элементов. Индексы при этом идут от 0 до len(a) - 1.
• Первый элемент имеет индекс 0, последний — индекс 4. Отрицательный индекс -1 тоже указывает на последний элемент, и это удобнее, когда длина заранее неизвестна.
• Перебор по значениям: переменная x поочерёдно получает сам элемент. Так пишут, когда индекс не нужен.
• Печатаем элементы в строку.
• Перевод строки.
• Перебор по индексам. Эта форма нужна, когда требуется знать номер элемента или сравнивать соседние элементы.
• Выводим пару «индекс — значение».

a = [10, 20, 30, 40, 50, 60]
print(a[1:4])
print(a[:3])
print(a[3:])
print(a[::2])
print(a[::-1])

🔍 Разбор по строкам
• Исходный список из шести элементов.
• Срез от индекса 1 до индекса 4, причём правая граница не включается — точно так же, как в range.
• Левая граница опущена — значит, срез начинается с начала списка.
• Правая граница опущена — срез идёт до конца списка.
• Третье число — шаг. Берём каждый второй элемент.
• Шаг -1 разворачивает список задом наперёд. Самый короткий способ сделать реверс.

a = [5, 3, 9, 1, 7]
a.append(4)
print(sum(a), max(a), min(a))
print(a.count(3), a.index(9))
b = sorted(a)
print(b)
a.sort(reverse=True)
print(a)

🔍 Разбор по строкам
• Исходный список.
• Метод append добавляет элемент в конец. Метод вызывается через точку и меняет сам список.
• Три встроенные функции: сумма, максимум и минимум. Их не нужно писать вручную циклом.
• count считает, сколько раз значение встречается, index возвращает индекс первого вхождения.
• Функция sorted создаёт новый отсортированный список, оставляя исходный нетронутым.
• Выводим копию: она упорядочена по возрастанию.
• Метод sort, наоборот, сортирует список на месте. Параметр reverse=True задаёт убывание.
• Теперь изменился сам список a. Различие между sorted и sort нужно чувствовать твёрдо.

squares = [i * i for i in range(1, 8)]
print(squares)
evens = [x for x in squares if x % 2 == 0]
print(evens)
nums = list(map(int, input().split()))
print(sum(nums))

🔍 Разбор по строкам
• Генератор списка. Читается справа налево: «для каждого i от 1 до 7 вычисли i * i и собери результаты в список». Это компактная замена циклу с append.
• Проверяем результат.
• В генератор добавлено условие: в новый список попадут только элементы, прошедшие фильтр.
• Выводим отфильтрованный список.
• Читаем произвольное количество чисел из одной строки — заготовка для задач с массивами.
• Сумма всех прочитанных чисел.

with open("17.txt") as f:
    a = [int(line) for line in f]
print(len(a), max(a))
point = (3, 8)
x, y = point
print(x + y)

🔍 Разбор по строкам
• Открываем файл. Конструкция with сама закроет его после работы — именно так читают данные в заданиях ЕГЭ.
• Генератор списка по строкам файла: каждая строка превращается в целое число. Функция int сама отбрасывает символ перевода строки.
• Проверяем, что данные прочитаны: количество элементов и максимум.
• Создаём кортеж из двух чисел. Круглые скобки вместо квадратных.
• Распаковка: элементы кортежа раскладываются по переменным. Точно так же работает a, b = b, a из первого занятия.
• Пользуемся полученными значениями. Попытка написать point[0] = 5 вызвала бы ошибку: кортеж изменять нельзя.

def rectangle_area(width, height):
    return width * height
print(rectangle_area(3, 4))
print(rectangle_area(10, 2))

🔍 Разбор по строкам
• Ключевое слово def, имя функции и параметры в скобках. Строка заканчивается двоеточием.
• Тело функции с отступом. return отдаёт результат туда, откуда функцию вызвали.
• Вызов функции: значения 3 и 4 подставляются вместо width и height по порядку.
• Повторный вызов с другими аргументами. В этом весь смысл функции: код написан один раз, а используется многократно.

def grade(score, pass_mark=40):
    if score >= 80:
        return "отлично"
    if score >= pass_mark:
        return "зачёт"
    return "не сдано"
print(grade(92))
print(grade(55))
print(grade(30, 25))

🔍 Разбор по строкам
• У второго параметра есть значение по умолчанию. Если при вызове его не передать, будет использовано 40.
• Первая проверка.
• return не только возвращает значение, но и сразу выходит из функции. Остальные строки уже не выполнятся.
• Вторая проверка. Сюда попадаем, только если первая оказалась ложной, поэтому elif не нужен.
• Возврат второго варианта.
• Строка без условия: если ни одна проверка не сработала, возвращается этот результат.
• Вызов с одним аргументом — порог берётся по умолчанию.
• Ещё один вызов: 55 меньше 80, но не меньше 40.
• Здесь порог передан явно и равен 25, поэтому 30 баллов дают зачёт.

count = 0
def add(x):
    count = x
    return count
print(add(5))
print(count)

🔍 Разбор по строкам
• Глобальная переменная, созданная вне функций.
• Объявляем функцию с одним параметром.
• Присваивание внутри функции создаёт новую, локальную переменную с тем же именем. Глобальная при этом не меняется.
• Возвращаем локальное значение.
• Функция отработала и вернула 5.
• А глобальная переменная так и осталась нулём. Это не ошибка языка, а защита: функция не должна незаметно портить внешние данные. Передавай значения через параметры и забирай через return.

def digits_sum(n):
    s = 0
    while n > 0:
        s = s + n % 10
        n = n // 10
    return s
for number in [123, 4567, 9]:
    print(number, "->", digits_sum(number))

🔍 Разбор по строкам
• Заворачиваем в функцию алгоритм из третьего занятия.
• Накопитель — локальная переменная, она создаётся заново при каждом вызове. Это и хорошо: результаты вызовов не влияют друг на друга.
• Цикл внутри функции: отступ 4 пробела.
• Тело цикла — уже 8 пробелов. Уровни вложенности складываются.
• Отрезаем цифру. Изменение параметра n внутри функции не затрагивает переменную снаружи.
• return стоит на уровне тела функции, а не цикла. Если сдвинуть его вправо, функция вернёт результат после первой же итерации.
• Перебираем список чисел.
• Вызываем функцию прямо внутри print. Готовый инструмент можно применять сколько угодно раз.

def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)
print(factorial(5))

🔍 Разбор по строкам
• Объявляем функцию вычисления факториала.
• Базовый случай. Он обязан быть первым: именно он останавливает цепочку вызовов.
• Факториал единицы равен единице — дальше спускаться некуда.
• Рекурсивный шаг. Функция вызывает саму себя с меньшим аргументом. Цепочка раскручивается так: 5 × 4 × 3 × 2 × 1.
• Запускаем вычисление. Всего произойдёт пять вложенных вызовов, и результаты «схлопнутся» обратно снизу вверх.

from itertools import product
def has_double(word):
    for i in range(len(word) - 1):
        if word[i] == word[i + 1]:
            return True
    return False
count = 0
for w in product("АБВ", repeat=3):
    if not has_double(w):
        count = count + 1
print(count)

🔍 Разбор по строкам
• Подключаем готовый инструмент перебора из стандартной библиотеки. Именно так решаются задания на комбинаторику.
• Вспомогательная функция: проверяет, есть ли в слове две одинаковые буквы подряд.
• Идём до предпоследнего символа, потому что внутри обращаемся к следующему.
• Сравниваем соседние символы.
• Нашли повтор — сразу выходим, дальше проверять незачем.
• Строка выполнится, только если цикл прошёл полностью и повторов не нашлось.
• Счётчик подходящих слов.
• product перебирает все слова длины 3 из букв А, Б и В — всего 27 вариантов.
• Отбираем те, в которых нет повторов. not переворачивает результат функции.
• Увеличиваем счётчик.
• Выводим ответ. Перебор сделал всю работу за нас — считать вручную не пришлось.