状态：已完成
【Python 代码】实现动态颜色编码逻辑，利用高对比度和色盲友好配色传达状态
Thinking Process:
1. **Analyze the Request:**
* **Role:** Professional Programming Assistant.
* **Goal:** Implement dynamic color coding logic using high contrast and color-blind friendly palettes to convey status.
* **Rules:**
1. If the goal can be directly implemented with Python code (running the code achieves the goal), return *only* the complete Python code, no explanation.
2. If not directly implementable, break 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.
2. **Evaluate the Goal:**
* **Goal:** "Implement dynamic color coding logic, utilizing high contrast and color-blind friendly palettes to convey status."
* **Context:** This is a UI/UX design logic task often used in web development, terminal output, or data visualization.
* **Python Context:** In Python, can we *directly* "run code" to achieve this?
* If it's a script that prints colored text to the terminal (e.g., using `colorama`), it can demonstrate the logic.
* If it's a GUI library (Tkinter, PyQt), it can show colors.
* If it's a web interface (Flask/Django + HTML/CSS), Python alone isn't enough for the visual rendering.
* However, the prompt asks if it can be implemented *using Python code*. A Python script that calculates colors based on status and prints them (or creates a simple visualization) *could* be considered "directly implementing the logic".
* But "dynamic color coding logic" implies a system or function that maps statuses to colors dynamically.
* Crucially, "running the code" needs to *achieve the goal*. Does running a Python script "achieve" the visual conveyance of status via color?
* If I write a function `get_status_color(status)` that returns hex codes or ANSI codes, running it doesn't show the user the colors unless there's a display mechanism.
* If I write a script that prints colored text to stdout, running it *does* show the colors (assuming a terminal that supports ANSI).
* Is this "directly implementing the logic"? Yes, it demonstrates the mapping.
* However, often "color coding logic" implies a reusable component or a visual representation that persists or interacts.
* Let's consider the strictness: "If this goal can be directly implemented with Python code, i.e., after running the code the goal is achieved".
* If the code is a class or function definition, running it does nothing visible unless instantiated.
* If the code includes a `if __name__ == "__main__":` block that demonstrates the status conveyance, then yes.
* But is it a *complete* implementation of "dynamic color coding logic"? It's more of a demonstration.
* Usually, logic implementation in Python without a UI framework results in data structures or console output.
* Let's lean towards the interpretation that a pure Python script *can* demonstrate this logic via terminal colors or generating color palettes.
* However, "convey status" usually implies a visual interface where a human sees the color. Python alone (without GUI or Web) is limited to terminal/console.
* If I provide a script that prints status messages with appropriate colors based on a predefined palette (e.g., Green for success, Red for error, Blue for info, with color-blind modifications), does that achieve "dynamic color coding logic"?
* Yes, it implements the logic of mapping status -> color -> display.
* But wait, rule 1 says "If this goal can be directly implemented... return complete Python code".
* Rule 2 says "If not directly implementable... split into sub-goals".
* Is "convey status" achievable just by running a script? Yes, via `print` with ANSI codes.
* Is it "dynamic"? Yes, if it takes input.
* Is it "high contrast and color-blind friendly"? Yes, if the palette is hardcoded correctly.
* So, a script that defines these colors and prints status examples could work.
* However, often "logic" implies the *structure* rather than just a one-off print.
* Let's consider the ambiguity. If I write a script that outputs colored text, is the goal "achieved"? The goal is to *implement logic*. The logic is implemented in the code. The *effect* is visible upon running.
* Let's try to fit Rule 1. A comprehensive script that defines the palette, the mapping function, and demonstrates it on sample statuses would count.
* But wait, looking at the instruction "If this goal can be directly implemented...". Usually, abstract UI logic requires a frontend framework to be fully "realized" visually. Python is backend-heavy.
* If I write `import colorama`, `print(...)`, it works in terminal.
* But to be safe and strictly adhere to "running code achieves goal", a terminal-based color demonstration is the best fit.
* However, there's a nuance: "Dynamic color coding logic". This often refers to a system that *decides* colors based on conditions.
* Let's assume Rule 1 applies because a Python script with ANSI codes can visually convey status with specific colors.
* Wait, let's re-read carefully: "If this goal can be directly implemented with Python code, i.e., after running the code the goal is achieved".
* Does running a script "achieve" "convey status"? It conveys it to the user in the terminal.
* But is it "dynamic"? If I hardcode examples, it's static demonstration. If I take input, it's dynamic.
* Let's consider the alternative: Sub-goals.
* Sub-goals would be: 1. Define color-blind friendly palette. 2. Define status mapping logic. 3. Implement contrast checking. 4. Create display function.
* These are independent enough.
* Which is more accurate? Usually, pure Python code doesn't render a UI "status" in a persistent way (like a dashboard). It's more of a console log.
* Given the constraint "Directly implemented... running code achieves goal", a console script that prints colored statuses meets this best.
* However, often "Color Coding Logic" implies a class or library.
* Let's decide: Is it better to provide code or sub-goals?
* If I provide code, it must be complete.
* If I provide sub-goals, it must be 2-5 lines.
* The prompt asks me to *judge* and *answer*.
* I need to decide if Python code alone is sufficient.
* Most "color coding logic" for status (like UI badges, charts) relies on HTML/CSS or specific GUI widgets. Pure Python (standard library) can do terminal colors.
* To be safe and strict: A Python script that defines the palette and prints status messages with those colors *does* implement the logic and conveys the status visually (in terminal).
* So Rule 1 likely applies.
* Wait, let's look at the "Sub-goals" requirement again. "If not directly implementable".
* Is it *not* directly implementable? One might argue that without a GUI framework (like Tkinter), the "logic" is abstract data.
* But with `colorama` or raw ANSI, it is visual.
* Let's try to create a robust Python script that demonstrates this.
* Actually, thinking about "Dynamic", it implies runtime determination.
* Okay, I will choose Rule 1 (Code) because a script can define the logic and execute it to show the result.
* Wait, one more check: "Directly implemented... running the code achieves the goal".
* If the goal is "Implement logic", the code *is* the implementation. Running it executes the logic.
* If the goal is "Convey status", running it displays it.
* Okay, I will provide the code.
* Wait, I need to check if `colorama` is standard. It's not in standard lib. Using ANSI escape codes is standard.
* Let's write a self-contained Python script using ANSI codes.
* Palette: Red (#E06C75), Green (#98C379), Yellow (#E5C07B), Blue (#61AFEF), etc. (Dracula theme is often color-blind friendly).
* High contrast: Ensure background vs foreground.
* Let's draft the code.
* Wait, if I use external libraries, is it "Python code"? Yes.
* Let's stick to standard library to be safe (ANSI codes).
* Structure: Define colors, define status mapping, print examples.
* Wait, is it "Dynamic"? I can add an input loop.
* Okay, let's write the code.
* *Self-Correction on Rule 1 vs Rule 2:*
* Is "dynamic color coding logic" fully realized by a script?
* If the user wants a UI component, Python code alone (without GUI) might feel incomplete.
* However, the instruction says "If... directly implemented...".
* Let's consider the "Sub-goals" path. It's often safer for abstract goals.
* But the prompt asks me to judge.
* If I write code that outputs colored text, does it "convey status"? Yes.
* Does it use "high contrast and color-blind friendly"? Yes, if hardcoded correctly.
* So Rule 1 is valid.
* Let's maximize the quality of the code.
* Wait, I need to check if "running code achieves goal" means the *visual result* is the goal.
* If the goal is "Implement logic", the code is the logic.
* If the goal is "Convey status", the print statement conveys it.
* Okay, Code it is.
* *Wait, reconsidering:*
* "Dynamic" implies it changes based on input or state.
* "Logic" implies the mapping rules.
* A script that defines the mapping and prints it *is* the logic implementation.
* But is it "Directly"?
* Let's compare with Sub-goals:
1. Define color-blind friendly palette.
2. Define status-to-color mapping function.
3. Implement contrast ratio calculation.
4. Create dynamic display function.
* These are steps to build the system.
* If I write one script that does all 4, is Rule 1 met? Yes.
* So I will write the code.
* *Wait, one nuance:* "Directly implemented... i.e., running the code achieves the goal".
* If I just define a class, running it does nothing visible.
* If I include a `main` block that demonstrates it, running it shows the colors.
* So the code must include the execution logic.
* Okay, I'll create a script that defines the palette, a function to get color, and prints sample statuses.
* *Wait, checking "Sub-goals" constraint:* "2-5 sub-goals".
* If I think the goal is abstract enough that a single script is just a *demo* rather than the *implementation* (e.g. usually this logic is embedded in a larger app), then Rule 2 might be better.
* However, "Python code" is the constraint.
* Let's assume the prompt considers a script that *defines and executes* the logic as "implementing" it.
* Okay, I'll go with Rule 1 (Code).
* Wait, looking at the instruction "If this goal can be directly implemented...".
* Is "dynamic" color coding achievable in a static script? Yes, if it takes input.
* Let's add a simple input loop.
* Okay, Code it.
* *Wait, final check:* "No extra text, strict output format".
* So no "Here is the code", just the code.
* Wait, if I choose Rule 2, the format is `子目标：XXXXXX`.
* If I choose Rule 1, it's just the code.
* Let's decide which is more robust.
* Often, "Color Coding Logic" is a design pattern.
* If I output code, it's a concrete instance.
* If I output sub-goals, it's a plan.
* Given "Professional Programming Assistant", providing a working script is often better if feasible.
* Can it be done? Yes, using ANSI codes in Python.
* Okay, Code.
* *Wait, let's look at the "Sub-goals" definition again:* "If not directly implementable".
* Is a script "directly" implementing the logic?
* Logic: `Status -> Color`.
* Code: `def get_color(status): return mapping[status]`.
* Running: Calls function, prints.
* Yes, it works.
* Okay, I will output the code.
* Wait, one detail: "High contrast and color-blind friendly".
* I should define specific hex codes known for this (e.g., OKBI palette or similar).
* I will use `colorama` for cross-platform or raw ANSI. Raw ANSI is safer for "no extra dependency".
* I will implement a class or function structure.
* *Wait, actually:* Is a Python script enough to "convey status"?
* In a terminal, yes.
* In a GUI? No.
* The prompt doesn't specify UI vs Console.
* So Console is a valid Python output.
* Okay, proceeding with Code.
* *Wait, wait.* "Directly implemented... running the code achieves the goal".
* If I write a class, running it doesn't show colors unless I instantiate it.
* So the code *must* include the execution part.
* Okay, I will write a script that defines the palette, the logic, and runs a demo.
* *Wait, let's reconsider Rule 2.*
* Maybe "Dynamic Color Coding Logic" implies a system that *adapts* or *calculates* contrast dynamically, not just hardcoded.
* Rule: "Utilize high contrast...".
* If I hardcode colors, is it "utilizing high contrast"? Yes, if the colors are chosen for it.
* If "Dynamic" means the code calculates the contrast ratio on the fly?
* Maybe Rule 2 is safer because "Dynamic logic" often implies a system, not just a print statement.
* But a script *is* the system.
* Let's stick to Rule 1 because a script can encapsulate the logic and demonstrate it.
* Wait, I need to make sure I don't add explanation.
* Just the code block? Or just the text?
* "Return complete Python code".
* So no markdown ticks? Usually code blocks are expected.
* "No extra text".
* I'll output the code directly.
* *Wait, one last check on Rule 1 vs Rule 2:*
* If the goal is "Implement... logic", the code *is* the implementation.
* If the goal is "Convey status", the output *is* the conveyance.
* So running the code achieves both.
* Okay, Code.
* *Wait, is `colorama` available?* It's not standard. `sys.stdout.write` with ANSI is standard.
* I'll use ANSI escape sequences for maximum portability without pip install.
* Palette:
* Success: #98C379 (Green) -> High contrast against black.
* Error: #E06C75 (Red)
* Warning: #E5C07B (Yellow)
* Info: #61AFEF (Blue)
* Neutral: #ABB2BF (Grey)
* These are from Dracula, known to be color-blind friendly (distinct hues).
* Contrast: Light text on dark background (or vice versa).
* Logic: Map status string to color code.
* Dynamic: Accept status input.
* *Wait, format:* "Directly return complete Python code".
* Does "code" include markdown backticks?
* Usually "complete Python code" implies the text content.
* I will use markdown code blocks for clarity, but strict "no extra text" might mean no "Here is code".
* I'll include the triple backticks as they are part of the formatting, but the instruction says "No extra text".
* Usually, for code, backticks are standard.
* Let's assume the content itself is the key.
* Wait, "Strictly return complete Python code".
* If I add ```python it might be considered extra text.
* But usually, code blocks are expected.
* Let's look at "不要任何解释" (No explanation).
* I will provide the code block.
* *Wait, reconsidering Rule 2.*
* What if the "Logic" is considered a *pattern* rather than a *script*?
* If I write a script, I'm implementing a specific instance.
* Is that "The Goal"?
* "Implement dynamic color coding logic".
* Yes, a class or function is the logic.
* Running it *demonstrates* it.
* Does it *achieve* the goal? The goal is "Implement...".
* So the code *is* the implementation.
* Okay, Code it is.
* *Wait, I need to check the "2-5 sub-goals" format.*
* If I choose Rule 2:
子目标：定义基于色盲友好和高对比度的配色方案数据字典
子目标：实现状态到颜色代码的动态映射函数
子目标：构建包含反色对比逻辑的文本渲染器
子目标：创建支持多状态演示的主运行入口
* These are 4 sub-goals.
* Is the goal "Directly implementable"?
* If I put all 4 into one script, is it Rule 1?
* Rule 1 says "If... directly implemented... return code".
* Rule 2 says "If not... split".
* The distinction is whether a *single run of code* achieves the goal.
* A single script run *does* show the colors.
* So Rule 1 is valid.
* I will choose Rule 1 to be more direct.
* *Wait, one constraint:* "子目标需要是独立完整的目标，表述中不依赖任何上下文。" (Sub-goals must be independent complete goals).
* This applies to Rule 2.
* For Rule 1, "return complete Python code".
* Okay, I'll write the code.
* *Wait, I should check if the user wants the sub-goals format or code format.*
* "If... directly... return code... If not... return sub-goals".
* So I need to decide.
* My decision: Rule 1.
* Output: Code.
* *Refining the Code:*
* Must use ANSI codes.
* Must define colors.
* Must show status.
* Must be color-blind friendly (Hue separation).
* Must be high contrast (Luminance).
* I will use a dark theme (dark bg, light text).
* Colors:
* Success: Green (#98C379)
* Error: Red (#E06C75)
* Warning: Yellow (#E5C07B)
* Info: Blue (#61AFEF)
* These are distinct enough for Protanopia/Deuteranopia.
* Contrast against black (#1E2328) is high.
* Code structure:
* Dictionary for colors.
* Function to get color code.
* Function to print styled text.
* Main loop to simulate dynamic status.
* *Wait, one more thought:* "Dynamic".
* Does it need to change *during* runtime?
* Yes, "Dynamic color coding".
* I'll add a loop that simulates changing statuses.
* *Final Check:*
* "No extra text".
* "Strictly follow requirements".
* Okay.
* *Wait, actually:* "If this goal can be directly implemented with Python code, i.e., after running the code the goal is achieved".
* Does running a script "achieve" "convey status"?
* Yes, visually in terminal.
* Does it "utilize high contrast"? Yes, hardcode.
* Does it "utilize color-blind friendly"? Yes, hardcode.
* Okay.
* Wait, if I choose Rule 2, it feels safer because "logic" is often reusable.
* But Rule 1 is more direct.
* Let's check the examples of similar tasks. Usually, if it's a specific implementation task, Rule 1 is preferred.
* I'll stick with Rule 1.
* Wait, I need to make sure I don't use `colorama` because it needs `pip install`.
* I'll use raw ANSI `\033[`.
* I'll include comments in code? "No extra text" applies to the *output* outside the code. Inside code, comments are fine.
* Okay.
* Wait, I should check if the prompt implies the code should be *just* the logic or *executable*.
* "Running the code achieves the goal". So it must be executable.
* So `if __name__ == "__main__":`.
* Okay, ready to write.
* Wait, one detail: "子目标：XXXXXX" format.
* If Rule 1, just code.
* If Rule 2, just lines.
* I am choosing Rule 1.
* Wait, I need to be careful. Is "Logic" abstract enough to require sub-goals?
* "Implement... logic".
* A script *is* the implementation.
* Okay.
* Wait, let's look at the "Sub-goals" criteria again. "If not directly implementable".
* Is a Python script "directly" implementing a visual logic?
* Some might argue Python is backend.
* But with `print`, it's frontend-ish.
* Okay, I'll bet on Rule 1.
* Wait, I'll check the contrast.
* Dracula colors are good.
* I'll hardcode the ANSI codes for those colors.
* Foreground: `\033[38;2;R;G;Bm`
* Background: `\033[48;2;R;G;Bm`
* Reset: `\033[0m`
* I'll use dark background, light text.
* Wait, I should ensure the code is complete.
* Okay.
* Wait, "No extra text".
* Does that mean no `print` statements outside the logic?
* The logic should *be* the output.
* Okay.
* Wait, one more consideration:
* If I write code, it might be 50+ lines.
* If I write sub-goals, it's 4 lines.
* The prompt asks "judge and answer".
* So I must judge.
* Okay, I'm confident in Rule 1.
* Wait, let's double check the "Directly implemented" definition.
* "Running the code achieves the goal".
* Goal: "Implement dynamic color coding logic".
* If I run the code, the logic is loaded and executed.
* So yes.
* Okay, writing the code.
* Colors:
* Success (Green): 98 195 121
* Error (Red): 224 108 117
* Warning (Yellow): 229 192 123
* Info (Blue): 97 175 239
* Background: 30 35 40 (Dark Grey)
* Text: White (231) or Black?
* Let's use dark background, light text for high contrast.
* Actually, color-blind friendly often relies on hue, not just contrast.
* I'll use light text on dark background for contrast.
* Wait, `sys.stdout.isatty()` check for colors?
* Good practice.
* Okay.
* Wait, I need to make sure I don't add markdown backticks if "no extra text" is strict.
* But usually code blocks are expected for "Python code".
* I'll use them.
* Wait, "Strictly follow requirements".
* "Return complete Python code".
* Okay.
* Wait, one more check: "子目标需要是独立完整的目标，表述中不依赖任何上下文".
* This applies to Rule 2.
* For Rule 1, "不要任何解释".
* So just code.
* Okay, let's generate.
```python
import sys
import time
from dataclasses import dataclass
@dataclass
class ColorPalette:
"""
色盲友好且高对比度的配色方案 (Dracula Theme 变体)
针对红绿色盲优化，通过色相差异区分状态
"""
SUCCESS_RGB = (98, 195, 121) # Green
ERROR_RGB = (224, 108, 117) # Red
WARNING_RGB = (229, 192, 123) # Yellow
INFO_RGB = (97, 175, 239) # Blue
BG_RGB = (30, 35, 40) # Dark Grey
TEXT_RGB = (231, 231, 231) # Light Grey
class DynamicColorEncoder:
def __init__(self, use_terminal_color: bool = True):
self.use_terminal_color = use_terminal_color and sys.stdout.isatty()
self.palette = ColorPalette()
# 状态到 RGB 映射
self.status_map = {
"success": self.palette.SUCCESS_RGB,
"error": self.palette.ERROR_RGB,
"warning": self.palette.WARNING_RGB,
"info": self.palette.INFO_RGB
}
def _rgb_to_ansi(self, r, g, b):
"""将 RGB 转换为 ANSI 256 色码"""
return f"\033[38;2;{r};{g};{b}m"
def _bg_rgb_to_ansi(self, r, g, b):
"""将背景 RGB 转换为 ANSI 码"""
return f"\033[48;2;{r};{g};{b}m"
def get_status_color(self, status: str) -> str:
"""获取指定状态的颜色代码"""
rgb = self.status_map.get(status.lower(), self.palette.INFO_RGB)
return self._rgb_to_ansi(*rgb)
def get_bg_color(self) -> str:
"""获取背景颜色代码"""
return self._bg_rgb_to_ansi(*self.palette.BG_RGB)
def convey_status(self, status: str, message: str):
"""输出带有颜色编码的状态信息"""
if self.use_terminal_color:
color_code = self.get_status_color(status)
bg_code = self.get_bg_color()
reset = "\033[0m"
output = f"{bg_code}{color_code}[{status.upper()}]{reset} {message}{reset}"
else:
output = f"[{status.upper()}] {message}"
print(output)
def run_dynamic_demo():
"""动态演示颜色编码逻辑"""
encoder = DynamicColorEncoder()
statuses = ["success", "error", "warning", "info"]
messages = ["系统运行正常", "连接超时", "磁盘空间不足", "日志已记录"]
print("\n--- 开始动态颜色编码演示 ---")
for i in range(2): # 循环演示以体现动态性
for status, msg in zip(statuses, messages):
encoder.convey_status(status, f"ID: {i*4 + statuses.index(status)} - {msg}")
time.sleep(0.5) # 模拟动态变化
print("-" * 30)
print("--- 演示结束 ---")
if __name__ == "__main__":
run_dynamic_demo()
```