Removed unnecessary docstrings and refactored.

Author: jzshred

flashcards.py

@@ -11,7 +11,7 @@ def __init__(self):
         self.__chosen_subject = 0
         self.__subject_questions = []
         self.__subject_answers = []
-        self.__number_of_subject_questions = 0
+        self.__number_of_questions_in_subject = 0
 
         self.__random_subject = len(self.__subjects) - 1
         self.__random_questions = []
@@ -25,7 +25,6 @@ def __init__(self):
         self.__quit_session = False
 
     def start(self):
-        """Start the Q&A session."""
         if not self.__quit_session:
             self.__display_intro()
             self.__display_subjects()
@@ -39,7 +38,6 @@ def start(self):
                 self.start()
 
     def __display_intro(self):
-        """Print the program title and instructions."""
         if not self.__intro_displayed:
             title_length = 35
             print("=" * title_length)
@@ -51,77 +49,66 @@ def __display_intro(self):
             self.__intro_displayed = True
 
     def __display_subjects(self):
-        """Print the available subjects for a Q&A session."""
         print("Choose your subject:")
         for i, j in enumerate(self.__subjects):
             print(f"{(i + 1):>2}. {j}")
         print("On any question, input 'q' to quit.")
 
     def __choose_subject(self):
-        """Ask the user to choose the Q&A subject."""
         chosen_subject = input()
         try:
             self.__check_valid_subject(chosen_subject)
         except ValueError:
             self.__check_quit_session(chosen_subject)
 
     def __check_valid_subject(self, chosen_subject):
-        """Check if the user has chosen a valid Q&A subject."""
         chosen_subject = int(chosen_subject)
         if 1 <= chosen_subject <= len(self.__subjects):
             self.__chosen_subject = chosen_subject - 1
         else:
             self.__invalid_subject()
 
     def __check_quit_session(self, chosen_subject):
-        """Check if the user has chosen to quit the Q&A session."""
         if chosen_subject.lower() == 'q':
             self.__display_score()
             self.__quit_session = True
         else:
             self.__invalid_subject()
 
     def __invalid_subject(self):
-        """Indicate that an invalid subject has been chosen. Take user to choose another subject."""
         print("Invalid option. Please choose again.")
         self.__choose_subject()
 
     def __build_qa_session(self):
-        """Build a subject or random Q&A session, based on user's choice."""
         if self.__chosen_subject == self.__random_subject:
             self.__build_random_qa_session()
         else:
             self.__build_subject_qa_session()
 
     def __build_subject_qa_session(self):
-        """Build a subject Q&A session."""
         self.__clear_subject_qa_session()
         self.__build_subject_questions()
         self.__build_subject_answers()
 
     def __clear_subject_qa_session(self):
-        """Clear lists of subject questions and answers."""
         self.__subject_questions.clear()
         self.__subject_answers.clear()
 
     def __build_subject_questions(self):
-        """Retrieve questions from the chosen subject."""
         filename = self.__subjects_folder \
             + self.__subjects[self.__chosen_subject].lower().replace(' ', '_') \
             + "_questions.txt"
         with open(filename) as file_object:
             self.__subject_questions = file_object.readlines()
 
     def __build_subject_answers(self):
-        """Retrieve answers from the chosen subject."""
         filename = self.__subjects_folder\
             + self.__subjects[self.__chosen_subject].lower().replace(' ', '_')\
             + "_answers.txt"
         with open(filename) as file_object:
             self.__subject_answers = file_object.readlines()
 
     def __build_random_qa_session(self):
-        """Retrieve random questions and answers."""
         self.__clear_random_qa_session()
         while len(self.__random_questions) < self.__number_of_random_questions:
             self.__choose_random_subject()
@@ -133,51 +120,41 @@ def __build_random_qa_session(self):
         self.__reset_random_subject()
 
     def __clear_random_qa_session(self):
-        """Clear lists of random questions and answers."""
         self.__random_questions.clear()
         self.__random_answers.clear()
 
     def __choose_random_subject(self):
