Python 打印0-999999之间的数字名称

所以我有一个小任务，我必须用Python编写一个程序，打印0-999999之间的数字名称

但是我遇到了一些问题，我很想得到你的想法和帮助

这是我到目前为止写的：

numbers = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four', 5: 'Five', \
       6: 'Six', 7: 'Seven', 8: 'Eight', 9: 'Nine', 10: 'Ten', \
       11: 'Eleven', 12: 'Twelve', 13: 'Thirteen', 14: 'Fourteen', \
       15: 'Fifteen', 16: 'Sixteen', 17: 'Seventeen', 18: 'Eighteen', \
       19: 'Nineteen', 20: 'Twenty', 30: 'Thirty', 40: 'Forty', \
       50: 'Fifty', 60: 'Sixty', 70: 'Seventy', 80: 'Eighty', \
       90: 'Ninety', 0: 'Zero'}


def beta1(n):
    if n == 0:
        return numbers[0]
    elif n >= 1 and n <= 19:
        return numbers[n]
    elif n >= 20 and n <= 99:
        if n % 10 == 0:
            return numbers[n]
        else:
            return numbers[n - n % 10] + " " + numbers[n % 10]
    elif n>=100 and n<=999:
        if n%10 == 0:
            return numbers[n/100] + " Hundred"
        else:
            return numbers[n/100] + " Hundred" +" "  +numbers[n%100 - n %10] + " " + numbers[n % 10]
    elif n>=1000 and n<=999999:
        if n>= 1000 and n <=9999:
            if n%10 == 0:
                return numbers[n/1000] + " Thousand"
            else:
                return numbers[n/1000] + " Thousand" + " " +numbers[(n%1000- n%100)/100] + " Hundred " + numbers[n%100- n%10] + " " + numbers[n%10]

我很想从您那里得到一些关于这个主题的想法/帮助（由于不包括库，我希望它是纯编码的。）

我是一个新的程序员，所以对我放松点，哈哈。

---

提前谢谢

您可以通过先将大数字转换为字符串，然后一次解析一个字符来处理大数字。例如：

if n >= 1000:
    place = {1:'', 2:'', 3:'hundred', 4:'thousand'}
    return_val = ''
    n = str(n)
    while n != '':
        c = n[0]
        return_val += numbers[int(c)]
        return_val += place[len(n)]
        n = n[1:]

显然，这个答案并不完整，但我认为这是解决这个问题最简单的方法。此外，可以对beta1函数进行递归调用，以避免大量嵌套的if-else语句

---

希望有帮助

你接近了！我会从一个自上而下的方法开始（例如，从100000级别开始，一路向下），并使用递归调用。我还将使用表示

mod

的

%

运算符（基本上为您提供余数

5%2=1

）

下面是一个将处理示例5050的想法：

numbers = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four', 5: 'Five', \
   6: 'Six', 7: 'Seven', 8: 'Eight', 9: 'Nine', 10: 'Ten', \
   11: 'Eleven', 12: 'Twelve', 13: 'Thirteen', 14: 'Fourteen', \
   15: 'Fifteen', 16: 'Sixteen', 17: 'Seventeen', 18: 'Eighteen', \
   19: 'Nineteen', 20: 'Twenty', 30: 'Thirty', 40: 'Forty', \
   50: 'Fifty', 60: 'Sixty', 70: 'Seventy', 80: 'Eighty', \
   90: 'Ninety', 0: 'Zero'}

mapping = {3:'Hundred', 4:'Thousand', ...}

def beta1(n):
    numofdigits = len(n)
    if not mapping[numofdigits]:
        use your own code
    else:
        divider = (10 ** (numofdigits))
        word = numbers[n/divider]
        remainder = n%divider
        return word + mapping[numofdigits] + beta1(remainder)

例如，如果我在这个函数中插入

5050

。它将对

5050

和

10^len（5050）

进行整数除法，即

5050/1000

，得到5。

5050%1000

的剩余部分为

50

。现在，函数返回

word

，在本例中为

'Five'

，并与

映射[4]

连接，后者是

'000'

+对函数的递归调用，用于解析

50

，后者将返回

'Five'

。因此，您的最终结果将是

'5500'

---

这是一个更优雅的解决方案，因为您不需要太多硬代码。我会让你处理其他的案子！祝你好运，如果你还有任何问题，请告诉我

这可能看起来很乏味，但是将每个位置转换成一个单独的数字，然后添加单词的字符串。我在几分钟内就做到了999。继续相同的模式，它应该是简单和非常基本的

numbers = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four', 5: 'Five', \
   6: 'Six', 7: 'Seven', 8: 'Eight', 9: 'Nine', 10: 'Ten', \
   11: 'Eleven', 12: 'Twelve', 13: 'Thirteen', 14: 'Fourteen', \
   15: 'Fifteen', 16: 'Sixteen', 17: 'Seventeen', 18: 'Eighteen', \
   19: 'Nineteen', 20: 'Twenty', 30: 'Thirty', 40: 'Forty', \
   50: 'Fifty', 60: 'Sixty', 70: 'Seventy', 80: 'Eighty', \
   90: 'Ninety', 0: ''}


def beta1(n):
    global numbers
    if n == 0:
        pass
    elif n <= 20:
        return numbers[n]
    elif 10 < n < 100:
        tens = int(str(n)[0]) * 10
        ones = int(str(n)[1])
        return numbers[tens] + " " + numbers[ones]
    elif 100 < n < 1000:
        hundreds = int(str(n)[0])
        tens = int(str(n)[1]) * 10
        ones = int(str(n)[2])
        return numbers[hundreds] + " Hundred " + numbers[tens] + " "+ numbers[ones]

