数据类型、流程控制和函数：用 Python 表达完整需求

数据类型：信息用什么形式表示
流程控制：代码接下来走哪条路
函数：一段逻辑如何被命名和复用

原始文档 -> 筛选相关文档 -> 拼接上下文 -> 得到 Prompt

top_k_text = "3"
top_k = int(top_k_text)

document_count = 10
success_rate = 0.86

print(document_count + 2)       # 12
print(document_count // 3)      # 3
print(document_count % 3)       # 1
print(round(success_rate, 1))   # 0.9

import math

result = 0.1 + 0.2
print(result)  # 0.30000000000000004
print(math.isclose(result, 0.3))  # True

answer = None

if answer is None:
    print("暂时没有模型回答")

text = "Python AI"

print(text[0])     # P
print(text[-1])    # I
print(text[0:6])   # Python
print(text[:6])    # Python
print(text[7:])    # AI

raw_question = "  Python 如何处理文本？\n"
question = raw_question.strip()

print(question.lower())
print(question.replace("Python", "Python 3"))
print(question.startswith("Python"))
print("文本" in question)

tags = "python,rag,agent".split(",")
tag_text = " | ".join(tags)

print(tags)
print(tag_text)

document = {
    "title": "虚拟环境",
    "content": "虚拟环境用于隔离项目依赖。",
}

documents = ["python.md", "rag.md"]

documents.append("agent.md")
documents.insert(1, "linux.md")
documents[0] = "python-basics.md"
removed = documents.pop()

print(documents)
print(removed)

print(documents[0])
print(documents[:2])
print("rag.md" in documents)
print(len(documents))

model_config = ("demo-model", 0.2, 512)
model_name, temperature, max_tokens = model_config

single_item = ("python",)

source_tags = {"python", "rag", "python"}
required_tags = {"python", "agent"}

print(source_tags)                    # 重复项被去除
print(source_tags & required_tags)    # 交集
print(source_tags | required_tags)    # 并集
print(required_tags - source_tags)    # 差集

document = {
    "title": "Python 基础",
    "content": "变量用于给对象绑定名称。",
}

print(document["title"])
print(document.get("source", "unknown"))

document["source"] = "local"
document["title"] = "Python 变量"
removed_content = document.pop("content")

for key, value in document.items():
    print(f"{key}={value}")

original = ["python"]
alias = original
copy_items = original.copy()

alias.append("rag")

print(original)    # ['python', 'rag']
print(copy_items)  # ['python']

import copy

original = [{"title": "Python", "tags": ["basic"]}]
shallow = original.copy()
deep = copy.deepcopy(original)

shallow[0]["tags"].append("syntax")

print(original[0]["tags"])  # ['basic', 'syntax']
print(deep[0]["tags"])      # ['basic']

raw_texts = [" Python ", "", " RAG "]
cleaned_texts = [text.strip() for text in raw_texts if text.strip()]

print(cleaned_texts)  # ['Python', 'RAG']

要放入结果的值
for 当前元素 in 原始数据
if 可选过滤条件

tags = ["Python", "python", "RAG"]
normalized_tags = {tag.lower() for tag in tags}

scores = [0.9, 0.7]
score_map = {index: score for index, score in enumerate(scores, start=1)}

titles = ["Python", "RAG"]
contents = ["Python 基础", "检索增强生成"]

documents = [
    {"title": title, "content": content}
    for title, content in zip(titles, contents)
]

pairs = list(zip(titles, contents, strict=True))

documents = [
    {"title": "Python", "score": 0.8},
    {"title": "RAG", "score": 0.95},
]

ranked = sorted(
    documents,
    key=lambda item: item["score"],
    reverse=True,
)

if question.strip():
    print("开始处理")
else:
    print("问题不能为空")

score = 0.82

if score >= 0.9:
    level = "high"
elif score >= 0.7:
    level = "medium"
else:
    level = "low"

status = "有结果" if score > 0 else "无结果"

command = "search"

match command:
    case "search":
        action = "执行检索"
    case "summarize":
        action = "生成摘要"
    case _:
        action = "未知命令"

for document in documents:
    print(document["title"])

for index in range(1, 4):
    print(index)  # 1、2、3

documents = ["python.md", "rag.md"]

for index, name in enumerate(documents, start=1):
    print(f"第 {index} 篇：{name}")

results = ["", "Python 基础", "RAG 原理", "Agent 设计"]

for result in results:
    if not result:
        continue
    if result == "RAG 原理":
        print("找到目标")
        break

retry_count = 0
max_retries = 3

while retry_count < max_retries:
    retry_count += 1
    print(f"第 {retry_count} 次尝试")

def normalize_question(question: str) -> str:
    return question.strip()

def build_message(role: str, content: str) -> dict[str, str]:
    return {"role": role, "content": content}


user_message = build_message("user", "什么是 RAG？")
system_message = build_message(
    role="system",
    content="请根据资料回答。",
)

def truncate_text(text: str, limit: int = 100) -> str:
    return text[:limit]

def merge_contexts(*contexts: str, separator: str = "\n") -> str:
    return separator.join(contexts)


def create_config(**options: object) -> dict[str, object]:
    return options


context = merge_contexts("资料一", "资料二", separator="\n---\n")
config = create_config(model="demo-model", temperature=0.2)

def build_message(role: str, content: str) -> dict[str, str]:
    return {"role": role, "content": content}


position_values = ("user", "什么是 Python？")
keyword_values = {"role": "system", "content": "请简洁回答。"}

user_message = build_message(*position_values)
system_message = build_message(**keyword_values)

def search_documents(
    question: str,
    *,
    limit: int = 3,
    min_score: float = 0.0,
) -> list[str]:
    return [f"{question} | limit={limit} | min_score={min_score}"]


results = search_documents(
    "Python 环境",
    limit=5,
    min_score=0.7,
)

DEFAULT_LIMIT = 3


def select_items(items: list[str]) -> list[str]:
    selected = items[:DEFAULT_LIMIT]
    return selected

def build_counter():
    count = 0

    def increase() -> int:
        nonlocal count
        count += 1
        return count

    return increase


counter = build_counter()
print(counter())  # 1
print(counter())  # 2

def normalize_question(question: str) -> str:
    """去掉问题首尾空白，返回清洗后的字符串。"""
    return question.strip()

def select_documents(
    question: str,
    documents: list[dict[str, str]],
    limit: int = 2,
) -> list[dict[str, str]]:
    keywords = set(question.lower().split())
    selected = []

    for document in documents:
        content = document["content"].lower()
        if any(keyword in content for keyword in keywords):
            selected.append(document)

        if len(selected) >= limit:
            break

    return selected


def build_prompt(question: str, documents: list[dict[str, str]]) -> str:
    clean_question = question.strip()
    if not clean_question:
        raise ValueError("问题不能为空")

    selected = select_documents(clean_question, documents)
    if not selected:
        context = "没有找到相关资料。"
    else:
        context = "\n".join(
            f"[{item['title']}] {item['content']}" for item in selected
        )

    return f"请只根据上下文回答。\n\n上下文：\n{context}\n\n问题：{clean_question}"


documents = [
    {"title": "虚拟环境", "content": "venv 可以隔离不同项目的 Python 依赖。"},
    {"title": "文件编码", "content": "读取文本文件时应明确使用 UTF-8 编码。"},
    {"title": "异常处理", "content": "异常处理用于应对运行期间的可预期失败。"},
]

prompt = build_prompt("venv 如何隔离依赖", documents)
print(prompt)

def wrong_add(a: int, b: int) -> None:
    print(a + b)


result = wrong_add(1, 2)
print(result)  # None

messages = ["你好"]
backup = messages
backup.append("请介绍 Python")

print(messages)  # 两条消息

cleaned = [text for text in texts if text.strip()]

def add_message(message: str, history: list[str] = []):
    history.append(message)
    return history