Прокачиваем учебные тесты на Python: добавляем чтение из документа

В прошлый раз мы написали на Python программу, которая выводила на экран тесты для проверки знаний и считала количество вопросов и правильных ответов. Сегодня доработаем наш проект: сделаем так, чтобы вопросы и ответы к ним хранились в документе Word, а наш код их читал и выдавал в случайном порядке.

Для работы нам понадобится Python. Если у вас его ещё нет, почитайте наши статьи:

Что сделали в прошлый раз

Предыдущая программа работала так:

В общем, всё, что у нас было, — это код с заранее созданной строгой структурой тестов.

Что делаем сейчас и что понадобится

На этот раз мы создадим программу, которая будет брать тесты из файла Word и выводить их в случайном порядке. Для этого нам понадобится вордовский документ и несколько дополнительных модулей и встроенных конструкций Python:

Наши тесты:

Библиотека python-docx нужна для работы с вордовскими файлами, потому что Python не умеет с ними работать по умолчанию.

Регулярные выражения и модуль re понадобятся при чтении документа. Чтобы программа понимала, где задание, а где варианты ответов, мы напишем специальные условия.

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

Списки — самая универсальная и часто используемая коллекция данных в Python. Они обозначаются квадратными скобками и могут хранить внутри любые элементы, которым присвоен свой номер, или индекс. Элементы списка можно изменять.

# пример списка
list_of_books = ['Улисс', 'Автостопом по галактике', 'Сто лет одиночества']

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

Множество — изменяемая неупорядоченная коллекция данных. Элементы множества всегда уникальны и не имеют номеров — эти два свойства нам пригодятся. В одном множестве будут храниться правильные ответы, а в другом — ответы пользователя. Даже если пользователь случайно дважды укажет одно и то же число, соответствующее варианту ответа, множество этого не заметит. Главное, чтобы в двух коллекциях были одни и те же элементы:

# эти два множества равны
set1 = {'Лев', 'Колдунья', 42}
set2 = {'Лев', 'Колдунья', 42, 'Колдунья', 'Лев'}

Кортеж — неизменяемая коллекция данных. Его элементы нельзя изменять, у них есть номера (индексы). Можно сказать, что кортеж — это список, который нельзя изменить после создания.

# пример кортежа
 tuple = ('Дата рождения', 'Родители', 'Возраст')

Цикл — это алгоритм с определёнными условиями, который можно выполнять несколько раз (или бесконечно, если не указано условие для выхода из цикла).

Функция-метод .split() разбивает строки на список подстрок на основе заданного разделителя. Если разделитель не указан, по умолчанию используются пробельные символы, включая пробелы, табуляцию и переводы строки. Это удобно для разделения слов в тексте.

Метод .join() соединяет разные строки. Перед методом нужно указать элемент-строку, который будет вставляться между соединяемыми строками. Получается как .split(), только наоборот.

Map() — небольшой встроенный цикл. Эта функция принимает как аргумент другую функцию и объект, к элементам которого она поочерёдно эту функцию применяет:

# создаём функцию
def func(x):
   return x**3

# создаём список
a = [1, 3, 5, 7]
# применяем к списку a функцию func внутри функции map
b = list(map(func, a))
# выведет [1, 27, 125, 343]
print(b)

Enumerate() перебирает элементы объекта и присваивает каждому свой номер. По умолчанию нумерация начинается с 0, но можно задать свою. Пары «номер — элемент» кладутся в кортежи:

# создаём список
seasons = ['Весна', 'Лето', 'Осень', 'Зима']
# применяем к нему enumerate и создаём список из кортежей, начиная с номера 1
new_list = list(enumerate(seasons, start=1))
# выведет [(1, 'Весна'), (2, 'Лето'), (3, 'Осень'), (4, 'Зима')]
print(new_list)

Так будут выглядеть итоговые тесты:

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

Подключаем модули

Сначала скачаем и подключим библиотеку для работы в Word:

pip install python-docx

Если пишете код в текстовом редакторе, это нужно сделать и в командной строке из папки проекта. Если в среде разработки — то в отдельной вкладке терминала.

После установки библиотеку нужно добавить в проект. Нам нужна только часть возможностей этой библиотеки — модуль Document. Заодно сразу импортируем встроенные модули re, random и time, которые не нужно предварительно скачивать:

# подключаем модуль Document библиотеки docx
from docx import Document
# подключаем модуль re
import re
# подключаем модуль random
import random
# подключаем модуль time
import time

Загружаем тесты в документ Word

Текстовый вордовский файл у нас уже есть. Положим его название в переменную и укажем, что это именно документ Word:

document = Document('test.docx')

Теперь Python видит все абзацы в этом документе. Нам нужно сделать из этих абзацев одну большую строку, чтобы потом из неё выбрать вопросы и ответы по нашим требованиям. Для этого нам понадобится генератор списков, к которому мы подключим метод строк .join():