for n in range(1000):
    print beta1(n)

number={1:'1'，2:'2'，3:'3'，4:'4'，5:'5''\
6:'六',7:'七',8:'八',9:'九',10:'十',\
11:'十一',12:'十二',13:'十三',14:'十四',\
15:'十五',16:'十六',17:'十七',18:'十八',\
19:'十九',20:'二十',30:'三十',40:'四十',\
50:'五十',60:'六十',70:'七十',80:'八十',\
90:'90'，0:'}
def beta1（n）：
全球数字
如果n==0：
通过
elif n我不会给你一个直接的答案，但会给你一些提示

首先，您需要以三位数字为一组来解析数字，因为三位数字的每一组的措辞完全相同，唯一的区别是描述“级别”的后缀，例如：

505和505000将基本相同：
“五百零五”
哪一秒你只需要加上“千”

这意味着您还需要一个表：

suffixes = ['', 'thousand', 'million', ...]

（第一级为空）

然后，解析每个三元组很简单：
-检查百位数//100，从
numbers
-余数-如果小于20-从<代码>编号中获取，否则，从<代码>编号中获取第一个数字（编号//10*10）添加“百”，并从<代码>编号中获取提醒（编号%10）

---

-不要忘记在后缀的末尾添加“s”

您需要分别处理每个命名组（例如，

贰万肆仟肆佰伍拾壹

）。递归将是您在这里的朋友，这样您就不会有一个长链的

if

首先，如果提供的数字是直接在数字字典中定义的，则无需检查数字是否在特定范围内，您可以短路

if num in numbers:
    return numbers[num]

另外，您应该使用特殊的大小写

0

，并将其从数字字典中删除，这样我们以后就不会再除以它了

if num == 0:
    return 'Zero'

我会定义你要处理的不同的大量词

quantifiers = {
    10 ** 2: 'Hundred',
    10 ** 3: 'Thousand',
    10 ** 6: 'Million',
}

然后将您的号码分成需要单独处理的部分

num = 1234567

quantifier_amounts = []
r = num
for div in sorted(quantifiers.keys(), reverse=True):
    n, r = divmod(r, div)
    if n:
        quantifier_amounts.append((n, quantifiers[div]))
    if not r:
        break

这应该给你

quantifier_amounts = [(1, 'Million'), (234, 'Thousand'), (5, 'Hundred')]
r = 67

amounts = ['Sixty', 'Seven']

然后，使用数字字典以同样的方式处理剩余的

r

值

amounts = []
if r:
    for div in sorted(numbers.keys(), reverse=True):
        n, r = divmod(r, div)
        if n:
            amounts.append(numbers[div])
        if not r:
            break

这应该给你

quantifier_amounts = [(1, 'Million'), (234, 'Thousand'), (5, 'Hundred')]
r = 67

amounts = ['Sixty', 'Seven']

然后递归地处理每个量词部分并将文本添加到一起（函数名为

numtext

）

你应该

壹佰贰拾叁万肆仟伍佰陆拾柒元

---

Brenden Abel在上面的回答很好，但这里有一个好的、紧凑的、更独立的版本。正如其他人所指出的，递归是您的朋友：

def beta1(n, returnZero=True):
    if n == 0 and not returnZero: return []             # Prevent superfluous final "zero", e.g. 2900: "two thousand nine hundred zero"
    if n in numbers: return [numbers[n]]                # Direct mapping from n to text
    if n >= 1000: return beta1(n // 1000) + ['Thousand'] + beta1(n%1000, False)
    if n >= 100: return beta1(n // 100) + ['Hundred'] + beta1(n%100, False)
    if n > 20: return [numbers[n//10*10]] + beta1(n%10, False)

# This function returns the elements as a list, so convert it to a string:
print( " ".join(beta1(12345)) )

当然，这可以很容易地扩展到处理大于999999的数字：

    if n >= 1000000000: return beta1(n // 1000000000) + ['Billion'] + beta1(n%1000000000, False)
    if n >= 1000000: return beta1(n // 1000000) + ['Million'] + beta1(n%1000000, False)

还有一些测试用例：

# Wrapper function that converts from a list to a string
# def beta1Text(n): return " ".join(beta1(n))
def beta1Text(n): return " ".join(beta1(n))

# Your test cases
print(beta1Text(5050))      # Five Thousand Fifty
print(beta1Text(550))       # Five Hundred Fifty
print(beta1Text(515))       # Five Hundred Fifteen
print(beta1Text(505))       # Five Hundred Five

# A few more test cases
print(beta1Text(290000))    # Two Hundred Ninety Thousand
print(beta1Text(123210))    # One Hundred Twenty Three Thousand Two Hundred Ten
print(beta1Text(990000))    # Nine Hundred Ninety Thousand
print(beta1Text(123456))    # One Hundred Twenty Three Thousand Four Hundred Fifty Six
for ii in range(20): print(beta1Text(ii))   # Zero, One, Two...Eighteen, Nineteen

# Test cases > 999,999
print(beta1Text(1000000))       # One Million
print(beta1Text(1000000000))    # One Billion
print(beta1Text(1234567898))    # One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety Eight

---

我认为拆分为1000，在定义词典时不需要行继承字符（``）。