用 Python 实现名字音形义综合评分算法：音韵、字形、字义多维度评估与权重优化全流程

一、前言

起名是一门综合艺术，一个好名字需要同时满足多个维度的要求：读起来要朗朗上口（音韵），写出来要美观协调（字形），想起来要有美好寓意（字义）。然而，市面上大多数起名工具对名字的评估都停留在单一维度 —— 要么只算五格三才的数理吉凶，要么只查生辰八字的五行补缺，很少有工具能从音、形、义三个维度对名字进行综合量化评估。

笔者在开发 529宝宝起名网 的智能评分引擎时，最初也只实现了五格三才和八字五行的评分，但用户反馈显示，很多数理评分很高的名字，实际读起来拗口、写起来繁琐、寓意也不够好。这说明传统的数理评分并不能全面反映一个名字的质量。为此，我们构建了一套音形义综合评分算法，从音韵和谐度、字形美观度、字义寓意度三个大维度、12 个子指标对名字进行量化评估，并通过用户反馈数据持续优化权重分配。

该算法上线后，名字评分与用户主观满意度的相关性从 0.42 提升到 0.78，高分名字的用户采纳率提升了 45%。本文将完整记录从评分体系设计、各维度算法实现到权重优化和效果验证的全流程。

选择 Python 作为算法实现语言，主要基于以下考虑：pypinyin 库提供完善的拼音转换能力，jieba 分词支持中文语义分析，numpy/scipy 支持高效的数值计算和统计分析，scikit-learn 提供权重优化和模型训练工具，matplotlib 支持评分结果的可视化。相比其他语言，Python 在中文 NLP 和数值计算领域有最完善的生态，非常适合起名评分算法的快速迭代。

本文将涵盖以下内容：

• 评分体系设计与权重分配方法
• 音韵评分算法（拼音声调、音韵和谐、谐音检测）
• 字形评分算法（笔画结构、美观度、生僻字评估）
• 字义评分算法（寓意褒贬、文化内涵、性别适配）
• 综合评分与基于用户反馈的权重优化
• 评分结果验证与对比实验
• 踩过的坑与注意事项

二、评分体系设计与权重分配

2.1 音形义三维度评分框架

我们将名字的综合质量分解为三个大维度，每个维度下又包含若干子指标：

表格

每个子指标的评分范围为 0-100 分，最终综合评分为各子指标加权求和，范围也是 0-100 分。

2.2 评分等级划分

根据综合评分，将名字分为五个等级：

表格

2.3 权重优化方法

初始权重基于起名专家的经验设定，但专家经验不一定符合用户的实际偏好。我们采用 “基于用户反馈的权重迭代优化” 方法：

初始权重（专家经验）
↓
用户评分数据采集（用户对名字的主观评分）
↓
相关性分析（各子指标与用户满意度的相关性）
↓
权重调整（提高高相关性指标权重，降低低相关性指标权重）
↓
A/B测试验证（新旧权重的评分满意度对比）
↓
权重更新（通过验证则更新，否则回滚）
↓
持续迭代（每季度重新采集数据并优化）

# algorithms/weight_optimizer.py
import numpy as np
import pandas as pd
from typing import Dict, List, Tuple
from scipy.optimize import minimize
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

class WeightOptimizer:
"""基于用户反馈的权重优化器"""

def __init__(self, initial_weights: Dict[str, float]):
self.weights = initial_weights.copy()
self.optimization_history = []

def calculate_score(self, sub_scores: Dict[str, float],
weights: Dict[str, float] = None) -> float:
"""根据子指标评分和权重计算综合评分"""
w = weights or self.weights
total_weight = sum(w.values())
score = sum(sub_scores.get(k, 0) * w.get(k, 0) for k in w) / total_weight
return round(score, 1)

def optimize(self, feedback_data: pd.DataFrame) -> Dict:
"""
基于用户反馈数据优化权重
feedback_data: 包含各子指标评分和用户主观满意度的DataFrame
"""
# 分离特征和目标
feature_cols = [c for c in feedback_data.columns if c != "user_satisfaction"]
X = feedback_data[feature_cols].values
y = feedback_data["user_satisfaction"].values

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)

# 初始权重向量
initial_w = np.array([self.weights.get(col, 0.1) for col in feature_cols])

# 目标函数：最小化预测评分与用户满意度的MSE
def objective(w):
# 权重归一化
w_norm = w / w.sum()
predictions = X_train.dot(w_norm)
return mean_squared_error(y_train, predictions)

# 约束：所有权重为正，且和为1
constraints = {"type": "eq", "fun": lambda w: np.sum(w) – 1}
bounds = [(0.01, 0.5) for _ in range(len(feature_cols))]

# 优化
result = minimize(
objective, initial_w, method="SLSQP",
bounds=bounds, constraints=constraints,
options={"maxiter": 1000, "disp": False}
)

# 归一化最优权重
optimal_w = result.x / result.x.sum()
optimal_weights = {col: round(float(w), 4) for col, w in zip(feature_cols, optimal_w)}

# 在测试集上验证
predictions_test = X_test.dot(optimal_w)
mse_new = mean_squared_error(y_test, predictions_test)
r2_new = r2_score(y_test, predictions_test)

# 旧权重在测试集上的表现
old_w = initial_w / initial_w.sum()
predictions_old = X_test.dot(old_w)
mse_old = mean_squared_error(y_test, predictions_old)
r2_old = r2_score(y_test, predictions_old)

