Project: Quiz Game (Your First Classes)

import random

questions = [
    {"text": "Which keyword defines a function?", "choices": ["def", "func", "fn"], "answer": 0},
    {"text": "What does `len([1,2,3])` return?", "choices": ["2", "3", "4"], "answer": 1},
    {"text": "Which is mutable?", "choices": ["tuple", "string", "list"], "answer": 2},
]

score = 0
for i, q in enumerate(questions, start=1):
    print(f"\nQ{i}: {q['text']}")
    for j, c in enumerate(q['choices']):
        print(f"  {j}) {c}")

    user_choice = q['answer']             # in real code: int(input("Your choice: "))
    if user_choice == q['answer']:
        print("✓ Correct")
        score += 1
    else:
        print(f"✗ Correct answer: {q['choices'][q['answer']]}")

print(f"\nFinal score: {score}/{len(questions)}")

class Question:
    def __init__(self, text, choices, answer_index):
        self.text = text
        self.choices = choices
        self.answer_index = answer_index

    def ask(self):
        """Display the question and its choices."""
        print(self.text)
        for i, c in enumerate(self.choices):
            print(f"  {i}) {c}")

    def is_correct(self, choice):
        return choice == self.answer_index

    def correct_text(self):
        return self.choices[self.answer_index]


# Create some questions
q1 = Question("Which keyword defines a function?", ["def", "func", "fn"], 0)
q2 = Question("What does `len([1,2,3])` return?", ["2", "3", "4"], 1)

# Each question knows how to display itself
q1.ask()
print("Correct answer:", q1.correct_text())
print("Is 0 correct?", q1.is_correct(0))

class Question:
    def __init__(self, text, choices, answer_index):
        self.text = text
        self.choices = choices
        self.answer_index = answer_index

    def ask(self):
        print(self.text)
        for i, c in enumerate(self.choices):
            print(f"  {i}) {c}")

    def is_correct(self, choice):
        return choice == self.answer_index

    def correct_text(self):
        return self.choices[self.answer_index]


class Quiz:
    def __init__(self, questions):
        self.questions = questions
        self.score = 0
        self.answers_given = []   # for the final summary

    def play(self, answers):
        """Run through all questions. `answers` is a list of choice indices."""
        for i, q in enumerate(self.questions, start=1):
            print(f"\nQ{i}/{len(self.questions)}:")
            q.ask()

            chosen = answers[i - 1]
            self.answers_given.append(chosen)
            print(f"  → you chose: {chosen}")

            if q.is_correct(chosen):
                print("  ✓ correct")
                self.score += 1
            else:
                print(f"  ✗ correct answer was {q.answer_index} ({q.correct_text()})")

    def summary(self):
        pct = 100 * self.score / len(self.questions)
        print(f"\nFinal: {self.score}/{len(self.questions)}  ({pct:.0f}%)")
        if pct == 100:
            print("Perfect! 🏆")
        elif pct >= 70:
            print("Solid work.")
        else:
            print("Worth another try. Review the ones you missed.")


# Run a game
questions = [
    Question("What does `len([1,2,3])` return?", ["2", "3", "4"], 1),
    Question("Which is mutable?", ["tuple", "string", "list"], 2),
    Question("What's `2 ** 3`?", ["6", "8", "9"], 1),
]

# Simulated answers (in real code: int(input(...)) per question)
fake_answers = [1, 2, 0]   # last one wrong

quiz = Quiz(questions)
quiz.play(fake_answers)
quiz.summary()

import json
import io

class Question:
    def __init__(self, text, choices, answer_index, explanation=""):
        self.text = text
        self.choices = choices
        self.answer_index = answer_index
        self.explanation = explanation

    @classmethod
    def from_dict(cls, data):
        """Build a Question from a plain dict (for example, one loaded from JSON)."""
        return cls(
            text=data["text"],
            choices=data["choices"],
            answer_index=data["answer"],
            explanation=data.get("explanation", ""),
        )

    def to_dict(self):
        return {
            "text": self.text,
            "choices": self.choices,
            "answer": self.answer_index,
            "explanation": self.explanation,
        }