-        """Choose a random subject within the range of available subjects."""
         self.__chosen_subject = randrange(self.__random_subject)
 
     def __choose_random_question_number(self):
-        """Choose a question number within the range of available questions."""
         self.__random_question_number = randrange(len(self.__subject_questions))
 
     def __build_random_question(self):
-        """Add a new question to the random questions list."""
         if self.__subject_questions[self.__random_question_number] not in self.__random_questions:
             self.__random_questions.append(self.__subject_questions[self.__random_question_number])
 
     def __build_random_answer(self):
-        """Add the corresponding answer to the random answers list."""
         if self.__subject_answers[self.__random_question_number] not in self.__random_answers:
             self.__random_answers.append(self.__subject_answers[self.__random_question_number])
 
     def __copy_random_questions_and_answers(self):
-        """Copy random questions and answers to subject questions and answers."""
         self.__subject_questions = self.__random_questions
         self.__subject_answers = self.__random_answers
 
     def __reset_random_subject(self):
-        """Reset the chosen subject to the random subject."""
         self.__chosen_subject = self.__random_subject
 
     def __display_subject_title(self):
-        """Print the chosen subject title and the number of questions."""
-        self.__set_number_of_subject_questions()
-        print(f"\n--- {self.__subjects[self.__chosen_subject]}: {self.__number_of_subject_questions} questions ---")
+        self.__set_number_of_questions_in_subject()
+        print(f"\n--- {self.__subjects[self.__chosen_subject]}: {self.__number_of_questions_in_subject} questions ---")
 
-    def __set_number_of_subject_questions(self):
-        """Set the total number of questions that the Q&A session will go through."""
+    def __set_number_of_questions_in_subject(self):
         if self.__chosen_subject == self.__random_subject:
-            self.__number_of_subject_questions = self.__number_of_random_questions
+            self.__number_of_questions_in_subject = self.__number_of_random_questions
         else:
-            self.__number_of_subject_questions = len(self.__subject_questions)
+            self.__number_of_questions_in_subject = len(self.__subject_questions)
 
     def __ask_questions(self):
-        """Ask the list of questions, one by one."""
         for question_number, question in enumerate(self.__subject_questions):
             print(f"Q{question_number + 1}. {question[:-1]}")
             response = self.__check_answer(question_number)
@@ -188,7 +165,6 @@ def __ask_questions(self):
                 self.__compute_score(response)
 
     def __check_answer(self, question_number):
-        """Check if the user inputs the correct or incorrect answer, or decides to quit."""
         answer = input()
         if answer == self.__subject_answers[question_number][:-1]:
             print("Correct!")
@@ -201,14 +177,12 @@ def __check_answer(self, question_number):
             return "incorrect"
 
     def __compute_score(self, response):
-        """Compute user's score based on correct and incorrect answers."""
         if response == "correct":
             self.__correct_answers += 1
         elif response == "incorrect":
             self.__incorrect_answers += 1
 
     def __display_score(self):
-        """Display user's score if there is one."""
         total_answers = self.__correct_answers + self.__incorrect_answers
         if total_answers > 0:
             print("\n--- Results ---")
@@ -218,7 +192,6 @@ def __display_score(self):
             print(f"Accuracy rate: {accuracy:.2%}")
 
     def __ask_to_continue(self):
-        """Ask the user if he wants to continue with a new Q&A session."""
         if not self.__quit_session:
             print("\nWould you like to continue with another subject? (y/n)")
             continue_with_qa = input()

test_flashcards.py

@@ -4,13 +4,11 @@
 
 
 def test_randrange():
-    """Test imported function randrange from random module."""
     assert randrange(1) == 0
 
 
 @pytest.fixture()
 def cardset():
-    """Return a Flashcard object."""
     return Flashcard()
 
 
@@ -22,16 +20,14 @@ def cardset_with_subject(cardset):
     return cardset
 
 