# 记录优化历史
self.optimization_history.append({
"timestamp": pd.Timestamp.now().isoformat(),
"sample_size": len(feedback_data),
"old_weights": self.weights.copy(),
"new_weights": optimal_weights,
"old_mse": round(mse_old, 4),
"new_mse": round(mse_new, 4),
"old_r2": round(r2_old, 4),
"new_r2": round(r2_new, 4),
"improvement": round((mse_old – mse_new) / mse_old * 100, 2),
})

return {
"optimal_weights": optimal_weights,
"old_mse": round(mse_old, 4),
"new_mse": round(mse_new, 4),
"old_r2": round(r2_old, 4),
"new_r2": round(r2_new, 4),
"mse_improvement_pct": round((mse_old – mse_new) / mse_old * 100, 2),
"r2_improvement": round(r2_new – r2_old, 4),
}

def apply_weights(self, new_weights: Dict[str, float]):
"""应用新权重"""
self.weights = new_weights.copy()

三、音韵评分算法实现

3.1 拼音与声调分析

音韵评分的基础是准确获取每个字的拼音和声调。我们使用 pypinyin 库，并结合自定义拼音库处理多音字和特殊字：

# algorithms/phonetic_scorer.py
from pypinyin import pinyin, Style, lazy_pinyin
from typing import List, Dict, Tuple
import re

class PhoneticScorer:
"""音韵评分器"""

# 声调分类：1、2声为平声，3、4声为仄声
TONE_CATEGORY = {1: "平", 2: "平", 3: "仄", 4: "仄", 5: "轻声"}

# 韵母分类
FINAL_CATEGORY = {
"开口呼": ["a", "o", "e", "ai", "ei", "ao", "ou", "an", "en", "ang", "eng", "er"],
"齐齿呼": ["i", "ia", "ie", "iao", "iou", "ian", "in", "iang", "ing"],
"合口呼": ["u", "ua", "uo", "uai", "uei", "uan", "uen", "uang", "ueng", "ong"],
"撮口呼": ["ü", "üe", "üan", "ün", "iong"],
}

def __init__(self, char_db_path: str = None):
self.char_db = {} # 多音字特殊处理库
if char_db_path:
self._load_char_db(char_db_path)

def get_pinyin(self, char: str, context: str = None) -> Tuple[str, int]:
"""
获取汉字的拼音和声调
char: 汉字
context: 上下文（用于多音字判断）
返回: (拼音不带声调, 声调1-4)
"""
# 先查自定义多音字库
if char in self.char_db and context:
for reading, conditions in self.char_db[char].items():
if any(cond in context for cond in conditions):
return self._split_pinyin(reading)

# 使用pypinyin获取拼音
result = pinyin(char, style=Style.TONE3, heteronym=False)
if result and result[0]:
py_with_tone = result[0][0]
return self._split_pinyin(py_with_tone)

return "", 0

def _split_pinyin(self, py_with_tone: str) -> Tuple[str, int]:
"""将带声调数字的拼音拆分为拼音和声调"""
match = re.match(r"^([a-zA-Zü]+)(\\d?)$", py_with_tone)
if match:
py = match.group(1)
tone = int(match.group(2)) if match.group(2) else 5
return py, tone
return py_with_tone, 0

def get_name_pinyin(self, name: str) -> List[Dict]:
"""获取完整名字的拼音信息"""
results = []
for i, char in enumerate(name):
context = name[max(0, i-1):i+2] # 前后各取一个字作为上下文
py, tone = self.get_pinyin(char, context)
results.append({
"char": char,
"pinyin": py,
"tone": tone,
"tone_category": self.TONE_CATEGORY.get(tone, "未知"),
"initial": self._get_initial(py),
"final": self._get_final(py),
"final_category": self._get_final_category(py),
})
return results

def _get_initial(self, pinyin: str) -> str:
"""获取声母"""
initials = ["zh", "ch", "sh", "b", "p", "m", "f", "d", "t", "n", "l",
"g", "k", "h", "j", "q", "x", "r", "z", "c", "s", "y", "w"]
for init in initials:
if pinyin.startswith(init):
return init
return "" # 零声母

def _get_final(self, pinyin: str) -> str:
"""获取韵母"""
initial = self._get_initial(pinyin)
return pinyin[len(initial):] if initial else pinyin

def _get_final_category(self, pinyin: str) -> str:
"""获取韵母分类（四呼）"""
final = self._get_final(pinyin)
for category, finals in self.FINAL_CATEGORY.items():
if final in finals:
return category
return "未知"

3.2 音韵和谐度计算

音韵和谐度从声调搭配、韵母和谐、声母搭配三个子维度评估：

def score_phonetic(self, name: str) -> Dict:
"""计算音韵综合评分"""
pinyin_info = self.get_name_pinyin(name)

# 1. 声调搭配评分
tone_score = self._score_tone_pattern(pinyin_info)

# 2. 韵母和谐评分
final_score = self._score_final_harmony(pinyin_info)

# 3. 声母搭配评分
initial_score = self._score_initial_pattern(pinyin_info)

# 4. 谐音歧义检测（扣分制）
homophone_penalty = self._check_homophone(name, pinyin_info)

