2.1 正向遍历法
首先，我们以 一百二十三 作为第一个要转化的例子，你大概会说，这个用小学学过的知识就可以做到，的确如此！先把中文数字和单位做个映射，然后正向遍历，用数字乘以单位，然后直接把他们累加起来就搞定了。
一百二十三 的解析式为 1*100 + 2*10 + 3，代码如下：
# 数字映射
number_map = {
"零": 0,
"一": 1,
"二": 2,
"三": 3,
"四": 4,
"五": 5,
"六": 6,
"七": 7,
"八": 8,
"九": 9
}
# 单位映射
unit_map = {
"十": 10,
"百": 100,
"千": 1000,
"万": 10000,
"亿": 100000000
}
# 正向遍历 1
def forward_cn2an_one(inputs):
output = 0
unit = 1
num = 0
for index, cn_num in enumerate(inputs):
if cn_num in number_map:
# 数字
num = number_map[cn_num]
# 最后的个位数字
if index == len(inputs) - 1:
output = output + num
elif cn_num in unit_map:
# 单位
unit = unit_map[cn_num]
# 累加
output = output + num * unit
num = 0
else:
raise ValueError(f"{cn_num} 不在转化范围内")
return output
output = forward_cn2an_one("一百二十三")
# output: 123是不是如你想象的那么简单，但这种基础算法到十万以上就不行了。比如 一十二万（通常情况下，你会更习惯说 十二万，但那个是口语说法），用上述算法就会得到 20010，而不是 120000。
仔细想想问题出在了哪里。没错！就出在万位那里，由于算法是单位乘以数字然后直接累加，因此一十二万被解析成了 1*10 + 2*10000，而不是 (1*10 + 2)*10000。
问题找到了，那解决起来还是比较简单的。我们直接在万位那里做个判断，即当识别到万的时候，先把前面所有数字加起来，再乘以单位万。
# 正向遍历 2
def forward_cn2an_two(inputs):
output = 0
unit = 1
num = 0
for index, cn_num in enumerate(inputs):
if cn_num in number_map:
# 数字
num = number_map[cn_num]
# 最后的个位数字
if index == len(inputs) - 1:
output = output + num
elif cn_num in unit_map:
# 单位
unit = unit_map[cn_num]
# 判断出万、亿，先把前面的累加再乘以单位万、亿
if unit % 10000 == 0:
output = (output + num) * unit
else:
# 累加
output = output + num * unit
num = 0
else:
raise ValueError(f"{cn_num} 不在转化范围内")
return output
output = forward_cn2an_two("一十二万")
# output: 120000别急！我们来分析一下，这是 一亿二千三百四十五万六千七百八十一 的解析式： (1*100000000 + 2*1000 + 3*100 + 4*10 + 5)*10000 + 6*1000 + 7*100 + 8*10 + 1，从解析式中可以看到，亿位上的数字被错误得乘以了万，这种情况也需要做处理。
# 正向遍历 3
def forward_cn2an_three(inputs):
output = 0
unit = 1
num = 0
# 亿位以上的输出
hundred_million_output = 0
for index, cn_num in enumerate(inputs):
if cn_num in number_map:
# 数字
num = number_map[cn_num]
# 最后的个位数字
if index == len(inputs) - 1:
# 把亿位和中间输出以及个位上的一起加起来
output = hundred_million_output + output + num
elif cn_num in unit_map:
# 单位
unit = unit_map[cn_num]
# 判断出万，前面的累加再乘以单位万
if unit == 10000:
output = (output + num) * unit
# 判断出亿，前面累加乘以亿后赋值给 hundred_million_output， output 重置为 0
elif unit == 100000000:
hundred_million_output = (output + num) * unit
output = 0
else:
# 累加
output = output + num * unit
num =0
else:
raise ValueError(f"{cn_num} 不在转化范围内")
return output
output = forward_cn2an_three("一亿二千三百四十五万六千七百八十一")
# output: 123456781仔细阅读上文代码，我增加了一个新的变量 hundred_million_output，用于存储亿位以上的数字，等所有计算完成时，再把它和后面的数字相加即可得到正确结果，解析式为：1*100000000 + （2*1000 + 3*100 + 4*10 + 5)*10000 + 6*1000 + 7*100 + 8*10 + 1。
同样的，我们用一个几乎接近上限的数字 一千二百三十四万五千六百七十八亿一千二百三十四万五千六百七十八 来测试，结果也是正确的。
output = forward_cn2an_three("一千二百三十四万五千六百七十八亿一千二百三十四万五千六百七十八")
# output: 1234567812345678目前为止，千万亿规模的数字上，我们的算法似乎已经可以很好的转化了！
2.2 反向遍历法
不知道你看完上面的算法是不是有点膈应，先用变量存储再相加的方式似乎不是那么优雅。有没有更好方法的解决它呢？
雷军：有人说我写的代码，像诗一样优雅。
咦～有了！我们可以使用反向（倒序）遍历，虽然还是数字乘以单位，但我们是不断的和更大的数字累加，只要处理好单位问题，就不会出现需要把部分值先暂存，然后再加到一起的方式，从而节省一个变量的空间！
# 反向遍历 1
def backward_cn2an_one(inputs):
output = 0
unit = 1
num = 0
for index, cn_num in enumerate(reversed(inputs)):
if cn_num in number_map:
# 数字
num = number_map[cn_num]
# 累加
output = output + num * unit
elif cn_num in unit_map:
# 单位
unit = unit_map[cn_num]
else:
raise ValueError(f"{cn_num} 不在转化范围内")
return output
output = backward_cn2an_one("一百二十三")
# output: 123一十二万 被解析成了 2*10000 + 1*10，仔细看和正向遍历得到的解析式 1*10 + 2*10000 的不同，1*10 中的 10 本应该是十万位。我们需要在遍历到万位时，记录当前的单位是万，后面的单位再乘以万就搞定了！代码如下：
# 反向遍历 2
def backward_cn2an_two(inputs):
output = 0
unit = 1
# 万、亿的单位
ten_thousand_unit = 1
num = 0
for index, cn_num in enumerate(reversed(inputs)):
if cn_num in number_map:
# 数字
num = number_map[cn_num]
# 累加
output = output + num * unit
elif cn_num in unit_map:
# 单位
unit = unit_map[cn_num]
# 判断出万、亿
if unit % 10000 == 0:
ten_thousand_unit = unit
if unit < ten_thousand_unit:
unit = ten_thousand_unit * unit
else:
raise ValueError(f"{cn_num} 不在转化范围内")
return output
output = backward_cn2an_two("一十二万")
# output: 120000亿以上数字测试通过！反向遍历就真这么简单？！不，还有更大的数字没有测试。
# 反向遍历 3
def backward_cn2an_three(inputs):
output = 0
unit = 1
# 万、亿的单位
ten_thousand_unit = 1
num = 0
for index, cn_num in enumerate(reversed(inputs)):
if cn_num in number_map:
# 数字
num = number_map[cn_num]
# 累加
output = output + num * unit
elif cn_num in unit_map:
# 单位
unit = unit_map[cn_num]
# 判断出万、亿
if unit % 10000 == 0:
# 万、亿
if unit > ten_thousand_unit:
ten_thousand_unit = unit
# 万亿
else:
ten_thousand_unit = unit * ten_thousand_unit
unit = ten_thousand_unit
if unit < ten_thousand_unit:
unit = ten_thousand_unit * unit
else:
raise ValueError(f"{cn_num} 不在转化范围内")
return output
output = backward_cn2an_three("一千二百三十四万五千六百七十八亿一千二百三十四万五千六百七十八")
# output: 1234567812345678
