Comment dois-je dire à Python pour convertir des nombres entiers en mots

Je suis en train de dire à Python pour convertir des nombres entiers en mots.

Exemple: (à l'aide de la chanson 99 bouteilles de bière sur le mur)

J'ai utilisé ce code pour écrire le programme:

for i in range(99,0,-1):
    print i, "Bottles of beer on the wall,"
    print i, "bottles of beer."
    print "Take one down and pass it around,"
    print i-1, "bottles of beer on the wall."
    print

Mais je ne peux pas comprendre comment écrire le programme, de sorte que les mots (c'est à dire quatre-vingt-dix-neuf, quatre-vingt-dix-huit, etc.) sera affiché à la place des numéros.

J'ai été ruiner ma tête dans le python livre que j'ai, je comprends que peut-être je ne comprends pas for/if/elif/else boucles encore, mais je suis juste de tourner mes roues.

Quelqu'un pourrait-il fournir aucune indication? Je ne cherche pas une réponse directe, bien que cela pourrait m'aider à voir mon problème, il suffit de rien pour me pointer dans la bonne direction serait génial.

  • for, if, elif et else ne sont pas vraiment des boucles, ils sont instructions
  • Vous êtes seulement intéressés par les solutions range(99, 0, -1)? Ou à la recherche de quelque chose de plus général?
  • double possible de Code de Golf: Nombre de Mots
  • allez-vous l'utiliser pour quelque chose de plus utile que de chanter une chanson?
  • et stackoverflow.com/questions/493174/...
  • Qui risque de décourager les nouveaux apprenants... Il est bon que l'on cherche à résoudre des problèmes(à moins qu'il/elle le veut pour le bien de trouver des devoirs à faire.)
  • Je suis d'accord avec vous @0xc0de, mais ce problème n'est pas vraiment important-problème de la vie réelle, est-il?
  • Non, il n'est pas. Je suppose que vous avez pointant vers le problème étant de moins en moins intéressant et délicat. Mais je ne pourrais jamais apprendre quoi que ce soit si j'avais commencé avec les problèmes de la vie réelle.. pour moi, ils étaient trop complexes pour commencer la programmation. Quand j'ai voulu voir comment les choses fonctionnent et en essayant d'éviter la syntaxe des bugs, je ne pouvais pas vraiment penser à des algorithmes 🙂
  • Ce problème n'est pas de devoirs...pas encore. J'ai remarqué qu'il y a plusieurs exercices dans le livre "Penser Python" par Allen Downey, qui demandent au lecteur d'essayer de convertir les mots pour les nombres entiers et arrière. J'ai juste utilisé cela comme un exemple....il a été le premier que j'ai essayé. La chose la plus proche que je suis en train de faire avec Python par rapport à ses devoirs avec le programme FORTRAN pour les Ingénieurs Électriques, et nous n'avons pas arriver à faire quelque chose d'amusant comme ça.
  • Merci pour le lien wim. J'ai cherché la nuit dernière pour les réponses, le long de ma question ligne. Il n'est jamais venu à moi de changer certains paramètres de la recherche autour de. Ill faire un peu de lecture sur ce forum quand je suis fait avec les classes d'aujourd'hui.
  • Génial. Je travaillais sur le même programme exact, le 99 Bouteilles de problème, et je me demandais la même chose.

InformationsquelleAutor Lgmccracken | 2012-01-24
  1. 63

    L'infléchir package peut le faire.

    https://pypi.python.org/pypi/inflect

    $ pip install inflect

    et puis:

    >>>import inflect
>>>p = inflect.engine()
>>>p.number_to_words(99)
ninety-nine
    • num2words, qui, apparemment, remplace PyNum2Word, peut également être installé via pip. Donc, peut-PyNum2Word.
    InformationsquelleAutor Lee
  2. 36

    Utilisation pynum2word module qui peut être trouvé sur sourceforge

    >>> import num2word
>>> num2word.to_card(15)
'fifteen'
>>> num2word.to_card(55)
'fifty-five'
>>> num2word.to_card(1555)
'one thousand, five hundred and fifty-five'
    InformationsquelleAutor ranendra
  3. 20

    Nous avons adapté un existant solution sympa (ref) pour la conversion des numéros de mots comme suit:

    def numToWords(num,join=True):
'''words = {} convert an integer number into words'''
units = ['','one','two','three','four','five','six','seven','eight','nine']
teens = ['','eleven','twelve','thirteen','fourteen','fifteen','sixteen', \
'seventeen','eighteen','nineteen']
tens = ['','ten','twenty','thirty','forty','fifty','sixty','seventy', \
'eighty','ninety']
thousands = ['','thousand','million','billion','trillion','quadrillion', \
'quintillion','sextillion','septillion','octillion', \
'nonillion','decillion','undecillion','duodecillion', \
'tredecillion','quattuordecillion','sexdecillion', \
'septendecillion','octodecillion','novemdecillion', \
'vigintillion']
words = []
if num==0: words.append('zero')
else:
numStr = '%d'%num
numStrLen = len(numStr)
groups = (numStrLen+2)/3
numStr = numStr.zfill(groups*3)
for i in range(0,groups*3,3):
h,t,u = int(numStr[i]),int(numStr[i+1]),int(numStr[i+2])
g = groups-(i/3+1)
if h>=1:
words.append(units[h])
words.append('hundred')
if t>1:
words.append(tens[t])
if u>=1: words.append(units[u])
elif t==1:
if u>=1: words.append(teens[u])
else: words.append(tens[t])
else:
if u>=1: words.append(units[u])
if (g>=1) and ((h+t+u)>0): words.append(thousands[g]+',')
if join: return ' '.join(words)
return words
#example usages:
print numToWords(0)
print numToWords(11)
print numToWords(110)
print numToWords(1001000025)
print numToWords(123456789012)

    résultats:

    zero
eleven
one hundred ten
one billion, one million, twenty five
one hundred twenty three billion, four hundred fifty six million, seven hundred
eighty nine thousand, twelve

    Noter que cela fonctionne pour des nombres entiers. Néanmoins, il est trivial de diviser un nombre à virgule en deux parties correspondant aux entiers.

    InformationsquelleAutor Developer
  4. 17

    Voici un moyen de le faire en Python 3:

    """Given an int32 number, print it in English."""
def int_to_en(num):
d = { 0 : 'zero', 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' }
k = 1000
m = k * 1000
b = m * 1000
t = b * 1000
assert(0 <= num)
if (num < 20):
return d[num]
if (num < 100):
if num % 10 == 0: return d[num]
else: return d[num // 10 * 10] + '-' + d[num % 10]
if (num < k):
if num % 100 == 0: return d[num // 100] + ' hundred'
else: return d[num // 100] + ' hundred and ' + int_to_en(num % 100)
if (num < m):
if num % k == 0: return int_to_en(num // k) + ' thousand'
else: return int_to_en(num // k) + ' thousand, ' + int_to_en(num % k)
if (num < b):
if (num % m) == 0: return int_to_en(num // m) + ' million'
else: return int_to_en(num // m) + ' million, ' + int_to_en(num % m)
if (num < t):
if (num % b) == 0: return int_to_en(num // b) + ' billion'
else: return int_to_en(num // b) + ' billion, ' + int_to_en(num % b)
if (num % t == 0): return int_to_en(num // t) + ' trillion'
else: return int_to_en(num // t) + ' trillion, ' + int_to_en(num % t)
raise AssertionError('num is too large: %s' % str(num))

    Et le résultat est:

    0 zero
3 three
10 ten
11 eleven
19 nineteen
20 twenty
23 twenty-three
34 thirty-four
56 fifty-six
80 eighty
97 ninety-seven
99 ninety-nine
100 one hundred
101 one hundred and one
110 one hundred and ten
117 one hundred and seventeen
120 one hundred and twenty
123 one hundred and twenty-three
172 one hundred and seventy-two
199 one hundred and ninety-nine
200 two hundred
201 two hundred and one
211 two hundred and eleven
223 two hundred and twenty-three
376 three hundred and seventy-six
767 seven hundred and sixty-seven
982 nine hundred and eighty-two
999 nine hundred and ninety-nine
1000 one thousand
1001 one thousand, one
1017 one thousand, seventeen
1023 one thousand, twenty-three
1088 one thousand, eighty-eight
1100 one thousand, one hundred
1109 one thousand, one hundred and nine
1139 one thousand, one hundred and thirty-nine
1239 one thousand, two hundred and thirty-nine
1433 one thousand, four hundred and thirty-three
2000 two thousand
2010 two thousand, ten
7891 seven thousand, eight hundred and ninety-one
89321 eighty-nine thousand, three hundred and twenty-one
999999 nine hundred and ninety-nine thousand, nine hundred and ninety-nine
1000000 one million
2000000 two million
2000000000 two billion
    InformationsquelleAutor SiLent SoNG
  5. 10

    Bien, les morts-simple façon de le faire est de faire une liste de tous les numéros qui vous intéressent:

    numbers = ["zero", "one", "two", "three", "four", "five", ... 
"ninety-eight", "ninety-nine"]

    (Le ... indique où vous tapez le texte des représentations d'autres nombres. Non, Python ne va pas magiquement remplir pour vous, vous avez le type de chacun d'eux pour utiliser cette technique.)

    Et puis d'imprimer le nombre, il suffit d'imprimer numbers[i]. Facile comme bonjour.

    Bien sûr, cette liste est beaucoup de dactylographie, de sorte que vous pouvez vous demander à propos d'un moyen facile de générer. L'anglais n'a malheureusement beaucoup d'irrégularités, de sorte que vous auriez à mettre manuellement dans les vingt (0-19), mais vous pouvez utiliser les régularités pour générer le reste jusqu'à 99. (Vous pouvez également générer de la des ados, mais seulement certains d'entre eux, de sorte qu'il semble plus facile de simplement taper.)

    numbers = "zero one two three four five six seven eight nine".split()
numbers.extend("ten eleven twelve thirteen fourteen fifteen sixteen".split())
numbers.extend("seventeen eighteen nineteen".split())
numbers.extend(tens if ones == "zero" else (tens + "-" + ones) 
for tens in "twenty thirty forty fifty sixty seventy eighty ninety".split()
for ones in numbers[0:10])
print numbers[42]  # "forty-two"

    Une autre approche consiste à écrire une fonction qui met en place la chaîne correcte à chaque fois. Encore une fois, vous aurez à coder en dur les vingt premiers numéros, mais après cela, vous pouvez facilement générer à partir de zéro en tant que de besoin. Il utilise un peu moins de mémoire (un beaucoup moins une fois que vous commencez à travailler avec un plus grand nombre).

    InformationsquelleAutor kindall
  6. 3

    Vous pouvez utiliser le python-n2w de la bibliothèque, il suffit de faire 

    pip install n2w

    alors simplement

    print(n2w.convert(your-number-here))
    • n2w actuellement ne convertit les adolescents correctement.
    • Merci pour les commentaires, pourriez-vous veuillez donner un exemple.
    • Assurez-vous. 14 -> "forteen' (orthographe), 15 -> 'seize', 16 -> "dix-sept', 17 -> 'dix-huit', 18 -> 'dix-neuf', 19 ->"'
    • merci de souligner ce point, ce problème semble être maintenant résolu 🙂
    InformationsquelleAutor Collins Abitekaniza
  7. 2

    Sonore comme vous aurez besoin d'utiliser un tableau, où num[1] = "one", num[2] = "two", et ainsi de suite. Ensuite, vous pouvez parcourir chaque comme vous l'êtes déjà et 

    num = array(["one","two","three","four","five","six","seven","eight","nine","ten"])
for i in range(10,0,-1):
print num[i], "Bottles of beer on the wall,"
print num[i], "bottles of beer."
print "Take one down and pass it around,"
print num[i-1], "bottles of beer on the wall."
print ""
    InformationsquelleAutor tyjkenn
  8. 2

    Ici est la version remaniée de plusieurs exemples de code affiché ci-dessus (pour la plupart de code collés par "développeur".

    def int2words(num):
"""Given an int32 number, print it in English.
Parameters
----------
num : int
Returns
-------
words : str
"""
assert (0 <= num)
d = {
0: 'zero', 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'
}
h = [100, 'hundred', 'hundred and']
k = [h[0] * 10, 'thousand', 'thousand,']
m = [k[0] * 1000, 'million', 'million,']
b = [m[0] * 1000, 'billion', 'billion,']
t = [b[0] * 1000, 'trillion', 'trillion,']
if num < 20:
return d[num]
if num < 100:
div_, mod_ = divmod(num, 10)
return d[num] if mod_ == 0 else d[div_ * 10] + '-' + d[mod_]
else:
if num < k[0]:
divisor, word1, word2 = h
elif num < m[0]:
divisor, word1, word2 = k
elif num < b[0]:
divisor, word1, word2 = m
elif num < t[0]:
divisor, word1, word2 = b
else:
divisor, word1, word2 = t
div_, mod_ = divmod(num, divisor)
if mod_ == 0:
return '{} {}'.format(int2words(div_), word1)
else:
return '{} {} {}'.format(int2words(div_), word2, int2words(mod_))
    InformationsquelleAutor dgrigonis
  9. 2

    Et voici ma solution 🙂 Il est différentes des précédentes solutions, mais il s'est développé sur mon propre - peut-être quelqu'un en profiter plus que d'autres propositions.

    TENS = {30: 'thirty', 40: 'forty', 50: 'fifty', 60: 'sixty', 70: 'seventy', 80: 'eighty', 90: 'ninety'}
ZERO_TO_TWENTY = (
'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten',
'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen', 'twenty'
)
def number_to_english(n):
if any(not x.isdigit() for x in str(n)):
return ''
if n <= 20:
return ZERO_TO_TWENTY[n]
elif n < 100 and n % 10 == 0:
return TENS[n]
elif n < 100:
return number_to_english(n - (n % 10)) + ' ' + number_to_english(n % 10)
elif n < 1000 and n % 100 == 0:
return number_to_english(n / 100) + ' hundred'
elif n < 1000:
return number_to_english(n / 100) + ' hundred ' + number_to_english(n % 100)
elif n < 1000000:
return number_to_english(n / 1000) + ' thousand ' + number_to_english(n % 1000)
return ''

    Il est recoursive solution et peut être facilement développer pour le plus grand nombre

    InformationsquelleAutor Hunter_71
  10. 1

    Code:

    >>>def handel_upto_99(number):
predef={0:"zero",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:"fourty",50:"fifty",60:"sixty",70:"seventy",80:"eighty",90:"ninety",100:"hundred",100000:"lakh",10000000:"crore",1000000:"million",1000000000:"billion"}
if number in predef.keys():
return predef[number]
else:
return predef[(number/10)*10]+' '+predef[number%10]
    >>>def return_bigdigit(number,devideby):
predef={0:"zero",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:"fourty",50:"fifty",60:"sixty",70:"seventy",80:"eighty",90:"ninety",100:"hundred",1000:"thousand",100000:"lakh",10000000:"crore",1000000:"million",1000000000:"billion"}
if devideby in predef.keys():
return predef[number/devideby]+" "+predef[devideby]
else:
devideby/=10
return handel_upto_99(number/devideby)+" "+predef[devideby]
    >>>def mainfunction(number):
dev={100:"hundred",1000:"thousand",100000:"lakh",10000000:"crore",1000000000:"billion"}
if number is 0:
return "Zero"
if number<100:
result=handel_upto_99(number)
else:
result=""
while number>=100:
devideby=1
length=len(str(number))
for i in range(length-1):
devideby*=10
if number%devideby==0:
if devideby in dev:
return handel_upto_99(number/devideby)+" "+ dev[devideby]
else:
return handel_upto_99(number/(devideby/10))+" "+ dev[devideby/10]
res=return_bigdigit(number,devideby)
result=result+' '+res
if devideby not in dev:
number=number-((devideby/10)*(number/(devideby/10)))
number=number-devideby*(number/devideby)
if number <100:
result = result + ' '+ handel_upto_99(number)
return result

    résultat:

    >>>mainfunction(12345)
' twelve thousand three hundred fourty five'
>>>mainfunction(2000)
'two thousand'
    InformationsquelleAutor Nullify
  11. 1

    Cela fonctionne pour trop les 1000 premiers nombres (Python 3). Débutant solution au problème, mais une solution néanmoins...

    first_nums = ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve",
"thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]
tens = ["ten", "twenty", "thirty","forty","fifty", "sixty","seventy","eighty","ninety"]
for num in range(1,1001):
if num < 20:
print(first_nums[num])
elif num < 100 and num % 10 == 0:
print(tens[int(num/10 - 1)])
elif num < 1000 and num % 100 == 0:
print(first_nums[int(num/100)] + " hundred")
elif num == 1000:
print("one thousand")
elif num < 100 and num % 10 != 0:
print(tens[int(num//10 - 1)] + " " + first_nums[int(num%10)])
elif num < 1000:
if num%100 < 20:
print(first_nums[int(num//100)] + " hundred and " + first_nums[num%100])
else:
print(first_nums[int(num//100)] + " hundred and " + tens[int(num%100//10 - 1)] + " " + first_nums[int(num%10)])
    InformationsquelleAutor Andrea
  12. 1

    Ce fait le travail sans aucune bibliothèque. Utilisé récursivité et il est de style Indien. -- Ravi.

    def spellNumber(no):
# str(no) will result in  56.9 for 56.90 so we used the method which is given below.
strNo = "%.2f" %no
n = strNo.split(".")
rs = numberToText(int(n[0])).strip()
ps =""
if(len(n)>=2):
ps = numberToText(int(n[1])).strip()
rs = "" + ps+ " paise"  if(rs.strip()=="") else  (rs + " and " + ps+ " paise").strip()
return rs
print(spellNumber(0.67))
print(spellNumber(5858.099))
print(spellNumber(5083754857380.50))    
def numberToText(no):
ones = " ,one,two,three,four,five,six,seven,eight,nine,ten,eleven,tweleve,thirteen,fourteen,fifteen,sixteen,seventeen,eighteen,nineteen,twenty".split(',')
tens = "ten,twenty,thirty,fourty,fifty,sixty,seventy,eighty,ninety".split(',')
text = ""
if len(str(no))<=2:
if(no<20):
text = ones[no]
else:
text = tens[no//10-1] +" " + ones[(no %10)]
elif len(str(no))==3:
text = ones[no//100] +" hundred " + numberToText(no- ((no//100)* 100))
elif len(str(no))<=5:
text = numberToText(no//1000) +" thousand " + numberToText(no- ((no//1000)* 1000))
elif len(str(no))<=7:
text = numberToText(no//100000) +" lakh " + numberToText(no- ((no//100000)* 100000))
else:
text = numberToText(no//10000000) +" crores " + numberToText(no- ((no//10000000)* 10000000))
return text
    InformationsquelleAutor Ravi Kotian
  13. 0

    Vous devez utiliser un dictionnaire ou un tableau.
    Par exemple : 

     to_19= ['zero','one','two','three','four','five','six','seven','eight','nine'..'nineteen']
tens = ['twenty'...'ninety']

    Et vous pouvez générer la chaîne d'un nombre en faisant, par exemple :

     if len(str(number)) == 2 and  number > 20:
word_number = tens[str(number)[0]]+' '+units[str(number)[0]]

    Vous devez vérifier si le dernier chiffre n'est pas un zéro et ainsi de suite.. classique de la valeur de la vérification.

    Il rappelle le projet euler défi (problème 17).. vous devriez essayer de trouver quelques solutions à ce sujet

    Espère que cela aide

    InformationsquelleAutor Jeremy D
  14. 0
    #This valid till 4 digit number
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', 100:'hundred', 1000:'thousand'}
def my_fun(num):
list = []
num_len = len(str(num)) - 1
while num_len > 0 and num > 0:
while num_len > 0 and num > 0:
if num in numbers and num < 1000:
list.append(numbers[num])
num_len = 0
elif num < 100:
list.extend([numbers[num - num%10], numbers[num%10]])
num_len = 0
else:
quotent = num//10**num_len # 4567//1000= 4
num = num % 10**num_len #4567%1000 =567
if quotent != 0 :
list.append(numbers[quotent])
list.append(numbers[10**num_len])
else:
list.append(numbers[num])
num_len -= 1
return ' '.join(list)
    • Échoue pour seul chiffre entiers comme les 5, 6.
    • il va travailler pour seulement 4 chiffres
    InformationsquelleAutor Singhak