# 音韵综合评分（声调40% + 韵母30% + 声母30%，再减谐音惩罚）
total = tone_score * 0.4 + final_score * 0.3 + initial_score * 0.3
total = max(0, total – homophone_penalty)

return {
"total_score": round(total, 1),
"tone_score": tone_score,
"final_score": final_score,
"initial_score": initial_score,
"homophone_penalty": homophone_penalty,
"pinyin_info": pinyin_info,
"details": {
"tone_pattern": "".join(p["tone_category"] for p in pinyin_info),
"final_repeat": self._check_final_repeat(pinyin_info),
"initial_repeat": self._check_initial_repeat(pinyin_info),
}
}

def _score_tone_pattern(self, pinyin_info: List[Dict]) -> float:
"""声调搭配评分：平仄交替为佳，连续同声调为差"""
if len(pinyin_info) < 2:
return 85.0 # 单字名默认较高分

tones = [p["tone_category"] for p in pinyin_info]

# 理想模式：平仄平、仄平仄、平仄仄、仄平平（有变化）
# 差模式：平平平、仄仄仄（单调）

# 计算声调变化次数
changes = sum(1 for i in range(1, len(tones)) if tones[i] != tones[i-1])
max_changes = len(tones) – 1
change_ratio = changes / max_changes if max_changes > 0 else 0

# 基础分：变化越多分越高
base_score = 60 + change_ratio * 40

# 惩罚：全平或全仄
if len(set(tones)) == 1:
base_score -= 20

# 奖励：理想的平仄交替模式
ideal_patterns = [["平", "仄", "平"], ["仄", "平", "仄"],
["平", "仄"], ["仄", "平"]]
if tones in ideal_patterns:
base_score += 10

return round(min(100, max(0, base_score)), 1)

def _score_final_harmony(self, pinyin_info: List[Dict]) -> float:
"""韵母和谐评分：避免韵母重复，四呼搭配多样为佳"""
if len(pinyin_info) < 2:
return 85.0

finals = [p["final"] for p in pinyin_info]
final_categories = [p["final_category"] for p in pinyin_info]

score = 85.0

# 惩罚：完全相同的韵母（如"依依"yī yī）
if len(set(finals)) == 1:
score -= 30

# 惩罚：韵母过于相似（如"an"和"ian"）
for i in range(len(finals)):
for j in range(i+1, len(finals)):
if self._finals_similar(finals[i], finals[j]):
score -= 10

# 奖励：四呼搭配多样
category_diversity = len(set(final_categories)) / len(final_categories)
score += category_diversity * 15

return round(min(100, max(0, score)), 1)

def _finals_similar(self, f1: str, f2: str) -> bool:
"""判断两个韵母是否过于相似"""
# 韵尾相同且主元音相近
if f1[-1] == f2[-1] and len(f1) > 1 and len(f2) > 1:
# 检查主元音是否相同
vowels = set("aeiouü")
main_vowel1 = next((c for c in f1 if c in vowels), "")
main_vowel2 = next((c for c in f2 if c in vowels), "")
if main_vowel1 == main_vowel2:
return True
return False

def _score_initial_pattern(self, pinyin_info: List[Dict]) -> float:
"""声母搭配评分：避免声母重复，特别是绕口的组合"""
if len(pinyin_info) < 2:
return 85.0

initials = [p["initial"] for p in pinyin_info]
score = 85.0

# 惩罚：完全相同的声母（如"丽丽"lì lì）
if len(set(initials)) == 1 and initials[0]:
score -= 25

# 惩罚：绕口组合（如zh/ch/sh与z/c/s混用，n/l混用）
confusing_pairs = [
({"zh", "z"}, {"ch", "c"}, {"sh", "s"}),
({"n", "l"},),
({"f", "h"},),
]
for pair_group in confusing_pairs:
pair_set = set()
for s in pair_group:
pair_set.update(s)
if len(set(initials) & pair_set) >= 2:
score -= 15

# 奖励：声母发音部位多样
places = [self._initial_place(init) for init in initials if init]
if len(set(places)) == len(places):
score += 10

return round(min(100, max(0, score)), 1)

def _initial_place(self, initial: str) -> str:
"""获取声母发音部位"""
places = {
"双唇音": ["b", "p", "m"],
"唇齿音": ["f"],
"舌尖前音": ["z", "c", "s"],
"舌尖中音": ["d", "t", "n", "l"],
"舌尖后音": ["zh", "ch", "sh", "r"],
"舌面音": ["j", "q", "x"],
"舌根音": ["g", "k", "h"],
"零声母": ["y", "w", ""],
}
for place, initials in places.items():
if initial in initials:
return place
return "未知"

3.3 谐音与歧义检测

谐音检测是音韵评分中最有价值但也最复杂的部分，需要检测名字是否有不良谐音：

def _check_homophone(self, name: str, pinyin_info: List[Dict]) -> float:
"""
检测谐音歧义，返回惩罚分数（0-40分）
惩罚越多，说明谐音问题越严重
"""
penalty = 0.0

# 1. 整体谐音检测（名字整体读音是否与不良词汇相同或相近）
full_pinyin = " ".join(p["pinyin"] for p in pinyin_info)
for bad_word, bad_pinyin in self.BAD_HOMOPHONES.items():
if self._pinyin_similar(full_pinyin, bad_pinyin):
penalty += 20
break

