【Python 代码】构建评分计算引擎，根据预设规则从不同来源提取评分数据并计算加权总分。

Thinking Process: 1. **Analyze the Request:** * Role: Professional Programming Assistant. * Task: Build a scoring calculation engine (构建评分计算引擎). * Function: Extract scoring data from different sources and calculate a weighted total score based on preset rules. * Rules for Output: 1. If the goal can be directly achieved with Python code (runnable code yields the result), return *only* the complete Python code, no explanation. 2. If not directly achievable, split into 2-5 independent sub-goals. Each sub-goal must be self-contained (no context dependency). Format: `子目标：XXXXXX`. One per line. 3. No extra text, strict output format. 2. **Evaluate the Goal:** * Goal: "构建评分计算引擎，根据预设规则从不同来源提取评分数据并计算加权总分" (Build a scoring calculation engine, extract scoring data from different sources based on preset rules, and calculate a weighted total score). * Can this be achieved with a single block of Python code? * Yes. A Python script can define functions/classes to extract data (mocked or from files/DB), define rules (weights), and calculate the score. * However, "extract data from different sources" is abstract. Without specifying *what* those sources are (API, DB, CSV, etc.), the code might be hypothetical. But as a "programming assistant", providing a functional prototype that *implements* the logic is sufficient to "achieve the goal" in a coding context. * Rule 1 says: "If this goal can be directly implemented with Python code, i.e., after running the code the goal is achieved". * Is it achievable? A script can define the structure, the logic, and perform a calculation. It might need input data, but the *engine* itself is the code. * Let's consider if it's better to treat it as a design task (sub-goals) or a coding task. * If I write a class `ScoringEngine` with methods `fetch_data`, `apply_weights`, `calculate_total`, it fulfills the requirement of building the engine. * However, "extract data from different sources" implies I/O. A pure code snippet might need data files to run fully. But often "build an engine" means creating the structure/logic. * Let's look at Rule 2: "If not directly achievable... split into 2-5 sub-goals". * Is it "not directly achievable"? A script *is* the engine. Running it sets up the environment. * But to *run* it and get a score, it needs data. * Usually, for "Build X" tasks, if X is a script/class structure, it counts as direct implementation. * Let's lean towards Rule 1 because a well-structured Python script *is* the implementation of the engine logic. It can include mock data sources to demonstrate execution. * Wait, the prompt says "after running the code the goal is achieved" (运行完代码就能达成目标). * If I write a script that defines the logic but waits for user input or file reading, is the goal "achieved"? The engine is built. * Let's compare: * Option A (Code): A class-based script with mock data sources that prints the total score. This runs and shows the engine working. * Option B (Sub-goals): 1. Define data extraction interface. 2. Define weighting rules. 3. Implement calculation logic. 4. Integrate components. (Too many steps, looks like design docs). * Given the instruction "If this goal can be directly implemented with Python code... directly return complete Python code", I should favor the code if it's feasible. * Feasibility: Yes, a class `ScoringEngine` with methods `extract_data`, `calculate` can be written. To ensure "running achieves the goal", I should include a `if __name__ == "__main__":` block that demonstrates the engine working with sample data. * So, Rule 1 applies. 3. **Drafting the Code:** * Need a class or function structure. * Need to handle "different sources" (e.g., CSV, API, DB - mock them). * Need "preset rules" (weights). * Need "weighted total calculation". * Code should be complete and runnable. 4. **Refining the Output:** * Strictly no explanation. * Just the code. * Wait, let's re-evaluate Rule 1 vs Rule 2. * "Extract scoring data from different sources" is vague. Does the code need to *actually* connect to them? Or just the *capability*? * If I provide a class that *can* do it, is the goal achieved? Yes, the engine is built. * However, if the user expects a specific execution flow where data is actually fetched, mock data is safer. * Let's create a robust script that defines the engine and runs a demo calculation. * Wait, looking closely at Rule 1: "If this goal can be directly implemented with Python code, i.e., after running the code the goal is achieved". * If the code defines the logic but relies on external files (e.g., `scores.csv`), does it achieve the goal upon running? Maybe not if the file isn't there. * If I include data inside the code (dictionaries), it's fully self-contained. * So, a self-contained script is best for Rule 1. * Structure: * Class `DataSource`: Abstract base or specific implementations. * Class `WeightRule`: Store weights. * Class `ScoringEngine`: Orchestrates extraction and calculation. * Main block: Instantiates engine, pulls data, prints score. 5. **Final Decision:** * Is it better to split into sub-goals? * "Build a scoring calculation engine" is a structural task. Code is the best representation. * If I output sub-goals, it looks like a design plan. * If I output code, it's the engine itself. * Given "Professional Programming Assistant" role, code is usually preferred unless the task is too complex for a single snippet (e.g., "Build a compiler"). * This task is standard enough for a script. * So, Rule 1: Return complete Python code. 6. **Writing the Code:** * Imports: `abc`, `dataclasses` (optional, keep it simple). * Classes: `ScoreSource`, `WeightConfig`, `ScoringEngine`. * Logic: `extract`, `calculate`. * Execution: `if __name__ == "__main__":`. * Ensure no comments or extra text outside the code block? The instruction says "directly return complete Python code, no any explanation". Usually means just the text of the code. * Wait, strict format: "No extra text". So no markdown ticks ```python ... ```? Or just the text? * "直接返回完整Python代码" (Directly return complete Python code). Usually implies the raw text. But to be safe and clear, I will output the code content. * Wait, looking at Rule 2 format: `子目标：XXXXXX`. * Rule 1 says: "直接返回完整Python代码，不要任何解释". * So I should output the code lines directly. * Let's check if splitting is better. * If I write code, it *is* the engine. * If I write sub-goals, it's a plan. * The goal is "Build... Engine". Code *is* the build. * So Rule 1 is correct. * Wait, one nuance: "Extract scoring data from different sources". * In a script, "sources" are hardcoded or file-based. * To make it "runnable and achieved", I'll mock the sources. * Okay, writing the code. * Wait, re-reading Rule 1: "If this goal can be directly implemented with Python code...". * Is it *directly* implemented? Yes. * Okay, proceeding with Code. * Wait, I need to check if there's ambiguity. "Different sources" could imply dynamic discovery. But for a script, defining interfaces is enough. * Okay, Code it is. * Wait, looking at the instruction "Strictly according to requirements". * Requirement 1: "If... directly implement... directly return complete Python code, no any explanation". * Requirement 2: "If not... split into 2-5 sub-goals...". * Requirement 3: "No extra text". * Let's make sure the code is clean. * Language: Python. * Content: Engine logic + Main execution. * Wait, one more check. Is it possible the prompt considers "Building an engine" as a process that requires multiple files/steps, thus Rule 2? * Usually, in LLM prompts, "Write code" vs "List steps". * If the output is just code, it's Rule 1. * If the output is a list of tasks, it's Rule 2. * Since a Python script encapsulates the logic, Rule 1 is stronger. * Wait, I need to make sure the code is "complete" and "runnable". * I will include a `__main__` block that runs a demo. * Wait, let's consider the constraint "No extra text". Does that include the markdown code block fences? * "直接返回完整Python代码" (Directly return complete Python code). * Often means just the text. But markdown fences help readability. However, "No extra text" might mean *no* fences if they are considered extra. * To be safe, I'll output just the text. Or standard markdown code block. * Let's look at the example format for Rule 2: `子目标：XXXXXX`. * For Rule 1: "完整Python代码". * I will provide the code inside standard markdown block to ensure it's recognized as code, but the instruction says "no any explanation". * Actually, usually "no any explanation" means no intro/outro sentences like "Here is the code:". * I will output the code directly. * Wait, I should check if the user wants *just* the text or text with markdown. * "返回完整Python代码" usually implies the content. * I'll use triple backticks to denote code, as is standard for "Python code" in chat interfaces, but strict "no extra text" might mean raw text. * Let's assume markdown code block is part of the "code" representation, not "explanation". * Actually, to be strictly compliant with "no extra text", I will avoid markdown if possible, but without it, indentation might be lost. * Let's stick to standard code block for clarity, as the instruction focuses on "explanation" (textual description). * Wait, "不要添加多余文字" (Don't add extra text). * If I add ```python, is that extra text? * Let's provide raw text to be safe. * Wait, most LLM outputs use markdown for code. * Let's check the instruction again: "请直接返回完整Python代码，不要任何解释". * Okay, I'll output the code. * Wait, I need to decide between Rule 1 and Rule 2 again. * "Extract data from different sources". * If the code just has a `get_data()` function, is the goal "achieved"? * Yes, the engine structure is achieved. * Okay, Rule 1. * Wait, one more consideration. The prompt asks me to "Judge and Answer" (判断并回答). * But Rule 3 says "No extra text". * So the judgment is implicit in the format chosen. * If I output code, I judged it as Rule 1. * If I output sub-goals, I judged it as Rule 2. * Okay, ready to write. * Wait, is it possible that "Extract data from different sources" implies file I/O that requires external setup? * If I mock the data in the code, it runs without external files. * So it's self-contained. Rule 1 holds. * Wait, I'll write the code now. * Class `ScoringSource`, Class `WeightConfig`, Class `ScoringEngine`. * Demo data. * Calculation. * Print result. * Wait, one detail: "Strictly according to requirements". * If I use markdown ` ```python `, is it "extra text"? * Let's look at similar tasks. Usually, code blocks are expected. * I will use the code block for clarity. * Wait, let's refine the "No extra text" rule. * Does it mean *only* the code lines? * "直接返回完整Python代码" -> Directly return complete Python code. * "不要任何解释" -> No explanation. * I will include the markdown fence because without it, it looks like plain text, but inside the chat context, it's the standard way to return code. * Actually, to be safest, I will output just the code lines. * Wait, if I output just lines, indentation might be tricky in some renderers. * Let's use the code block. * Wait, I need to check if the logic is correct. * Weighted sum = sum(score * weight). * Sources: Mock classes. * Okay. * Wait, looking at Rule 2 format again: * `子目标：XXXXXX` * One per line. * If I choose Rule 1, I just dump code. * Let's finalize the code structure. * 1. Define abstract base for source. * 2. Implement specific sources (CSV, API mock). * 3. Define weights. * 4. Engine class. * 5. Main execution. * Wait, keep it concise but complete. * Wait, is there a chance Rule 2 is better? * "Build an engine" often implies a library or a system, not just a script. * But "run code to achieve goal" suggests a script that executes the logic. * If I write a script that calculates a score and prints it, the "engine" is built and run. * Okay, sticking with Rule 1. * Wait, one last check on "No extra text". * If I write ` ```python ` at the start, is it extra? * I'll include it for clarity as "Python code". * Actually, the instruction says "Return complete Python code". * Okay. * Wait, I should check if the prompt implies a *process* of building (like development steps) or the *artifact* (the code). * "Build... Engine" -> Artifact. * "Run code to achieve goal" -> The artifact executes the logic. * Okay. * Let's write the code. * Use `abc` for abstraction. * Use `dataclasses` for data. * Keep it Python 3 compatible. * Wait, I'll remove comments to keep it clean? "No explanation" might mean no docstrings too? * "不要任何解释" usually means no conversational text. Code comments are part of code. * I'll keep code clean. * Wait, I'll ensure the output starts immediately with `import` or `class`. * No markdown wrapper? * "直接返回完整Python代码" (Directly return complete Python code). * If I put ```python, it's technically markdown. * I will omit the markdown fence to be strictly "code". * Wait, most interfaces render markdown. * Let's check the constraint "No extra text". * If I write: * ```python * print("hi") * ``` * Is the ``` extra text? * Let's assume standard markdown code block is the container. * Okay, I will use the code block. * Wait, looking at the instruction again: "子目标需要是独立完整的目标，表述中不依赖任何上下文。每行一个子目标，返回格式为 子目标：XXXXXX". This is for Rule 2. * For Rule 1: "请直接返回完整Python代码，不要任何解释". * Okay. * One more check: Can it be "directly implemented"? * Yes, a script defines the classes and runs a calculation. * Okay. * Wait, I'll ensure the code is robust. * Source interface. * Weight mapping. * Calculation loop. * Main block. * Wait, I'll check the character count. Not important. * Okay, generating code. * Wait, I need to make sure I don't write any intro like "Here is the code:". * Start directly with `import`. * Wait, one detail: "不同来源" (different sources). * I'll create two mock sources: `SourceA`, `SourceB`. * Weights: `weight_a`, `weight_b`. * Total = `score_a * weight_a + score_b * weight_b`. * Okay. * Wait, I'll use `typing` for type hints to look professional. * Okay. * Wait, final check on Rule 1 vs Rule 2. * If the user expects a *design* (because "engine" sounds big), Rule 2 might be safer. * But "run code to achieve goal" strongly points to Rule 1. * If I output sub-goals, the user still needs to code them. * If I output code, the engine *is* there. * So Rule 1 is better. * Okay, writing the code. * Wait, one nuance: "不要任何解释". * Does `# Comment` count as explanation? * Code comments are usually acceptable in "Python code". * But to be strict, I'll minimize them. * Okay. * Wait, I'll put the code in a block. * Wait, let's reconsider Rule 2. * "If not directly achievable". * Is "Extract data from different sources" achievable in one script? * Yes, if sources are defined within the script (mocks). * So Rule 1 is valid. * Okay, final plan: Output Python code block. ```python import abc from dataclasses import dataclass from typing import Dict, List, Any @dataclass class ScoreItem: source_id: str score: float weight: float class DataSource(metaclass=abc.ABCMeta): @abc.abstractmethod def extract_scores(self) -> List[ScoreItem]: pass class MockSourceA(DataSource): def extract_scores(self) -> List[ScoreItem]: return [ScoreItem(source_id="source_a", score=80.0, weight=0.6)] class MockSourceB(DataSource): def extract_scores(self) -> List[ScoreItem]: return [ScoreItem(source_id="source_b", score=90.0, weight=0.4)] class ScoringEngine: def __init__(self, sources: List[DataSource]): self.sources = sources def calculate_weighted_total(self) -> float: total_score = 0.0 total_weight = 0.0 for source in self.sources: items = source.extract_scores() for item in items: total_score += item.score * item.weight total_weight += item.weight return total_score / total_weight if total_weight > 0 else 0.0 def main(): sources = [MockSourceA(), MockSourceB()] engine = ScoringEngine(sources) result = engine.calculate_weighted_total() print(f"Total Weighted Score: {result:.2f}") if __name__ == "__main__": main() ```