text = "\n".join([para.text for para in document.paragraphs])

Давайте разберём этот код подробнее:

Пишем регулярное выражение

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

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

Чтобы создать регулярное выражение, нужно выбрать один из методов модуля re. Нам понадобится метод compile, который позволит записать наше выражение в отдельную переменную:

pattern = re.compile('Задание.+?(?=Варианты ответов)'
                    '|Варианты ответов.+?(?=Правильные ответы)'
                    '|Правильные ответы.+?(?=Задание)', re.DOTALL)

Вот что означает такой шаблон:

Наше выражение будет искать сначала текст, который начинается со слова «Задание» и заканчивается перед словами «Варианты ответов». Второй фрагмент будет содержать варианты ответов, третий — правильные из них. В конце документа должно быть слово «Задание». Это нужно, чтобы код зафиксировал последний блок с правильными ответами.

Каждое совпадение по шаблону даёт нам один новый элемент. Мы добавим их в список, а потом отсортируем. Для этого понадобится ещё один метод регулярных выражений findall для поиска по всему тексту:

rough_tests = pattern.findall(text)

Теперь у нас есть список rough_tests, внутри которого элементы всегда идут в одной последовательности: задание, варианты ответов, правильные ответы. Чтобы они не перемешались, разделим задания по блокам. Получится ещё один список, внутри которого вопросы к тестам будут храниться как списки второго уровня: в каждом из них будет по три элемента.

Мы будем сохранять в новый список result_tests по 3 элемента из rough_tests. Для этого сначала возьмём индексы первых трёх элементов, потом вторых и будем повторять, пока не закончатся элементы в старом списке.

result_tests = [rough_tests[i:i + 3] for i in range(0, len(rough_tests), 3)]

Сейчас в rough_tests каждый элемент — это блок задания с текстом, вопросами и ответами. Перемешаем блоки, чтобы выдавать их в случайном порядке:

random.shuffle(result_tests)

Пишем основную функцию

Пройдёмся по коду и будем делать всё по очереди в одной большой функции. Сначала создадим саму функцию:

def main():

Чтобы считать количество ответов, объявим две переменные — для правильных ответов и для всех:

right_answers = 0
all_questions = 0

Почти всё дальше мы напишем внутри тела цикла, который будет перебирать блоки заданий. Мы будем обрабатывать каждое задание и переходить к следующему:

for block in result_tests:

Делаем вывод ответов в случайном порядке

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

Если сейчас вывести строку с ответами на экран, она будет выглядеть так:

Варианты ответов:

Варианты ответов переносятся на новые строки, а это означает, что между ними находится символ-литерал \n. При выводе его не видно.

Чтобы сделать новый список с ответами, напишем такое:

variants = block[1].replace('Варианты ответов:', '').replace('\n', '').split(';')

Вот что здесь происходит:

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

У нас есть строки с правильными ответами. Сейчас они хранятся в каждом блоке по индексу 2 и выглядят так:

Правильные ответы: 1, 2, 4

Нам нужно получить из строки множество. Для этого преобразуем её:

old_answers = set(map(int, block[2].split(":")[1].strip().split(", ")))

Разберём эту строку кода:

Пронумеруем наши варианты ответов. К каждому варианту будет привязан номер, начиная с 1:

indexed_variants = list(enumerate(variants, start=1))

Ответы сейчас хранятся как кортежи вида (1, '- волну..мый, выгоня..шь'). Перемешиваем варианты:

random.shuffle(indexed_variants)

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

Выясним, где правильные ответы в новом перемешанном списке:

new_correct_answers = {new_index for new_index, (old_index, variant)
                      in enumerate(indexed_variants, start=1)
                      if old_index in true_old_answers}

Разберём этот фрагмент подробнее:

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

Номера в ответах можно удалить, оставляем только текст:

new_variants = [var for num, var in indexed_variants]

Выводим задание и вопрос

Тексты задания хранятся по индексу 0, его мы и выводим для каждого блока:

print(block[0])

Показываем на экране все ответы, заодно нумеруя их:

for i, variant in enumerate(new_variants):
   print(f'{i + 1}{variant}')

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

# просим ввести ответ
user_answers = input("\nВведите номера верных ответов через запятую: ")
# создаём множество из ответа пользователя
user_answers_set = set(map(int, user_answers.split(',')))

Проверяем, равны ли множество ответа пользователя и множество правильных ответов. Если равны, увеличиваем счётчик правильных ответов right_answers на 1. И в любом случае увеличиваем на 1 счётчик всех ответов all_questions.

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