# 2. 连续字谐音检测（相邻两字是否组成不良词汇）
for i in range(len(pinyin_info) – 1):
two_pinyin = f"{pinyin_info[i]['pinyin']} {pinyin_info[i+1]['pinyin']}"
for bad_word, bad_pinyin in self.BAD_HOMOPHONES.items():
if self._pinyin_similar(two_pinyin, bad_pinyin):
penalty += 15
break

# 3. 单字谐音检测（单字是否与不良字同音）
for p in pinyin_info:
if p["pinyin"] in self.BAD_SINGLE_CHARS:
penalty += 10
break

return min(40, penalty)

def _pinyin_similar(self, py1: str, py2: str) -> bool:
"""判断两个拼音串是否相似（允许声调不同、韵母相近）"""
parts1 = py1.split()
parts2 = py2.split()

if len(parts1) != len(parts2):
return False

match_count = 0
for p1, p2 in zip(parts1, parts2):
# 完全相同
if p1 == p2:
match_count += 1
# 声母相同、韵母相近
elif (self._get_initial(p1) == self._get_initial(p2) and
self._finals_similar(self._get_final(p1), self._get_final(p2))):
match_count += 0.7

return match_count / len(parts1) >= 0.8

# 不良谐音词库（示例，实际应用中需要更完整的词库）
BAD_HOMOPHONES = {
"笨蛋": "ben dan",
"白痴": "bai chi",
"贱人": "jian ren",
"王八蛋": "wang ba dan",
"神经病": "shen jing bing",
"流氓": "liu mang",
"无耻": "wu chi",
"废物": "fei wu",
}

BAD_SINGLE_CHARS = {
"si": "死",
"sha": "杀",
"gui": "鬼",
"chou": "丑",
"e": "恶",
}

该音韵评分算法已应用于在线起名工具的名字评分功能，用户输入名字后可实时查看音韵评分、拼音信息和谐音检测结果，帮助家长避免起出有不良谐音的名字。

四、字形评分算法实现

4.1 笔画数与结构分析

字形评分的基础是准确获取每个字的笔画数和字形结构：

# algorithms/graphic_scorer.py
from typing import List, Dict
import pandas as pd

class GraphicScorer:
"""字形评分器"""

# 字形结构分类
STRUCTURE_TYPES = {
"独体结构": ["一", "乙", "人", "入", "八", "儿", "匕", "几", "刁", "了"],
"左右结构": ["他", "你", "们", "好", "的", "和", "她", "它", "把", "被"],
"上下结构": ["字", "家", "花", "草", "苗", "英", "杰", "各", "名", "多"],
"左中右结构": ["树", "湖", "渺", "棚", "渤", "滁", "潋", "澎", "潭", "澳"],
"上中下结构": ["意", "莫", "黄", "葬", "禀", "冀", "篝", "篡", "嚣", "兑"],
"全包围结构": ["国", "回", "因", "园", "围", "图", "圆", "圈", "固", "圃"],
"半包围结构": ["这", "过", "建", "延", "式", "武", "或", "载", "戚", "威"],
"品字结构": ["品", "晶", "森", "淼", "焱", "垚", "鑫", "磊", "众", "矗"],
"穿插结构": ["巫", "乘", "爽", "乖", "垂", "重", "禹", "禺", "离", "胤"],
}

def __init__(self, char_db_path: str):
# 加载汉字数据库：包含笔画数、结构、常用度等
self.char_db = pd.read_csv(char_db_path).set_index("char")

def get_char_info(self, char: str) -> Dict:
"""获取汉字的字形信息"""
if char in self.char_db.index:
row = self.char_db.loc[char]
return {
"char": char,
"strokes": int(row["kangxi_strokes"]),
"structure": row.get("structure", self._infer_structure(char)),
"common_level": int(row.get("common_level", 3)), # 1常用 2次常用 3生僻
"radical": row.get("radical", ""),
"radical_strokes": int(row.get("radical_strokes", 0)),
}
return {
"char": char,
"strokes": 0,
"structure": "未知",
"common_level": 4, # 未收录视为极生僻
"radical": "",
"radical_strokes": 0,
}

def _infer_structure(self, char: str) -> str:
"""根据偏旁推断字形结构（简化版）"""
# 实际应用中应使用完整的字形结构数据库
for structure, chars in self.STRUCTURE_TYPES.items():
if char in chars:
return structure
return "未知"

4.2 字形美观度计算

字形美观度从笔画均衡、结构搭配、视觉协调三个子维度评估：

def score_graphic(self, name: str) -> Dict:
"""计算字形综合评分"""
char_info = [self.get_char_info(c) for c in name]

# 1. 笔画均衡评分
stroke_score = self._score_stroke_balance(char_info)

# 2. 结构搭配评分
structure_score = self._score_structure_diversity(char_info)

# 3. 生僻程度评分
rarity_score = self._score_rarity(char_info)

# 4. 辨识度评分
recognition_score = self._score_recognition(char_info)

# 字形综合评分
total = (stroke_score * 0.30 + structure_score * 0.25 +
rarity_score * 0.25 + recognition_score * 0.20)

return {
"total_score": round(total, 1),
"stroke_score": stroke_score,
"structure_score": structure_score,
"rarity_score": rarity_score,
"recognition_score": recognition_score,
"char_info": char_info,
"details": {
"total_strokes": sum(c["strokes"] for c in char_info),
"avg_strokes": round(sum(c["strokes"] for c in char_info) / len(char_info), 1),
"structures": [c["structure"] for c in char_info],
"has_rare_char": any(c["common_level"] >= 3 for c in char_info),
}
}

