Python 综合练习：从“能运行”到“结果可信”

语法错误：代码无法被解析
运行错误：类型、索引、键或文件操作失败
逻辑错误：程序能运行，但结果不符合需求
设计问题：结果暂时正确，但代码很难修改和复用

temperature = 2.5
max_tokens = 0

temperature 必须在 0 到 2 之间
max_tokens 必须在 1 到 8192 之间

temperature = 2.5
max_tokens = 0
errors = []

if not 0 <= temperature <= 2:
    errors.append("temperature 必须在 0 到 2 之间")

if not 1 <= max_tokens <= 8192:
    errors.append("max_tokens 必须在 1 到 8192 之间")

if errors:
    for error in errors:
        print(error)
else:
    print("参数有效")

request_results = [False, False, True]

for attempt, success in enumerate(request_results, start=1):
    print(f"第 {attempt} 次请求")

    if success:
        print("请求成功")
        break

    print("请求失败，准备重试")
else:
    print("达到最大重试次数")

text = "Python helps AI, and Python helps automation."
punctuation = ",.!?"
counts: dict[str, int] = {}

for raw_word in text.lower().split():
    word = raw_word.strip(punctuation)
    if not word:
        continue
    counts[word] = counts.get(word, 0) + 1

sorted_counts = sorted(
    counts.items(),
    key=lambda item: item[1],
    reverse=True,
)

for word, count in sorted_counts:
    print(word, count)

def split_text(text: str, chunk_size: int, overlap: int = 0) -> list[str]:
    if chunk_size <= 0:
        raise ValueError("chunk_size 必须大于 0")
    if overlap < 0:
        raise ValueError("overlap 不能小于 0")
    if overlap >= chunk_size:
        raise ValueError("overlap 必须小于 chunk_size")

    step = chunk_size - overlap
    return [
        text[start:start + chunk_size]
        for start in range(0, len(text), step)
    ]


print(split_text("ABCDEFGHIJ", chunk_size=4, overlap=1))

['ABCD', 'DEFG', 'GHIJ', 'J']

def split_text(text: str, chunk_size: int, overlap: int = 0) -> list[str]:
    if chunk_size <= 0:
        raise ValueError("chunk_size 必须大于 0")
    if overlap < 0 or overlap >= chunk_size:
        raise ValueError("overlap 必须在 0 到 chunk_size - 1 之间")

    chunks = []
    start = 0

    while start < len(text):
        end = min(start + chunk_size, len(text))
        chunks.append(text[start:end])
        if end == len(text):
            break
        start = end - overlap

    return chunks


print(split_text("ABCDEFGHIJ", chunk_size=4, overlap=1))

['ABCD', 'DEFG', 'GHIJ']

from pathlib import Path


def count_non_empty_lines(path: Path) -> int:
    with path.open("r", encoding="utf-8") as file:
        return sum(1 for line in file if line.strip())


def scan_text_files(directory: Path) -> tuple[dict[str, int], list[str]]:
    if not directory.is_dir():
        raise NotADirectoryError(directory)

    counts = {}
    errors = []

    for path in sorted(directory.glob("*.txt")):
        try:
            counts[path.name] = count_non_empty_lines(path)
        except (OSError, UnicodeDecodeError) as error:
            errors.append(f"{path.name}: {error}")

    return counts, errors

raw_documents = [
    {"title": " Python 环境 ", "content": " venv 用于隔离项目依赖。 "},
    {"title": "文件编码", "content": "UTF-8 能把 Unicode 字符编码成字节。"},
    {"title": "Python 环境", "content": "重复文档不应再次进入知识库。"},
    {"title": "空文档", "content": "   "},
    "这不是一条字典记录",
]

from dataclasses import dataclass
from typing import Any


@dataclass(frozen=True)
class Document:
    title: str
    content: str


@dataclass(frozen=True)
class Chunk:
    chunk_id: str
    title: str
    content: str


def clean_documents(raw_items: list[Any]) -> tuple[list[Document], list[str]]:
    documents = []
    errors = []
    seen_titles = set()

    for index, item in enumerate(raw_items, start=1):
        if not isinstance(item, dict):
            errors.append(f"第 {index} 条不是字典")
            continue

        title = str(item.get("title", "")).strip()
        content = str(item.get("content", "")).strip()

        if not title or not content:
            errors.append(f"第 {index} 条标题或正文为空")
            continue

        if title in seen_titles:
            errors.append(f"第 {index} 条标题重复：{title}")
            continue

        seen_titles.add(title)
        documents.append(Document(title=title, content=content))

    return documents, errors


def split_documents(documents: list[Document], chunk_size: int) -> list[Chunk]:
    if chunk_size <= 0:
        raise ValueError("chunk_size 必须大于 0")

    chunks = []
    for document_index, document in enumerate(documents, start=1):
        parts = [
            document.content[start:start + chunk_size]
            for start in range(0, len(document.content), chunk_size)
        ]

        for chunk_index, part in enumerate(parts, start=1):
            chunk_id = f"doc-{document_index:03d}-chunk-{chunk_index:03d}"
            chunks.append(
                Chunk(
                    chunk_id=chunk_id,
                    title=document.title,
                    content=part,
                )
            )

    return chunks


raw_documents = [
    {"title": " Python 环境 ", "content": " venv 用于隔离项目依赖。 "},
    {"title": "文件编码", "content": "UTF-8 能把 Unicode 字符编码成字节。"},
    {"title": "Python 环境", "content": "重复文档不应再次进入知识库。"},
    {"title": "空文档", "content": "   "},
    "这不是一条字典记录",
]

documents, errors = clean_documents(raw_documents)
chunks = split_documents(documents, chunk_size=12)

print(f"有效文档：{len(documents)}")
print(f"生成片段：{len(chunks)}")

for chunk in chunks:
    print(chunk)

for error in errors:
    print(f"跳过：{error}")

text = "abcdefgh"
size = 3

parts = [text[start:start + size] for start in range(0, len(text), size)]
print(parts)  # ['abc', 'def', 'gh']

item["title"] = item["title"].strip()

list = []
id = "doc-001"

def normalize_title(title: str) -> str:
    return title.strip().lower()


assert normalize_title(" Python ") == "python"
assert normalize_title("") == ""
assert normalize_title("  RAG  ") == "rag"

assert split_text("ABCDEFGHIJ", 4, 1) == ["ABCD", "DEFG", "GHIJ"]
assert split_text("ABC", 4, 1) == ["ABC"]
assert split_text("", 4, 1) == []

try:
    split_text("ABC", chunk_size=3, overlap=3)
except ValueError:
    pass
else:
    raise AssertionError("overlap 非法时应抛出 ValueError")

documents, errors = clean_documents(raw_documents)
chunks = split_documents(documents, chunk_size=12)

assert len(documents) == 2
assert len(errors) == 3
assert chunks[0].chunk_id == "doc-001-chunk-001"
assert all(chunk.content for chunk in chunks)