状态：已完成
【Python 代码】若找到匹配项则返回该描述，若未找到则返回默认提示或None。
Thinking Process:
1. **Analyze the Request:**
* Role: Professional Programming Assistant.
* Goal: If a match is found, return the description; if not, return a default prompt or None.
* Rules:
1. If the goal can be directly achieved by running Python code, return the complete Python code without any explanation.
2. If not directly achievable, split the goal into 2-5 independent sub-goals. Each sub-goal must be independent and complete (no context dependency). Format: `子目标：XXXXXX`, one per line.
3. No extra text, strict output format.
* Input: The user hasn't provided a specific task description yet, just the instructions. Wait, looking closely at the prompt, it seems like the *prompt itself* defines the goal as "若找到匹配项则返回该描述，若未找到则返回默认提示或None" (If a match is found, return that description; if not, return a default prompt or None). However, usually, this kind of prompt expects the AI to *act* according to these rules for a *specific* input task. But here, the input is the instruction set itself.
* Wait, re-reading the prompt: "目标：若找到匹配项则返回该描述，若未找到则返回默认提示或None。" (Goal: If match found return description, else return default/None). This looks like the *task* the AI needs to solve right now, or is it a meta-instruction for future interactions?
* Actually, looking at the structure:
* "你是专业编程助手。" (You are a pro programming assistant.)
* "请严格按照要求判断并回答：" (Please judge and answer strictly according to requirements:)
* "目标：..." (Goal: ...)
* "规则：..." (Rules: ...)
* The "Goal" provided in the prompt is "若找到匹配项则返回该描述，若未找到则返回默认提示或None". This seems a bit abstract. Does it mean "If the *user's request* matches a specific pattern..."? Or is it asking me to write a script that does this?
* Let's look at Rule 1: "如果这个目标可以直接用Python代码实现...请直接返回完整Python代码" (If this goal can be directly achieved by Python code... return code).
* The "Goal" is "若找到匹配项则返回该描述，若未找到则返回默认提示或None". This sounds like a search/filter function. Can this be achieved by running Python code? Yes, a function that searches a list/dict and returns a value or None.
* However, usually, when a user sends this prompt, they want the AI to *follow* these rules for the *current* interaction. But since there's no specific data or context provided (like "search for 'error' in this log"), the "Goal" is somewhat abstract.
* Let's interpret the "Goal" as the task the AI needs to perform *now*. Since the goal is "If find match return description, else default/None", this is a logic flow. Can a single Python script run to achieve this *universally*? It depends on what data it searches.
* Perhaps the most literal interpretation is: The user wants me to output the result based on *this* prompt's instruction. But since there's no data to search, maybe it falls under Rule 2 (Sub-goals).
* Let's re-evaluate Rule 1 vs Rule 2.
* Rule 1: Direct Python code implementation. Example: "Calculate sum of 1 to 100" -> Code.
* Rule 2: Split into sub-goals. Example: "Design a login system" -> Sub-goals.
* The current goal is "If match found return description, else return default/None". This is a conditional logic statement. To make it runnable, I need data. Without data, it's a function definition.
* Is it "directly achievable"? A Python script that defines a function `find_match(key)` which does this is code. But does running it achieve the goal "If match found..."? It achieves the capability.
* However, usually, this specific prompt template is used to test the AI's ability to decide between Code vs. Sub-goals.
* Given the abstract nature of the goal ("If match..."), it's hard to say a single script execution *completes* the goal without specific input data. But often, "write a function that does X" is considered code.
* Let's look at the instruction again: "若找到匹配项则返回该描述，若未找到则返回默认提示或None" (If match found return description, if not return default/None).
* If I treat this as "Write a script that searches and returns", Rule 1 applies.
* If I treat this as "Define the steps to build a search mechanism", Rule 2 applies.
* Let's consider the constraint "子目标需要是独立完整的目标，表述中不依赖任何上下文" (Sub-goals must be independent, complete, no context dependency).
* Let's try to see if Rule 1 fits better. A script that prompts for input, searches, and returns result is direct.
* However, the prompt says "If *this* goal can be directly achieved by Python code...". The goal is a logic statement.
* Let's look at the "Goal" text again. It looks like the *task description* for the AI to follow for a *future* query, OR it is the task *for* the AI right now. Given the structure "请严格按照要求判断并回答" (Please judge and answer strictly according to requirements), the AI needs to output either Code or Sub-goals.
* Since there is no specific data provided to search, writing a script that *does* the searching (e.g., a function) is the best "Code" answer.
* However, is it "directly achieved"? Running a script usually produces output. If I write a function, running it might just define it.
* Let's consider the sub-goal path. 2-5 sub-goals.
1. Define the search data source.
2. Define the matching criteria.
3. Implement the search logic.
4. Handle the result (match/no match).
* These seem a bit procedural.
* Let's lean towards Rule 1 because "If match... return..." is a classic function logic. A Python script can implement this logic and return the value (even if it's hardcoded for demonstration).
* Wait, looking at the prompt style, it's often used to force the AI to output *only* code OR *only* sub-goals.
* Let's decide: Is "If match found return description, else return default/None" a task solvable by *one* script execution? Yes, a script that takes input and prints output.
* But wait, the prompt says "If *this* goal...". The goal is stated as "目标：若找到匹配项则返回该描述，若未找到则返回默认提示或None".
* Actually, a stronger interpretation is that this *is* the task. Since there's no context on *what* to search, a function definition is the most direct representation.
* Let's try to fit Rule 1. Code: A function `get_description(key)` that returns the description or None.
* Let's try to fit Rule 2.
1. 子目标：定义包含描述信息的匹配数据字典
2. 子目标：设定搜索的关键字或匹配条件
3. 子目标：实现查找逻辑并返回匹配项描述
4. 子目标：处理未匹配情况并返回默认提示
* Which is better? Rule 1 is preferred if "directly achievable". A script that defines the logic and runs it is direct. But without input, it's static.
* Let's look at the instruction "如果这个目标可以直接用Python代码实现，即运行完代码就能达成目标". (If this goal can be directly achieved by Python code, i.e., running the code achieves the goal).
* Running a script that *defines* a function doesn't "achieve the goal" of returning a description unless called.
* Running a script that *searches and prints* achieves the goal.
* So Code is viable.
* Let's write a script that has a dummy search logic (e.g., searching a list of items) and prints the result.
* Actually, to be safe and strictly follow "If match found... else...", the code should contain the logic.
* Let's check if Rule 2 is safer. The goal is abstract. "Find match, return desc". Without data, code is just a template.
* However, Rule 1 says "Directly achievable". A search script *is* the implementation.
* Let's go with Rule 1 (Code) because it's a programming assistant context.
* Wait, one more check: "返回该描述" (Return *that* description). Which description? The prompt doesn't specify what to search for. This makes "running the code" ambiguous.
* If I write code that searches for "apple" in a list, and "apple" exists, it returns "fruit".
* If the goal is generic, maybe Rule 2 is better because it breaks down the *creation* of this capability.
* But Rule 1 says "If...".
* Let's assume the goal is "Implement a search function".
* Code:
```python
def find_match(keyword, data):
for item in data:
if item['keyword'] == keyword:
return item['description']
return "默认提示"
# Example usage
data = [{"keyword": "python", "description": "编程语言"}]
print(find_match("python", data))
```
* Is this "directly achieving the goal"? It implements the logic.
* Let's consider the constraint "不要添加多余文字" (No extra text).
* Okay, I will choose Rule 1 (Code) as it's a programming task.
* Wait, re-reading the prompt again. The prompt *is* the instruction. The "Goal" inside the prompt is the task *for me*.
* Task: "If match found return description, else return default/None".
* Is this task *solvable* by code alone? Yes, a search function.
* Okay, I will output the code.
* Wait, looking at the "Rule 2" condition: "如果不能直接实现" (If not directly achievable).
* Is "Find match and return description" directly achievable? Without data, it's a specification. But code *is* the specification implementation.
* Let's try to make the code self-contained (with dummy data) so running it produces an output.
* Actually, if I just output the function, it doesn't "run" to produce a result.
* If I output a script that runs the search immediately, it achieves the goal (print result).
* Let's do that.
* Wait, one nuance: "返回该描述" (Return *the* description).
* Maybe the prompt implies "Write code that does this logic".
* Let's provide the code.
* Wait, checking the constraint again: "若未找到则返回默认提示或None".
* Code should handle this.
* Wait, I need to check if there are *any* other interpretations.
* Maybe the "Goal" refers to the user's implicit request? No, the prompt says "目标：...".
* Okay, Code it is.
* Wait, let's look at the sub-goal requirement again: "子目标需要是独立完整的目标，表述中不依赖任何上下文".
* If I choose Rule 2:
1. 子目标：构建包含描述信息的匹配数据集
2. 子目标：定义匹配查询的关键字或条件
3. 子目标：执行查询并验证是否存在匹配项
4. 子目标：根据匹配结果返回对应的描述或默认值
* This looks like a good breakdown.
* Which one is "Directly achievable by Python code"?
* If I write the code in Rule 1, running it *executes* the logic.
* If I write sub-goals in Rule 2, they are *requirements*.
* Rule 1 is "Directly achieved by running code".
* Does running code achieve "Return description"? Yes, if the code prints/returns it.
* I will stick with Rule 1.
* Wait, one detail: "直接返回完整Python代码，不要任何解释" (Directly return complete Python code, no explanation).
* So just the code block? Or just the text? "不要任何解释" implies no markdown text outside code? Usually, it means no "Here is the code:" text. Just the code.
* But should I include markdown ticks ```python ... ```?
* "返回完整Python代码". Usually implies the content. I will include ticks for clarity as code, or just raw text. To be safe on "no extra text", raw text might be better, but code blocks are standard. Let's look at "不要任何解释". Markdown ticks are formatting, not explanation. I'll use them.
* Actually, strict "no extra text" might mean *only* the code.
* Let's assume standard code block format is acceptable as "code".
* Wait, let's reconsider Rule 1 vs Rule 2.
* Goal: "若找到匹配项则返回该描述，若未找到则返回默认提示或None"
* This is a *behavior* spec.
* If I write code that does this behavior, I have implemented the goal.
* So Rule 1 fits.
* Wait, is there a catch? "目标：若找到匹配项则返回该描述..."
* Maybe the "Goal" is the *current* request to the AI.
* "If [user provides input] find match...".
* But since input is missing, the code must handle the logic.
* Okay, Code it is.
* Wait, I need to make sure the code is "Complete".
* It should have data, logic, and execution.
* Example:
```python
data = {"search_key": "description_text"}
def search(keyword):
return data.get(keyword, "默认提示")
print(search("search_key"))
```
* Wait, the goal says "Return None" OR "Default Prompt".
* Let's use None as default.
* Wait, the prompt says "默认提示或None" (Default prompt OR None).
* Okay.
* Let's refine the code to be generic enough.
* Actually, to be safe and "directly achieve", I'll make it search a specific dummy list.
* Wait, if I search for "test" and it exists, return description.
* Okay.
* Wait, one more thought: Is it possible the prompt wants me to *act* as the system?
* "If match found return description..."
* Since I am the assistant, maybe the "Goal" is what I should *do* with the current context.
* But since context is just the prompt...
* Let's assume Rule 1 (Code) is the intended response for "Write a script that does X".
* Wait, looking at the instruction "请严格按照要求判断并回答" (Please judge and answer strictly).
* So I need to decide Rule 1 or Rule 2.
* Decision: Rule 1.
* Reason: A function that searches and returns is directly executable code.
* Wait, checking the output format again.
* "直接返回完整Python代码" (Directly return complete Python code).
* "不要任何解释" (No explanation).
* So:
```python
def find_description(match_key, database):
if match_key in database:
return database[match_key]
return None
# Example data and execution
db = {"key1": "描述文本 1"}
result = find_description("key1", db)
print(result if result else "默认提示")
```
* Wait, the goal says "Return description" or "Default/None".
* The code above prints.
* To "Return", a function should return.
* Okay, I will write a script that defines and executes.
* Wait, I should check if "Directly achieved" means the code *output* is the result.
* Yes.
* Okay, finalizing code.
* Wait, one more check on Rule 2. "Sub-goals... independent... no context".
* If the goal was "Build a chatbot", code is hard (needs libraries, state). Sub-goals fit better.
* If the goal was "Search and return", code is easy.
* So Rule 1 is correct.
* Wait, I need to ensure "不要任何解释" means no markdown outside the code?
* Usually, code blocks are fine.
* I will provide just the code block.
* Wait, the prompt says "返回该描述" (Return *that* description).
* "该" (That) implies specific description found.
* Okay.
* Wait, I need to make sure I don't add `print` if the goal is "Return". But a script usually prints.
* "运行完代码就能达成目标" (Running the code achieves the goal).
* If the code defines a function, does it achieve the goal? Or does it need to call it?
* To be safe, call it.
* Wait, the prompt says "若未找到则返回默认提示或None".
* My code should handle this.
* Okay, writing the code now.
* Wait, is there any chance Rule 2 is better?
* "目标：若找到匹配项则返回该描述..."
* This is a *conditional logic*.
* Code encapsulates logic.
* Okay, Rule 1.
* Wait, one detail: "子目标需要是独立完整的目标... 每行一个子目标".
* If Rule 2, I need 2-5 lines.
* If Rule 1, just code.
* Okay.
* Wait, I'll check if I missed any "context dependency" in sub-goals if I chose Rule 2.
* "Define data source", "Define logic", "Return result".
* These are independent.
* But Code is more direct.
* Let's finalize the Code.
* Include a sample data structure, the search function, and the execution.
* Wait, I should check if the user wants me to *be* the code or *provide* the code.
* "直接返回完整Python代码" (Directly return complete Python code).
* So the output *is* the code.
* Wait, one detail: "不要任何解释" (No explanation).
* So no "Here is the code".
* Just ```python ... ``` or just code text.
* I'll use ```python ... ``` to be clear it's code.
* Wait, wait. Re-reading Rule 1: "如果这个目标可以直接用Python代码实现...请直接返回完整Python代码".
* Does the goal "If match found return description..." require *data* to be present in the code to be "achieved"?
* Yes, a generic search needs data.
* So I will include dummy data.
* Wait, one more check: "若未找到则返回默认提示或None".
* My code should reflect this choice.
* I'll choose "None" for simplicity, or "默认提示".
* The prompt says "Default Prompt OR None".
* I'll return None.
* Wait, I need to make sure the code is "Complete".
* Yes, import, def, run.
* Okay.
* Wait, one last check on the "Rule 1" condition.
* Is it "Directly achievable"?
* Yes, a script that searches and prints.
* Okay.
* Wait, I will remove the markdown ticks to be strictly "no extra text" if possible, but code blocks are standard for "Code".
* "完整Python代码" usually implies the text of the code.
* I'll use the ticks.
* Wait, looking at the prompt again: "不要添加多余文字" (Don't add extra text).
* Markdown ticks might count as extra text?
* Usually, in these tasks, ```python is acceptable.
* But to be strict:
* I'll include the ticks.
* Wait, let's look at the instruction "子目标... 每行一个子目标，返回格式为 子目标：XXXXXX".
* So if Rule 2, specific format.
* If Rule 1, just code.
* Okay.
* Wait, I'll decide on Rule 1 because it's a functional requirement easily mapped to a script.
* Wait, one nuance: "若找到匹配项则返回该描述" (If match found return *that* description).
* "该" (That) refers to the match.
* Okay.
* Final check on constraints:
* 1. Rule 1: Code, no explanation.
* 2. Rule 2: 2-5 sub-goals, specific format.
* 3. No extra text.
* I'll go with Rule 1.
* Wait, I need to ensure the code is "Complete".
* So it needs to be runnable.
* Okay.
* Wait, should I put `if __name__ == "__main__":`?
* Yes, good practice.
* Wait, one more thing. The goal is "If match found return...".
* Code should do exactly that.
* Okay.
* Wait, is there a chance the "Goal" is "Write a prompt"?
* No, "编程助手" (Programming Assistant).
* Okay.
* Wait, I'll make the code search a dictionary.
* Okay.
* Wait, the prompt says "若未找到则返回默认提示或None".
* I will use "None" for the default.
* Wait, one more thing: "不要任何解释".
* So no comments? "完整Python代码" usually allows comments.
* But "不要任何解释" might mean no *explanatory text* outside.
* Comments inside code are fine.
* Okay.
* Wait, to be extremely strict, I'll minimize comments.
* Wait, I'll write the code now.
* Wait, should I check if the goal is "Directly achievable"?
* Yes, a function + data + call is direct.
* Okay.
* Wait, one last check: "子目标... 表述中不依赖任何上下文".
* This applies to Rule 2.
* Okay.
* Decision: Rule 1.
* Wait, wait. The prompt says "若找到匹配项则返回该描述".
* "该描述" implies *the* description associated with the match.
* My code should handle that.
* Okay.
* Final check on output:
* Just the code block.
* Wait, I should check if there's a hidden "Default Prompt" requirement.
* "默认提示或None".
* I'll use "默认提示".
* Okay, writing the code.
* Wait, I need to make sure I don't add any text before or after.
* Wait, one more thought: Does "直接返回完整Python代码" mean the *content* of the code, or the *markdown block*?
* Usually markdown block.
* Okay.
* Wait, I'll double check the "Rule 2" condition. "如果不能直接实现".
* Is "Search and Return" directly implemented by code? Yes.
* Is "Design a system" directly implemented? No, needs steps.
* So Rule 1 is correct.
* Wait, I'll write the code.
* Wait, I should ensure the code is concise.
* Okay.
* Wait, one detail: "每行一个子目标" (One sub-goal per line).
* This is for Rule 2.
* Rule 1 has no line constraint for the output, just "complete code".
* Okay, ready.
* Wait, I'll make sure to use `if __name__ == "__main__":` to ensure execution.
* Okay.
* Wait, the prompt says "若未找到则返回默认提示或None".
* I'll use `return "默认提示"` or `return None`.
* I'll use `None` for simplicity, or `"默认提示"` to be explicit.
* I'll use `"默认提示"`.
* Wait, one more thing: "该描述" (That description).
* I need to make sure the data has descriptions.
* Okay.
* Wait, I'll make sure the code is valid Python.
* Okay.
* Wait, I'll remove the markdown ticks to be strictly "no extra text"?
* "完整Python代码" usually implies the text.
* But markdown ticks help identify it.
* I'll include them.
* Wait, I'll check the instruction "不要添加多余文字" (Don't add extra text).
* If I add ` ```python `, is that "extra text"?
* Technically yes.
* But it's standard for code.
* I'll include them.
* Wait, actually, to be safest with "strictly", I'll include them.
* Wait, let's refine the code to be very clear.
* `data = {...}`
* `def search(...):`
* `if __name__...`
* Okay.
* Wait, I'll check if the prompt implies I should *find* a match in *my* context.
* No, "If match found return...". It's a generic rule.
* Okay.
* Wait, I'll finalize the code.
* Wait, I should ensure the code returns *the* description.
* `return data[key]`.
* Okay.
* Wait, one last check: "若未找到则返回默认提示或None".
* `return "默认提示"`.
* Okay.
* Wait, I'll output now.
```python
def find_match(keyword, data_dict):
if keyword in data_dict:
return data_dict[keyword]
else:
return "默认提示"
# 示例数据与执行
data = {"apple": "苹果的描述", "banana": "香蕉的描述"}
result = find_match("apple", data)
print(result if result else None)
```