def _score_stroke_balance(self, char_info: List[Dict]) -> float:
"""笔画均衡评分：各字笔画数不宜相差过大，总笔画适中"""
strokes = [c["strokes"] for c in char_info if c["strokes"] > 0]

if not strokes:
return 50.0

score = 80.0

# 1. 笔画差异惩罚（相邻字笔画差过大）
for i in range(len(strokes) – 1):
diff = abs(strokes[i] – strokes[i+1])
if diff > 10:
score -= 15
elif diff > 7:
score -= 10
elif diff > 5:
score -= 5

# 2. 总笔画数评估（适中为佳，过多过少都扣分）
total = sum(strokes)
if 10 <= total <= 30:
score += 10 # 理想范围
elif total < 8:
score -= 10 # 过于简单
elif total > 40:
score -= 20 # 过于繁琐

# 3. 单字笔画极端值惩罚
for s in strokes:
if s > 25:
score -= 10 # 单字笔画过多
elif s < 3:
score -= 5 # 单字笔画过少

return round(min(100, max(0, score)), 1)

def _score_structure_diversity(self, char_info: List[Dict]) -> float:
"""结构搭配评分：字形结构多样为佳，避免重复结构"""
structures = [c["structure"] for c in char_info if c["structure"] != "未知"]

if not structures:
return 60.0

score = 75.0

# 结构多样性奖励
diversity = len(set(structures)) / len(structures)
score += diversity * 25

# 惩罚：全相同结构（如"林森"都是左右结构）
if len(set(structures)) == 1:
score -= 20

# 惩罚：复杂结构组合（如全包围+品字结构，视觉上过于复杂）
complex_structures = {"全包围结构", "品字结构", "左中右结构", "上中下结构"}
if len(set(structures) & complex_structures) >= 2:
score -= 10

return round(min(100, max(0, score)), 1)

def _score_rarity(self, char_info: List[Dict]) -> float:
"""生僻程度评分：常用字为佳，生僻字扣分"""
levels = [c["common_level"] for c in char_info]
score = 100.0

for level in levels:
if level == 1:
pass # 常用字，不扣分
elif level == 2:
score -= 5 # 次常用字，少量扣分
elif level == 3:
score -= 20 # 生僻字，较多扣分
elif level == 4:
score -= 40 # 极生僻/未收录，大量扣分

# 平均扣分
score = score / len(levels) if levels else 50

return round(min(100, max(0, score)), 1)

def _score_recognition(self, char_info: List[Dict]) -> float:
"""辨识度评分：名字是否容易被正确读写"""
score = 85.0

for c in char_info:
# 多音字降低辨识度
if c.get("is_polyphone", False):
score -= 10
# 笔画过多降低辨识度
if c["strokes"] > 20:
score -= 10
# 与常用字字形相近（容易写错）
if c.get("easily_confused", False):
score -= 15

# 名字整体辨识度：是否容易与其他名字混淆
name_str = "".join(c["char"] for c in char_info)
if self._is_easily_confused_name(name_str):
score -= 10

return round(min(100, max(0, score)), 1)

def _is_easily_confused_name(self, name: str) -> bool:
"""判断名字是否容易与其他名字混淆（简化版）"""
# 实际应用中应与常见名字库进行相似度比对
confusing_patterns = ["子轩", "梓涵", "浩然", "欣怡", "宇轩"]
return any(pattern in name for pattern in confusing_patterns)

五、字义评分算法实现

5.1 字义褒贬与寓意分析

字义评分的核心是评估每个字的寓意是否积极正面，以及名字整体的寓意是否连贯美好：

# algorithms/semantic_scorer.py
from typing import List, Dict, Optional
import pandas as pd
import jieba
from collections import defaultdict

class SemanticScorer:
"""字义评分器"""

def __init__(self, char_db_path: str, idiom_db_path: str = None,
poem_db_path: str = None):
# 汉字字义库：包含释义、褒贬、五行、性别倾向等
self.char_db = pd.read_csv(char_db_path).set_index("char")
# 成语库（用于名字寓意扩展）
self.idiom_db = self._load_idiom_db(idiom_db_path) if idiom_db_path else {}
# 诗词典故库（用于文化出处检测）
self.poem_db = self._load_poem_db(poem_db_path) if poem_db_path else {}

def get_char_semantic(self, char: str) -> Dict:
"""获取汉字的语义信息"""
if char in self.char_db.index:
row = self.char_db.loc[char]
return {
"char": char,
"meaning": row.get("meaning", ""),
"sentiment": row.get("sentiment", "中性"), # 褒义/中性/贬义
"sentiment_score": float(row.get("sentiment_score", 0.5)), # 0-1
"gender_tendency": row.get("gender_tendency", "中性"), # 男/女/中性
"cultural_level": int(row.get("cultural_level", 1)), # 1普通 2有出处 3经典
"tags": eval(row.get("tags", "[]")) if isinstance(row.get("tags"), str) else [],
}
return {
"char": char,
"meaning": "",
"sentiment": "未知",
"sentiment_score": 0.3,
"gender_tendency": "中性",
"cultural_level": 0,
"tags": [],
}

def score_semantic(self, name: str, gender: str = "通用") -> Dict:
"""计算字义综合评分"""
char_semantic = [self.get_char_semantic(c) for c in name]

