3.7. Проект «Обработка запроса с интерфейса»

with open("user.csv", "r", encoding="utf-8") as f:

from datetime import datetime

# Создаём datetime: 23 мая 2025, 14:30:45
test_time = datetime(year=2025, month=5, day=23, hour=14, minute=30, second=45)

# Выводим в разных форматах
print("1. Дата с двумя цифрами в годе:")
print(test_time.strftime("%d.%m.%y"))  # 23.05.25

print("\n2. Дата с четырьмя цифрами в годе:")
print(test_time.strftime("%d.%m.%Y"))  # 23.05.2025

print("\n3. Год.Месяц.День:")
print(test_time.strftime("%Y.%m.%d"))  # 2025.05.23

print("\n4. Полная дата и время:")
print(test_time.strftime("%d.%m.%Y %H:%M:%S"))  # 23.05.2025 14:30:45

print("\n5. ISO-формат (по стандарту):")
print(test_time.isoformat())  # 2025-05-23T14:30:45

id, test_id, task_id, order_number
81,      8,        1,        1
82,      8,        2,        2

import csv

# Чтение данных из нужного CSV-файла
with open("test_task_link.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    test_task_links = list(reader)

# ID теста, для которого ищем задачи
test_id = '8'
test_tasks = []

# Отбираем задачи с нужным test_id и сортируем по убыванию order_number
for link in test_task_links:
    if link[1] == test_id:
        inserted = False
        for i in range(len(test_tasks)):
            if int(link[3]) > int(test_tasks[i][3]):  # сравниваем order_number
                test_tasks.insert(i, link)
                inserted = True
                break
        else:
            test_tasks.append(link)

# Вывод результата
for task in test_tasks:
    print(task)

my_list = [1, 2, 4]
my_list.insert(2, 3)  # вставить 3 на позицию с индексом 2
print(my_list)        # [1, 2, 3, 4]

if int(link[1]) < int(current[1]) or (link[1] == current[1] and int(link[3]) < int(current[3])):

result = {
    "user": user_info,
    "progress": progress_info,
    "tests": tests_data
}

print(json.dumps(result, ensure_ascii=False, indent=2))

user_info = {
    "user_id":  ,
    "full_name": ,
    "class_id": ,
}

progress_info = {
    "tests_completed": ,
    "tests_total": ,
    "accuracy_average_percent": ,
}

{
    "test_id": ,
    "title": ,
    "tasks": ,
    "progress_percent": ,       
    "correct_percent": ,        
    "time": ,            
    "date_assigned": ,          
}

{
    "order_number": ,
    "task_id": ,
    "is_correct": ,
}

with open("user.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    users = list(reader)

users_dict = {user[0]: user for user in users}

{
  "101": ["101", "ученик", "София", "Сергеевна", "Боброва", "sofiya.bobrova@mail.ru", "79161798644", "Чтение, Коллекционирование монет, Путешествия"],
  "102": ["102", "ученик", "Андрей", "Петрович", "Смирнов", "andrey.smirnov@mail.ru", "79161234567", "Футбол, Игры, Чтение"],
  "103": ["103", "ученик", "Мария", "Ивановна", "Кузнецова", "maria.kuz@mail.ru", "79161239876", "Рисование, Фортепиано"],
  ...
}

users_dict[‘1’][2]

# Список файлов в заданном порядке
files = [
    "user.csv", 
    "class.csv", 
    "class_user_link.csv", 
    "task.csv", 
    "test.csv", 
    "test_task_link.csv", 
    "test_class_user_link.csv", 
    "test_attempt.csv", 
    "task_attempt.csv"
]

# Подсчёт строк в каждом файле
line_counts = []
for file_name in files:
    with open(file_name, "r", encoding="utf-8") as file:
        # Считаем все строки и вычитаем заголовок
        line_count = len(file.readlines()) - 1
        # Защита от отрицательных значений (если файл пустой)
        line_counts.append(str(max(0, line_count)))

# Вывод результатов через пробел
print(" ".join(line_counts))

import csv
from datetime import datetime


# Получаем входные данные
user_id, class_id = input().split()

# Читаем необходимые файлы
with open("test.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    tests = list(reader)
with open("class_user_link.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    class_user_links = list(reader)
with open("test_class_user_link.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    test_class_user_links = list(reader)
with open("test_attempt.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    test_attempts = list(reader)

# Создаём словарь для быстрого доступа к тестам по id
test_dict = {test[0]: test[1] for test in tests}

# Находим связь между пользователем и классом
class_user_link_ids = []
for link in class_user_links:
    if link[2] == user_id and link[1] == class_id:
        class_user_link_ids.append(link[0])

# Список для назначенных тестов
assigned_tests = []
completed_tests = 0
# Для каждой связи ищем назначенные тесты
for class_user_link_id in class_user_link_ids:
    for link in test_class_user_links:
        if link[2] == class_user_link_id:
            test_id = link[1]
            test_class_user_link_id = link[0]
            datetime_started = datetime.strptime(link[3], "%d.%m.%Y %H:%M:%S")
            
            # Получаем название теста
            test_name = test_dict.get(test_id, "Unknown Test")
            
            # Проверяем, пройден ли тест
            test_completed = "FALSE"
            for attempt in test_attempts:
                if attempt[1] == test_class_user_link_id and attempt[2] == "TRUE":
                    test_completed = attempt[2]
                    completed_tests += 1
                    break
            
            data = {
                "test_name": test_name,
                "datetime_started": datetime_started,
                "test_completed": test_completed
            }
            for i, assigned_test in enumerate(assigned_tests):
                if (
                    assigned_test["datetime_started"] < data["datetime_started"] or 
                    (
                        assigned_test["datetime_started"] == data["datetime_started"] and 
                        assigned_test["test_name"] > data["test_name"]
                    )
                ):
                    assigned_tests.insert(i, data)
                    break
            else:
                assigned_tests.append(data)

print(f"{completed_tests}/{len(assigned_tests)}")

# Выводим информацию о каждом тесте
for test in assigned_tests:
    print(f"{test['test_name']} {test['datetime_started'].strftime('%d.%m.%y')} {test['test_completed']}")

import csv
from datetime import datetime


# Получаем входные данные
user_id, class_id = input().split()

# Читаем необходимые файлы
with open("class_user_link.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    class_user_links = list(reader)
with open("test_class_user_link.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    test_class_user_links = list(reader)
with open("test_task_link.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    test_task_links = list(reader)
with open("task_attempt.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    task_attempts = list(reader)
with open("task_attempt.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    task_attempts = list(reader)
with open("test_attempt.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    test_attempts = list(reader)
with open("task.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    tasks = list(reader)

task_dict = {task[0]: task for task in tasks}

# Находим связь между пользователем и классом
for link in class_user_links:
    if link[2] == user_id and link[1] == class_id:
        class_user_link_id = link[0]
        break


# Находим все тесты для данного пользователя, отсортированные по дате
user_tests = []
for link in test_class_user_links:
    if link[2] == class_user_link_id:
        test_id = link[1]
        test_class_user_link_id = link[0]
        datetime_started = datetime.strptime(link[3], "%d.%m.%Y %H:%M:%S")
        data = {
            "test_id": test_id,
            "class_user_link_id": link[2],
            "test_class_user_link_id": test_class_user_link_id,
            "datetime_started": datetime_started,
        }
        # Сортируем тесты по дате выдачи (от поздних к ранним)
        for i, user_test in enumerate(user_tests):
            if user_test["datetime_started"] < data["datetime_started"]:
                user_tests.insert(i, data)
                break
        else:
            user_tests.append(data)

if not user_tests:
    print("Тестов не найдено")
    exit()

latest_test = user_tests[0]
test_id = latest_test["test_id"]
test_class_user_link_id = latest_test["test_class_user_link_id"]
for test_attempt in test_attempts:
    if test_attempt[1] == test_class_user_link_id:
        test_attempt_id = test_attempt[0]
        break
else:
    print("Попытки не найдено")
    exit()

# Получаем все задачи для этого теста
test_tasks = []
for link in test_task_links:
    if link[1] == test_id:
        data = {
            "order_number": int(link[3]),
            "task_id": link[2],
        }
        # Сортируем задачи по порядковому номеру
        for i, test_task in enumerate(test_tasks):
            if test_task["order_number"] > data["order_number"]:
                test_tasks.insert(i, data)
                break
        else:
            test_tasks.append(data)

# Получаем ответы для задач
task_results = {}
total_time_spent_seconds = 0

for attempt in task_attempts:
    if attempt[2] == test_attempt_id:
        task_id = attempt[1]
        user_answer = attempt[3]

        if user_answer.strip() == "":
            continue  # Пропускаем, если ответ пустой
        
        is_correct = attempt[3] == task_dict[task_id][2]
        time_spent = int(attempt[5]) if attempt[5] else 0  # Время в секундах
        total_time_spent_seconds += int(time_spent)

        # Добавляем результат задачи
        task_results[task_id] = {
            "is_correct": is_correct,
            "time_spent": time_spent,
        }

# Вычисляем проценты
total_questions = len(test_tasks)
answered_questions = len(task_results)
correct_answers = sum(1 for result in task_results.values() if result["is_correct"])
percentage_answered = (answered_questions / total_questions * 100) if total_questions > 0 else 0
percentage_correct = (correct_answers / answered_questions * 100) if answered_questions > 0 else 0

# Выводим результаты
print(f"{percentage_answered:.1f}% {percentage_correct:.1f}%")

for task in test_tasks:
    task_id = task["task_id"]
    
    # Определяем статус ответа
    if task_id in task_results:
        answer_status = "TRUE" if task_results[task_id]["is_correct"] else "FALSE"
    else:
        answer_status = "?"
    
    print(f"{task['order_number']} {answer_status} {task_id}")

# Формируем время в формате hh:mm:ss
hours, remainder = divmod(total_time_spent_seconds, 3600)
minutes, seconds = divmod(remainder, 60)
print(f"{hours:02d}:{minutes:02d}:{seconds:02d}")

import csv
import json
from datetime import datetime

# Чтение входных данных
user_id, class_id = input().split()

# Чтение данных из CSV-файлов
with open("user.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    users = list(reader)
with open("class_user_link.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    class_user_links = list(reader)
with open("task.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    tasks = list(reader)
with open("test.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    tests = list(reader)
with open("test_task_link.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    test_task_links = list(reader)
with open("test_class_user_link.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    test_class_user_links = list(reader)
with open("test_attempt.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    test_attempts = list(reader)
with open("task_attempt.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader)  # Пропускаем заголовок
    task_attempts = list(reader)

users_dict = {user[0]: user for user in users}
class_user_links_dict = {
    (class_user_link[1], class_user_link[2]): class_user_link 
    for class_user_link in class_user_links
}
tasks_dict = {task[0]: task for task in tasks}
tests_dict = {test[0]: test for test in tests}
test_attempts_dict = {test_attempt[1]: test_attempt for test_attempt in test_attempts}
task_attempts_dict = {
    (task_attempt[1], task_attempt[2]): task_attempt 
    for task_attempt in task_attempts
}

if user_id not in users_dict:
    print("Пользователь не найден")
    exit()

# Проверка принадлежности пользователя к классу
class_user_link = class_user_links_dict.get((class_id, user_id), None)
if not class_user_link:
    print("Пользователь не принадлежит к указанному классу")
    exit()

# Формирование информации о пользователе
user_info = {
    "user_id": int(user_id),
    "full_name": f"{users_dict[user_id][4]} {users_dict[user_id][2]}",  # last_name, first_name
    "class_id": int(class_id),
}

# Получение списка тестов, выданных пользователю
user_test_links = []
for link in test_class_user_links:
    if link[2] == class_user_link[0]:
        link[3] = datetime.strptime(link[3], "%d.%m.%Y %H:%M:%S")
        for i, user_test_link in enumerate(user_test_links):
            if link[3] > user_test_link[3]:
                user_test_links.insert(i, link)
                break
        else:
            user_test_links.append(link)

# Формирование списка тестов с задачами и статусом их выполнения
tests_data = []
accuracy_sum = 0
test_count = 0
tests_completed = 0

for test_link in user_test_links:
    test_id = test_link[1]

    test_info = tests_dict.get(test_id, None)
    if test_info is None:
        print("Тест не найден")
        continue

    test_attempt = test_attempts_dict.get(test_link[0], None)

    # Получение задач теста
    test_tasks = []
    for link in test_task_links:
        if link[1] == test_id:
            for i, test_task in enumerate(test_tasks):
                if int(link[3]) < int(test_task[3]):
                    test_tasks.insert(i, link)
                    break
            else:
                test_tasks.append(link)
    
    tasks_data = []
    correct_count = 0
    answered_count = 0
    total_time_seconds = 0
    
    for task_link in test_tasks:
        task_id = task_link[2]  # task_id
                
        # Получение статуса выполнения задачи
        task_attempt = task_attempts_dict.get((task_id, test_attempt[0]), None)
        
        is_correct = "?"
        if task_attempt:
            user_answer = task_attempt[3].strip()
            if user_answer != "":
                answered_count += 1
                # Получение правильного ответа для задачи
                task_info = tasks_dict.get(task_id, None)
            
                if task_info:
                    if task_attempt[3] == task_info[2]:
                        correct_count += 1
                        is_correct = "TRUE"
                    else:
                        is_correct = "FALSE"
            
            # Учёт времени выполнения
            if task_attempt[5]:  # time_spent
                total_time_seconds += int(task_attempt[5])
        
        tasks_data.append({
            "order_number": int(task_link[3]),  # order_number
            "task_id": int(task_id),
            "is_correct": is_correct,
        })
    
    # Расчёт процента выполнения и точности
    total_tasks = len(test_tasks)
    progress_percent = 100.0 * answered_count / total_tasks if total_tasks > 0 else 0.0
    correct_percent = 100.0 * correct_count / answered_count if answered_count > 0 else 0.0
    
    # Форматирование времени
    hours = total_time_seconds // 3600
    minutes = (total_time_seconds % 3600) // 60
    seconds = total_time_seconds % 60
    
    # Добавление информации о тесте
    test_data = {
        "test_id": int(test_id),
        "title": test_info[1],
        "tasks": tasks_data,
        "progress_percent": round(progress_percent, 1),
        "correct_percent": round(correct_percent, 1),
        "time": f"{hours:02d}:{minutes:02d}:{seconds:02d}",
        "date_assigned": test_link[3].strftime("%d.%m.%y"),
    }
    
    tests_data.append(test_data)

    if test_attempt and test_attempt[2] == "TRUE":
        tests_completed += 1
    # Учёт точности для расчёта среднего
    if answered_count > 0:
        accuracy_sum += correct_percent
        test_count += 1

# Расчёт общего прогресса
accuracy_average = accuracy_sum / test_count if test_count > 0 else 0

progress_info = {
    "tests_completed": tests_completed,
    "tests_total": len(tests_data),
    "accuracy_average_percent": round(accuracy_average, 1)
}

# Формирование итогового словаря
result = {
    "user": user_info,
    "progress": progress_info,
    "tests": tests_data
}

# Вывод результата
print(json.dumps(result, ensure_ascii=False, indent=2))