如何优化Wiktionary Parser返回结果的可读性与结构化？

1. 编写专用数据提取函数，按需筛选核心字段 #

根据你需要展示的信息（如词性、释义、发音、例句），编写针对性提取逻辑，直接过滤冗余内容。以俄语单词处理为例：

from wiktionaryparser import WiktionaryParser

parser = WiktionaryParser()

def extract_core_info(word, lang):
    raw_result = parser.fetch(word, lang)
    processed_data = []
    
    for entry in raw_result:
        entry_info = {
            "词源": entry.get("etymology", "无"),
            "发音": entry.get("pronunciations", {}).get("text", ["无"])[0],
            "释义列表": []
        }
        
        # 提取每个释义项
        for definition in entry.get("definitions", []):
            pos = definition.get("partOfSpeech", "未知词性")
            # 过滤语法说明类文本，只保留纯释义
            pure_meanings = [text for text in definition.get("text", []) 
                             if not text.startswith(("(", "*", "also"))]
            
            # 整理例句（针对俄语原数据的三组重复格式去重）
            refined_examples = []
            seen_pairs = set()
            ex_list = definition.get("examples", [])
            for idx in range(0, len(ex_list), 3):
                if idx + 2 < len(ex_list):
                    original = ex_list[idx].split(".A magnificent")[0] + "."
                    translation = ex_list[idx+2]
                    if (original, translation) not in seen_pairs:
                        refined_examples.append(f"原句：{original}\n译文：{translation}")
                        seen_pairs.add((original, translation))
            
            entry_info["释义列表"].append({
                "词性": pos,
                "含义": pure_meanings,
                "例句": refined_examples[:3]  # 仅保留前3个有效例句
            })
        
        processed_data.append(entry_info)
    return processed_data

# 测试调用
result = extract_core_info("человек", "russian")
for item in result:
    print(f"词源：{item['词源']}")
    print(f"发音：{item['发音']}")
    for idx, meaning in enumerate(item['释义列表'], 1):
        print(f"\n{idx}. 词性：{meaning['词性']}")
        print("含义：")
        for m in meaning['含义']:
            print(f"  - {m}")
        print("例句：")
        for ex in meaning['例句']:
            print(f"  > {ex}")

2. 递归扁平化嵌套结构 #

如果需要通用处理任意嵌套的字典/列表，可以用递归函数将多层结构转为扁平键值对，方便后续处理：

def flatten_nested_data(data, parent_key="", separator="·"):
    items = []
    if isinstance(data, dict):
        for key, value in data.items():
            new_key = f"{parent_key}{separator}{key}" if parent_key else key
            items.extend(flatten_nested_data(value, new_key, separator))
    elif isinstance(data, list):
        for index, value in enumerate(data):
            new_key = f"{parent_key}{separator}{index}" if parent_key else str(index)
            items.extend(flatten_nested_data(value, new_key, separator))
    else:
        items.append((parent_key, str(data)))
    return items

# 使用示例
raw_data = parser.fetch("человек", "russian")
flattened = flatten_nested_data(raw_data)
# 展示前20条扁平化结果
for key, value in flattened[:20]:
    print(f"{key}: {value}")

3. 用数据类规范结构（适合大型项目） #

用Pydantic定义数据模型，强制规范返回数据的结构，自动处理字段缺失问题：

from pydantic import BaseModel, Field
from typing import List, Optional

class Example(BaseModel):
    original: str
    translation: str

class Definition(BaseModel):
    part_of_speech: str = Field(alias="partOfSpeech")
    meanings: List[str] = Field(alias="text")
    examples: List[Example] = []

class Pronunciation(BaseModel):
    text: List[str]
    audio: List[str]

class WiktionaryEntry(BaseModel):
    etymology: Optional[str]
    definitions: List[Definition]
    pronunciations: Pronunciation

def parse_to_model(word, lang):
    raw_data = parser.fetch(word, lang)
    model_entries = []
    
    for entry in raw_data:
        processed_defs = []
        for d in entry["definitions"]:
            # 转换例句格式
            ex_pairs = []
            ex_list = d.get("examples", [])
            for i in range(0, len(ex_list), 3):
                if i + 2 < len(ex_list):
                    ex_pairs.append(Example(original=ex_list[i], translation=ex_list[i+2]))
            processed_defs.append(Definition(**d, examples=ex_pairs))
        
        model_entries.append(WiktionaryEntry(
            etymology=entry.get("etymology"),
            definitions=processed_defs,
            pronunciations=Pronunciation(**entry["pronunciations"])
        ))
    return model_entries

# 测试调用
model_result = parse_to_model("человек", "russian")
for entry in model_result:
    print(f"词源：{entry.etymology}")
    print(f"发音：{entry.pronunciations.text[0]}")
    for idx, def_item in enumerate(entry.definitions, 1):
        print(f"\n{idx}. 词性：{def_item.part_of_speech}")
        print("含义：")
        for m in def_item.meanings:
            print(f"  - {m}")
        print("例句：")
        for ex in def_item.examples[:2]:
            print(f"  原句：{ex.original}")
            print(f"  译文：{ex.translation}")

实用提示 #

• 不同语言的返回格式存在细微差异（比如英语例句格式和俄语不同），需要针对目标语言做适配
• 必须添加异常处理，避免因字段缺失导致程序崩溃
• 若仅需特定信息（如仅释义），直接跳过无关字段，无需遍历整个嵌套结构

内容的提问来源于stack exchange，提问作者diddy sideburns