# 1. 寓意褒贬评分
sentiment_score = self._score_sentiment(char_semantic)

# 2. 文化内涵评分
cultural_score = self._score_cultural(name, char_semantic)

# 3. 性别适配评分
gender_score = self._score_gender_fit(char_semantic, gender)

# 4. 时代感评分
era_score = self._score_era_appropriateness(name, char_semantic)

# 字义综合评分
total = (sentiment_score * 0.35 + cultural_score * 0.30 +
gender_score * 0.20 + era_score * 0.15)

return {
"total_score": round(total, 1),
"sentiment_score": sentiment_score,
"cultural_score": cultural_score,
"gender_score": gender_score,
"era_score": era_score,
"char_semantic": char_semantic,
"details": {
"overall_sentiment": self._overall_sentiment(char_semantic),
"cultural_sources": self._find_cultural_sources(name),
"gender_match": self._gender_match_level(char_semantic, gender),
}
}

def _score_sentiment(self, char_semantic: List[Dict]) -> float:
"""寓意褒贬评分：所有字都应为褒义或中性，不能有贬义"""
scores = [c["sentiment_score"] for c in char_semantic]

if not scores:
return 50.0

# 基础分：平均情感分
avg_score = sum(scores) / len(scores)
base = 50 + avg_score * 50

# 惩罚：有贬义字
for c in char_semantic:
if c["sentiment"] == "贬义":
base -= 40
elif c["sentiment"] == "未知":
base -= 10

# 奖励：所有字都是褒义
if all(c["sentiment"] == "褒义" for c in char_semantic):
base += 10

return round(min(100, max(0, base)), 1)

def _score_cultural(self, name: str, char_semantic: List[Dict]) -> float:
"""文化内涵评分：是否有诗词典故、成语出处"""
score = 60.0

# 单字文化等级
avg_cultural = sum(c["cultural_level"] for c in char_semantic) / len(char_semantic)
score += avg_cultural * 10

# 名字整体是否有成语出处
idiom_source = self._find_idiom_source(name)
if idiom_source:
score += 20

# 名字整体是否有诗词出处
poem_source = self._find_poem_source(name)
if poem_source:
score += 15

# 名字是否有经典组合（如"博文"来自"博学于文"）
classic_combo = self._find_classic_combination(name)
if classic_combo:
score += 10

return round(min(100, max(0, score)), 1)

def _score_gender_fit(self, char_semantic: List[Dict], gender: str) -> float:
"""性别适配评分：名字气质与性别是否匹配"""
if gender == "通用":
return 80.0 # 不指定性别时给中等偏上分

score = 70.0
target = "男" if gender == "男" else "女"

for c in char_semantic:
tendency = c["gender_tendency"]
if tendency == target:
score += 10
elif tendency == "中性":
score += 5
elif tendency != "中性" and tendency != target:
score -= 15

# 平均化
score = score / len(char_semantic) * len(char_semantic) / len(char_semantic)

return round(min(100, max(0, score)), 1)

def _score_era_appropriateness(self, name: str, char_semantic: List[Dict]) -> float:
"""时代感评分：是否符合当代审美，避免过时感"""
score = 75.0

# 检测过时用字（如建国、援朝、文革等时代特征明显的字）
outdated_chars = ["国", "军", "兵", "战", "红", "卫", "东", "彪", "超", "波"]
outdated_count = sum(1 for c in char_semantic if c["char"] in outdated_chars)
score -= outdated_count * 15

# 检测过于流行的字（容易重名，如梓、涵、轩、宇等）
trendy_chars = ["梓", "涵", "轩", "宇", "辰", "睿", "浩", "欣", "怡", "妍"]
trendy_count = sum(1 for c in char_semantic if c["char"] in trendy_chars)
if trendy_count >= 2:
score -= 10 # 两个以上流行字，容易撞名

# 检测有现代感的字（新颖但不生僻）
modern_chars = ["知", "行", "言", "思", "齐", "修", "远", "然", "也", "兮"]
modern_count = sum(1 for c in char_semantic if c["char"] in modern_chars)
score += modern_count * 5

return round(min(100, max(0, score)), 1)

def _find_idiom_source(self, name: str) -> Optional[str]:
"""查找名字的成语出处"""
# 简化版：实际应用中应使用完整成语库进行模糊匹配
for idiom, meaning in self.idiom_db.items():
# 检查名字是否是成语的连续子串或组合
if name in idiom or all(c in idiom for c in name):
return f"{idiom}：{meaning}"
return None

def _find_poem_source(self, name: str) -> Optional[str]:
"""查找名字的诗词出处"""
for poem, source in self.poem_db.items():
if name in poem:
return f"出自{source}：{poem}"
return None

def _find_classic_combination(self, name: str) -> Optional[str]:
"""查找经典名字组合"""
classic_combos = {
"博文": "出自《论语》'博学于文，约之以礼'",
"思齐": "出自《论语》'见贤思齐焉'",
"致远": "出自诸葛亮《诫子书》'非淡泊无以明志，非宁静无以致远'",
"修远": "出自屈原《离骚》'路漫漫其修远兮，吾将上下而求索'",
}
return classic_combos.get(name)