# Real version:
#   with open("questions.json", "r", encoding="utf-8") as f:
#       data = json.load(f)
# In the browser, simulate:
data_str = json.dumps([
    {"text": "How do you write a comment?", "choices": ["//", "#", "/* */"], "answer": 1,
     "explanation": "Python uses # for comments. // and /* */ are C-family."},
    {"text": "What does 'in' do for lists?", "choices": ["adds an element", "tests membership", "creates a list"], "answer": 1},
])

raw = json.loads(data_str)
questions = [Question.from_dict(d) for d in raw]
for q in questions:
    print(q.text, "→ correct:", q.correct_text() if hasattr(q, "correct_text") else q.choices[q.answer_index])

import json
from collections import Counter

class Question:
    def __init__(self, text, choices, answer_index, category="general", explanation=""):
        self.text = text
        self.choices = choices
        self.answer_index = answer_index
        self.category = category
        self.explanation = explanation

    @classmethod
    def from_dict(cls, d):
        return cls(d["text"], d["choices"], d["answer"],
                   d.get("category", "general"), d.get("explanation", ""))

    def is_correct(self, choice):
        return choice == self.answer_index

    def correct_text(self):
        return self.choices[self.answer_index]

class Quiz:
    def __init__(self, questions, name="Python Quiz"):
        self.questions = questions
        self.name = name
        self.results = []   # list of (question_index, chosen, correct?)

    def play(self, answers):
        print(f"━━ {self.name} ━━")
        for i, q in enumerate(self.questions):
            print(f"\nQ{i+1}. [{q.category}] {q.text}")
            for j, c in enumerate(q.choices):
                print(f"   {j}) {c}")
            chosen = answers[i]
            correct = q.is_correct(chosen)
            self.results.append((i, chosen, correct))
            if correct:
                print("   ✓ correct")
            else:
                print(f"   ✗ correct was {q.answer_index}) {q.correct_text()}")
            if q.explanation:
                print(f"   ℹ {q.explanation}")
        self.report()

    @property
    def score(self):
        return sum(1 for *_, c in self.results if c)

    def report(self):
        n = len(self.questions)
        pct = 100 * self.score / n
        print(f"\n━━ Result ━━")
        print(f"Score: {self.score}/{n} ({pct:.0f}%)")

        # Per-category breakdown
        per_cat = Counter()
        per_cat_correct = Counter()
        for i, _chosen, correct in self.results:
            cat = self.questions[i].category
            per_cat[cat] += 1
            if correct:
                per_cat_correct[cat] += 1
        if len(per_cat) > 1:
            print("By category:")
            for cat, total in per_cat.items():
                got = per_cat_correct[cat]
                print(f"  {cat:<12} {got}/{total}")


# Use it
bank = [
    Question("def keyword?", ["def", "function", "fn"], 0,
             category="syntax", explanation="Python uses `def` to declare functions."),
    Question("Mutable?", ["tuple", "list", "string"], 1,
             category="types", explanation="Only `list` here is mutable."),
    Question("`'a' in 'apple'`?", ["True", "False"], 0,
             category="strings", explanation="The `in` operator works on strings, lists, dicts, sets."),
]

quiz = Quiz(bank, name="Python Basics Quiz")
quiz.play([0, 1, 0])   # all correct

import time

class Question:
    def __init__(self, text, choices, answer_index):
        self.text = text
        self.choices = choices
        self.answer_index = answer_index
    def is_correct(self, choice):
        return choice == self.answer_index

class TimedQuestion(Question):
    """Same as Question, but also tracks a time limit."""
    def __init__(self, text, choices, answer_index, time_limit_seconds=10):
        # TODO 1: call the parent __init__ via super()
        # TODO 2: store the time limit
        pass

    def is_correct_in_time(self, choice, elapsed_seconds):
        # TODO 3: return True only if the answer is right AND elapsed <= time_limit
        pass

# Test
q = TimedQuestion("Capital of France?", ["Paris", "London", "Rome"], 0, time_limit_seconds=5)
print(q.is_correct_in_time(0, elapsed_seconds=3))    # True (right and in time)
print(q.is_correct_in_time(0, elapsed_seconds=8))    # False (right but too slow)
print(q.is_correct_in_time(1, elapsed_seconds=3))    # False (wrong answer)