-def test_choose_subject_valid_subject(cardset, monkeypatch):
-    """Test a valid input for the Q&A subject."""
+def test_choose_subject_case_valid_subject(cardset, monkeypatch):
     chosen_subject = 1
     monkeypatch.setattr("builtins.input", lambda: chosen_subject)
     cardset._Flashcard__choose_subject()
     assert cardset._Flashcard__chosen_subject == 0
 
 
-def test_choose_subject_quit_session(cardset, monkeypatch):
-    """Test quitting the Q&A session from the subject selection."""
+def test_choose_subject_case_quit_session(cardset, monkeypatch):
     chosen_subject = 'q'
     monkeypatch.setattr("builtins.input", lambda: chosen_subject)
     cardset._Flashcard__choose_subject()
@@ -72,31 +68,27 @@ def test_build_random_qa_session_answers(cardset):
     assert len(cardset._Flashcard__subject_answers) == cardset._Flashcard__number_of_random_questions
 
 
-def test_set_number_of_subject_questions_subject(cardset_with_subject):
-    """Test that the correct number of questions is set for a particular subject."""
-    cardset_with_subject._Flashcard__set_number_of_subject_questions()
-    assert cardset_with_subject._Flashcard__number_of_subject_questions \
+def test_set_number_of_questions_in_subject_case_subject(cardset_with_subject):
+    cardset_with_subject._Flashcard__set_number_of_questions_in_subject()
+    assert cardset_with_subject._Flashcard__number_of_questions_in_subject \
            == len(cardset_with_subject._Flashcard__subject_questions)
 
 
-def test_set_number_of_subject_questions_random(cardset):
-    """Test that the correct number of questions is set for the random subject."""
+def test_set_number_of_questions_in_subject_case_random(cardset):
     cardset._Flashcard__chosen_subject = cardset._Flashcard__random_subject
-    cardset._Flashcard__set_number_of_subject_questions()
-    assert cardset._Flashcard__number_of_subject_questions == cardset._Flashcard__number_of_random_questions
+    cardset._Flashcard__set_number_of_questions_in_subject()
+    assert cardset._Flashcard__number_of_questions_in_subject == cardset._Flashcard__number_of_random_questions
 
 
-def test_display_subject_title_subject(cardset_with_subject, capsys):
-    """Test that the correct subject title is displayed."""
+def test_display_subject_title_case_subject(cardset_with_subject, capsys):
     cardset_with_subject._Flashcard__display_subject_title()
     stdout, stderr = capsys.readouterr()
     assert stdout == (f"\n--- "
                       f"{cardset_with_subject._Flashcard__subjects[cardset_with_subject._Flashcard__chosen_subject]}: "
-                      f"{cardset_with_subject._Flashcard__number_of_subject_questions} questions ---\n")
+                      f"{cardset_with_subject._Flashcard__number_of_questions_in_subject} questions ---\n")
 
 
-def test_display_subject_title_random(cardset, capsys):
-    """Test that the random subject title is displayed."""
+def test_display_subject_title_case_random(cardset, capsys):
     cardset._Flashcard__chosen_subject = cardset._Flashcard__random_subject
     cardset._Flashcard__display_subject_title()
     stdout, stderr = capsys.readouterr()
@@ -113,13 +105,13 @@ def test_check_answer(cardset_with_subject, monkeypatch, mock_answer, expected_r
     assert cardset_with_subject._Flashcard__check_answer(question_number) == expected_result
 
 
-def test_compute_score_correct_answer(cardset):
+def test_compute_score_case_correct_answer(cardset):
     response = "correct"
     cardset._Flashcard__compute_score(response)
     assert cardset._Flashcard__correct_answers == 1
 
 
-def test_compute_score_incorrect_answer(cardset):
+def test_compute_score_case_incorrect_answer(cardset):
     response = "incorrect"
     cardset._Flashcard__compute_score(response)
     assert cardset._Flashcard__incorrect_answers == 1