def _overall_sentiment(self, char_semantic: List[Dict]) -> str:
"""判断名字整体情感倾向"""
avg = sum(c["sentiment_score"] for c in char_semantic) / len(char_semantic)
if avg >= 0.8: return "非常积极"
elif avg >= 0.6: return "积极"
elif avg >= 0.4: return "中性"
elif avg >= 0.2: return "偏消极"
else: return "消极"

def _gender_match_level(self, char_semantic: List[Dict], gender: str) -> str:
"""判断性别匹配程度"""
if gender == "通用":
return "未指定"
target = "男" if gender == "男" else "女"
match_count = sum(1 for c in char_semantic if c["gender_tendency"] == target)
ratio = match_count / len(char_semantic)
if ratio >= 0.8: return "高度匹配"
elif ratio >= 0.5: return "基本匹配"
elif ratio >= 0.3: return "部分匹配"
else: return "不匹配"

def _load_idiom_db(self, path: str) -> Dict:
"""加载成语库"""
df = pd.read_csv(path)
return dict(zip(df["idiom"], df["meaning"]))

def _load_poem_db(self, path: str) -> Dict:
"""加载诗词库"""
df = pd.read_csv(path)
return dict(zip(df["verse"], df["source"]))

读者可前往在线起名工具查看完整的字义评分功能，工具支持输入名字后查看每个字的释义、褒贬倾向、性别适配度和文化出处，帮助家长全面了解名字的寓意内涵。

六、综合评分与权重优化

6.1 加权综合评分算法

将音韵、字形、字义三个维度的评分加权求和，得到最终综合评分：

# algorithms/name_scorer.py
from typing import Dict, Optional
from .phonetic_scorer import PhoneticScorer
from .graphic_scorer import GraphicScorer
from .semantic_scorer import SemanticScorer

class NameScorer:
"""名字综合评分器"""

# 默认权重（音35% + 形30% + 义35%）
DEFAULT_WEIGHTS = {
"phonetic": 0.35,
"graphic": 0.30,
"semantic": 0.35,
}

def __init__(self, char_db_path: str, weights: Dict = None,
idiom_db_path: str = None, poem_db_path: str = None):
self.phonetic_scorer = PhoneticScorer(char_db_path)
self.graphic_scorer = GraphicScorer(char_db_path)
self.semantic_scorer = SemanticScorer(char_db_path, idiom_db_path, poem_db_path)
self.weights = weights or self.DEFAULT_WEIGHTS.copy()

def score(self, name: str, surname: str = "", gender: str = "通用") -> Dict:
"""
计算名字综合评分
name: 名字（不含姓氏）
surname: 姓氏（用于音韵分析时考虑全名）
gender: 性别（男/女/通用）
"""
full_name = surname + name

# 1. 音韵评分（使用全名，因为姓氏也影响读音）
phonetic_result = self.phonetic_scorer.score_phonetic(full_name)

# 2. 字形评分（使用全名，因为姓氏也影响视觉平衡）
graphic_result = self.graphic_scorer.score_graphic(full_name)

# 3. 字义评分（只看名字部分，姓氏通常不参与寓意）
semantic_result = self.semantic_scorer.score_semantic(name, gender)

# 4. 加权综合评分
total = (
phonetic_result["total_score"] * self.weights["phonetic"] +
graphic_result["total_score"] * self.weights["graphic"] +
semantic_result["total_score"] * self.weights["semantic"]
)

# 5. 等级评定
level = self._get_level(total)

# 6. 生成优化建议
suggestions = self._generate_suggestions(
phonetic_result, graphic_result, semantic_result
)

return {
"name": full_name,
"surname": surname,
"given_name": name,
"gender": gender,
"total_score": round(total, 1),
"level": level,
"phonetic": phonetic_result,
"graphic": graphic_result,
"semantic": semantic_result,
"weights": self.weights,
"suggestions": suggestions,
"radar_data": {
"音韵": phonetic_result["total_score"],
"字形": graphic_result["total_score"],
"字义": semantic_result["total_score"],
},
}

def _get_level(self, score: float) -> str:
"""根据评分获取等级"""
if score >= 90: return "优秀"
elif score >= 80: return "良好"
elif score >= 70: return "中等"
elif score >= 60: return "及格"
else: return "较差"

def _generate_suggestions(self, phonetic: Dict, graphic: Dict,
semantic: Dict) -> list:
"""根据各维度评分生成优化建议"""
suggestions = []

# 音韵建议
if phonetic["total_score"] < 70:
if phonetic["homophone_penalty"] > 0:
suggestions.append("存在不良谐音，建议更换读音相近但无歧义的字")
if phonetic["tone_score"] < 60:
suggestions.append("声调搭配单调，建议选择平仄交替的字")
if phonetic["final_score"] < 60:
suggestions.append("韵母重复或拗口，建议选择韵母不同的字")

# 字形建议
if graphic["total_score"] < 70:
if graphic["stroke_score"] < 60:
suggestions.append("笔画不均衡或过于繁琐，建议选择笔画适中的字")
if graphic["rarity_score"] < 60:
suggestions.append("包含生僻字，建议更换为常用字以提高辨识度")
if graphic["structure_score"] < 60:
suggestions.append("字形结构单一，建议选择不同结构的字搭配")

# 字义建议
if semantic["total_score"] < 70:
if semantic["sentiment_score"] < 60:
suggestions.append("字义不够积极，建议选择寓意更正面的字")
if semantic["cultural_score"] < 60:
suggestions.append("文化内涵不足，可考虑选择有诗词典故的字")
if semantic["gender_score"] < 60:
suggestions.append("性别适配度不高，建议选择更符合性别气质的字")

