def student_data():
    students = {}
    while True:
        name = input("Введите имя студента, или 'стоп' для завершения ввода: ")
        if name.lower() == 'стоп':
            break 
        try:
            grades = list(map(float, input(f"Введите оценки для {name} через пробел: ").split()))
            students[name] = grades  
        except ValueError:
            print("ERROR") 
    return students
        
def calculate_average(grades):
    return sum(grades) / len(grades) if grades else 0

def get_top_students(students, threshold):
    return {name: average_rating for name, average_rating in students.items() if average_rating > threshold}


def print_top_student(students):

    if not students:
        print("Нет данных о студентах.")
        return
    top_student = max(students, key=students.get)
    print(f"Студент с наивысшим средним баллом: {top_student} ({students[top_student]:.2f})")


def main():

    while True:
        students = student_data()
        
        if not students:
            print("Нет данных для анализа.")
            continue
        

        student_averages = {name: calculate_average(grades) for name, grades in students.items()}
        

        print("\nСредний балл студентов:")
        for name, average_rating in student_averages.items():
            print(f"{name}: {average_rating:.2f}")
        

        threshold = float(input("\nВведите порог для вывода студентов с баллом выше: "))
        top_students = get_top_students(student_averages, threshold)
        
        if top_students:
            print("\nСтуденты с баллом выше порога:")
            for name, average_rating in top_students.items():
                print(f"{name}: {average_rating:.2f}")
        else:
            print("Нет студентов с баллом выше порога.")
        

        print_top_student(student_averages)
        

        repeat = input("\nХотите ввести данные заново? (да/нет): ").lower()
        if repeat != 'да':
            print("Программа завершена.")
            break


main()

def func_1(n):
    def multiply(x):
        return x * x
    return multiply(n) + multiply(n - 1)

result = func_1(4)
print(result) 

return multiply(n) + multiply(n - 1)

def predict_price(m, r, b):

    return m * r + b

price_per_room = 50000  
number_of_rooms = 3  
base_price = 200000  

predicted_price = predict_price(price_per_room, number_of_rooms, base_price)
print(f"Прогнозируемая цена дома: ${predicted_price}")

def func(x):
    return x + 5

def main():
    return func(5) + func(10)

print(main())

def compress_string(s):    
    if not s:
        return " " 

    listt = []
    count = 1

    for i in range(1, len(s)): # Мы начинаем с индекса 1 (у нас это второй символ) и проходим по всей строке до конца
        if s[i] == s[i - 1]: # Если текущий равен предыдущему: 
            count += 1 # Увеличиваем счетчик на 1

        else:
             listt.append(s[i - 1] + str(count)) #Если текущий символ не равен предыдущему, последовательность закончилась. Это значит, что вся строка добавляет в список listt[] строку, состоящую из символа и его количества (как раз то, что нам нужно)            

             count = 1 # Обновляем счетчик, чтобы начать подсчет для новой буквы 

    listt.append(s[-1] + str(count)) # Мы соединяем все элементы в списке listt в одну строку с помощью ''.join(listt) и возвращаем результат 
    return ''.join(listt) # Об этом поговорим еще сегодня

print(compress_string("aaabbvvvvccd"))

def compress_string(s):    
    if not s:
        return " " 
    listt = []
    count = 1
    for i in range(1, len(s)): 
        if s[i] == s[i - 1]:
            count += 1 
        else:
             listt.append(s[i - 1] + str(count)) 

             count = 1

    listt.append(s[-1] + str(count)) 
    return ''.join(listt) 
print(compress_string("aaabbvvvvccd"))

def func(a, *args, **kwargs):
    print(a, args, kwargs)

func(1, 2, 3, x=4, y=5)

def func(x, y=[]):
    y.append(x)
    return y

list1 = func(1)
list2 = func(2, [])
list3 = func(3)

print(list1, list2, list3)

words = ["Hello", "Code", "Lab", "is", "awesome"]
result = " ".join(words)
print(result)  # Вывод: "Hello Code Lab is awesome"

fruits = ["Hello", "Code", "Lab", "is", "awesome"]
result = ", ".join(fruits)
print(result)  # Вывод: "Hello, Code, Lab, is, awesome"

numbers = [1, 2, 3]
result = "-".join(map(str, numbers))
print(result)  # Вывод: "1-2-3"

def func(a, *args, **kwargs):
    print(a, args, kwargs)

func(1, 2, 3, x=4, y=5)

def func(a, *args, **kwargs):

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

a = [1,2,3]
b = [*a,4,5,6] # мы берем содержимое списка a и распаковываем его в новый список b
print(b) # [1,2,3,4,5,6]

def func(x, y, z):
    return x + y + z

numbers = [1, 2, 3]
result = func(*numbers)  # Распаковываем список в отдельные аргументы
print(result)  # Вывод: 6

data = {'name': 'Brovscki', 'age': 21}
def greeting(name, age):
    print(f"Hello, {name}! You are {age} years old.")

greeting(**data)  # Вывод: Hello, Brovscki! You are 21 years old

def my_function(a, *args):
    print("a:", a)
    print("args:", args)

my_function(1, 2, 3, 4)  # args будет содержать (2, 3, 4)

# Вывод:

a: 1
args: (2, 3, 4)

def my_function(**kwargs):
    print(kwargs)

my_function(name="Brovscki", age=25)  # Вывод: {'name': 'Brovscki', 'age': 25}
my_function(city="Zalupinsk", country="USA")  # Вывод: {'city': 'Zalupinsk', 'country': 'UK'}

Имена, такие как args и kwargs, нужны для того, чтобы у нас была переменная, через которую можно обращаться к собранным аргументам внутри функции.

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

def factorial(n):
    # Базовый случай
    if n == 0 or n == 1:
        return 1
    # Рекурсивный случай
    else:
        return n * factorial(n - 1)

print(factorial(5))  # Вывод: 120

return n * factorial(n - 1)

Строка return n * factorial(n - 1) запускает рекурсивный вызов и ждёт его результат. Как только factorial(n - 1) возвращает значение, это значение умножается на n, и результат поднимается обратно, возвращаясь вызову на уровень выше.