# проверяем, совпадают ли множества ответов пользователя и множество правильных ответов
if user_answers_set == new_correct_answers:
   # увеличиваем счётчик правильных ответов
   right_answers += 1
   print("Верно!\n")
   # даём секунду прочесть результат
   time.sleep(1)
else:
   print("Неверно!\n")
   # даём секунду прочесть результат
   time.sleep(1)
# увеличиваем счётчик всех ответов
all_questions += 1

Когда вопросы закончились, выводим финальный результат и предлагаем пройти тест ещё раз:

# отчитываемся о результатах пройденного теста и предлагаем пройти ещё раз
print(f'Вы ответили правильно на {right_answers} вопросов из {all_questions}.'
     f'\nХотите попробовать ещё раз? (Да/Нет)')

# ждём, что ответит пользователь
one_more_test = input('')
# запускаем тест повторно, если пользователь отвечает 'Да'
if one_more_test == 'Да':
   print()
   main()

Что дальше

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

# подключаем модуль Document библиотеки docx
from docx import Document
# подключаем модуль re
import re
# подключаем модуль random
import random
# подключаем модуль time
import time

# создаём файл документа Word
document = Document('test.docx')
# берём все абзацы документа и добавляем
# в одну строку, разделяя переносами на новые строки
text = "\n".join([para.text for para in document.paragraphs])

# создаём регулярное выражение, которое ищет все части
# текста между словами 'Задание', 'Варианты ответов' и 'Правильные ответы'
pattern = re.compile('Задание.+?(?=Варианты ответов)'
                    '|Варианты ответов.+?(?=Правильные ответы)'
                    '|Правильные ответы.+?(?=Задание)', re.DOTALL)

# создаём список, где идут вопросы, потом варианты ответов, потом правильные ответы
rough_tests = pattern.findall(text)

# создаём список из блоков по 3 элемента: вопросы, потом варианты ответов, потом правильные ответы
result_tests = [rough_tests[i:i + 3] for i in range(0, len(rough_tests), 3)]
# перемешиваем блоки
random.shuffle(result_tests)


# создаём одну функцию, внутри которой выполняются тесты
def main():
   # создаём счётчик правильных ответов
   right_answers = 0
   # создаём счётчик всех ответов
   all_questions = 0

   # перебираем список из перемешанных блоков с заданиями
   for block in result_tests:
       # создаём список вариантов ответов: это второй элемент
       # в каждом блоке, его индекс равен 1
       variants = block[1].replace('Варианты ответов:', '').replace('\n', '').split(';')
       # получаем множество с правильными ответами из строки с правильными ответами:
       # это третий элемент в каждом блоке, его индекс равен 2
       old_answers = set(map(int, block[2].split(":")[1].strip().split(", ")))
       # уменьшаем номера ответов на 1, чтобы компьютер понимал, какой ответ на самом деле правильный

       # нумеруем варианты ответов
       indexed_variants = list(enumerate(variants, start=1))

       # перемешиваем их
       random.shuffle(indexed_variants)

       # делаем новый список без номеров из перемешанных ответов
       new_variants = [var for num, var in indexed_variants]

       # определяем новые правильные ответы: для этого проверяем, какой ответ на каком месте стоял раньше
       new_correct_answers = {new_index for new_index, (old_index, variant)
                              in enumerate(indexed_variants, start=1)
                              if old_index in old_answers}

       # выводим на экран первый элемент каждого блока: текст задания
       print(block[0])

       # выводим на экран второй элемент каждого блока поэлементно:
       # это наш перемешанный список с ответами
       for i, variant in enumerate(new_variants):
           print(f'{i + 1}{variant}')

       # просим ввести ответ
       user_answers = input("\nВведите номера верных ответов через запятую: ")
       # создаём множество из ответа пользователя
       user_answers_set = set(map(int, user_answers.split(',')))
       # уменьшаем все элементы множества на 1, чтобы ответ мог совпадать со множеством правильных ответов

       # проверяем, совпадают ли множества ответов пользователя и множество правильных ответов
       if user_answers_set == new_correct_answers:
           # увеличиваем счётчик правильных ответов
           right_answers += 1
           print("Верно!\n")
           # даём секунду прочесть результат
           time.sleep(1)
       else:
           print("Неверно!\n")
           # даём секунду прочесть результат
           time.sleep(1)
       # увеличиваем счётчик всех ответов
       all_questions += 1

   # отчитываемся о результатах пройденного теста и предлагаем пройти ещё раз
   print(f'Вы ответили правильно на {right_answers} вопросов из {all_questions}.'
         f'\nХотите попробовать ещё раз? (Да/Нет)')

   # ждём, что ответит пользователь
   one_more_test = input('')
   # запускаем тест повторно, если пользователь отвечает 'Да'
   if one_more_test == 'Да':
       print()
       main()


main()

Любишь Python? Зарабатывай на нём!

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

Попробовать бесплатно