if not suggestions:
suggestions.append("各维度表现均衡，是一个不错的名字")

return suggestions

6.2 权重优化效果验证

我们采集了 5000 条用户对名字的主观评分数据，用于验证权重优化的效果：

表格

优化后的权重分配变化：

表格

关键发现：

• 谐音歧义的权重从 8% 提升到 13%，说明用户对不良谐音非常敏感
• 声调搭配的权重从 12% 提升到 15%，说明读音是否顺口是用户最看重的因素
• 生僻程度的权重从 7% 提升到 11%，说明用户不希望名字中有难认的字
• 文化内涵的权重从 10% 降到 7%，说明虽然有文化出处是加分项，但用户并不像专家认为的那样看重

上述综合评分算法和权重优化效果可在在线起名工具中体验，工具提供了详细的评分报告、雷达图和优化建议，帮助家长全面评估名字质量。

6.3 评分结果对比实验

我们选取了 100 个名字，分别用传统五格评分法和我们的音形义综合评分法进行评估，并与用户主观满意度进行对比：

表格

实验结果表明，音形义综合评分法显著优于传统的单一维度评分方法，而基于用户反馈的权重优化进一步提升了评分的准确性和实用性。

七、踩过的坑与注意事项

在实现这套音形义综合评分算法的过程中，遇到了不少实际问题，以下是最有价值的 5 条经验：

1. 多音字处理是音韵评分最大的难点，上下文判断准确率有限

最初我们直接用 pypinyin 库获取拼音，但多音字的处理准确率只有约 70%。例如 “行” 字，在 “知行” 中读 xíng，在 “道行” 中读 héng；“重” 字，在 “重远” 中读 zhòng，在 “重复” 中读 chóng。pypinyin 的默认读音经常出错，导致声调搭配和谐音检测都不准确。后来我们建立了起名场景专用的多音字库，收录了 500 多个常见多音字在不同词语组合中的正确读音，并通过上下文匹配来判断，准确率提升到 92%。但仍有一些特殊组合无法准确判断，建议在实际应用中对多音字给出多种读音选项，让用户确认。

2. 谐音检测不能只看完全同音，近音词的杀伤力更大

最初我们的谐音检测只匹配完全相同的拼音，结果发现很多有问题的名字没有被检测出来。例如 “杜子腾”（肚子疼）、“范建”（犯贱）、“朱逸群”（猪一群），这些名字的拼音与不良词汇并不完全相同，但读音非常接近，听起来就会产生歧义。后来我们引入了拼音相似度算法，允许声母相同、韵母相近的情况被检测到，并建立了包含 2000+ 不良词汇的谐音词库，检测覆盖率从 35% 提升到 85%。建议在实际应用中持续维护和更新谐音词库，因为网络用语和新的不良组合层出不穷。

3. 字形美观度非常主观，笔画均衡只是其中一个维度

最初我们认为字形评分主要看笔画数是否均衡，但实际测试发现，笔画均衡的名字不一定看起来美观。例如 “一二一” 笔画很均衡，但看起来过于简单；“麒麟” 笔画都很多，但视觉上很协调。后来我们引入了字形结构、偏旁部首、视觉重心等多个维度，并通过用户审美数据训练了字形美观度模型，评分与用户审美一致性从 0.45 提升到 0.71。建议在实际应用中不要过度依赖规则，要结合用户审美数据进行模型训练。

4. 字义褒贬不能只看单字，名字组合后的整体寓意更重要

最初我们的字义评分只是简单地把每个字的褒贬分数加权平均，但实际发现很多单字都是褒义的名字，组合起来寓意并不好。例如 “冰雪” 单看都是褒义，但组合起来有 “冷若冰霜” 的暗示；“富贵” 单看都是褒义，但组合起来显得过于直白俗气。后来我们引入了名字整体寓意分析，通过成语匹配、诗词出处、语义连贯性等维度评估名字的整体寓意，评分准确性显著提升。建议在实际应用中建立名字组合语义分析模型，而不是只看单字评分。

5. 权重优化不能只看数据，专家经验和业务约束同样重要

最初我们完全基于用户反馈数据优化权重，结果发现一些不合理的权重分配：例如 “时代感” 的权重被降到接近 0，因为用户评分时不太考虑这个因素，但从产品角度看，避免过时名字是重要的价值主张；“文化内涵” 的权重也被降得很低，但这是我们产品差异化的核心卖点。后来我们采用 “数据驱动 + 专家约束” 的混合优化方法，在优化时设置权重的上下限，并保留业务核心指标的最低权重，最终得到了既符合用户偏好又满足业务目标的权重分配。建议在实际应用中不要盲目追求数据拟合，要结合业务目标和专家经验设置合理的约束。

八、总结

本文完整记录了用 Python 实现名字音形义综合评分算法的全流程，核心要点如下：

该算法已在 529 宝宝起名网上线运行半年，累计为超过 50 万用户提供名字评分服务，用户满意度达到 89%。后续计划引入大语言模型进行更深层次的语义分析和名字创意生成，并构建基于知识图谱的名字文化内涵评估系统，进一步提升评分的准确性和实用性。

如果本文对你有帮助，欢迎点赞收藏，有问题或想法欢迎在评论区交流。