Les nombres ordinaux de remplacement

Comment à ce sujet:

suf = lambda n: "%d%s"%(n,{1:"st",2:"nd",3:"rd"}.get(n if n<20 else n%10,"th"))
print [suf(n) for n in xrange(1,32)]

['1st', '2nd', '3rd', '4th', '5th', '6th', '7th', '8th', '9th', '10th',
 '11th', '12th', '13th', '14th', '15th', '16th', '17th', '18th', '19th',
 '20th', '21st', '22nd', '23rd', '24th', '25th', '26th', '27th', '28th',
 '29th', '30th', '31st']

Je voulais utiliser des ordinaux pour un projet de mine et après quelques prototypes je pense que cette méthode, bien que pas un petit travail pour tout entier positif, oui tout entier.

Il fonctionne par determiniting si le nombre est au-dessus ou en dessous de 20, si le nombre est inférieur à 20, il va tourner à la int 1 dans la chaîne 1er , 2 , 2e, 3, 3e, et le reste sera "st" a été ajoutée.

Pour les numéros de plus de 20, il va prendre le dernier et l'avant dernier chiffres, que j'ai appelé la les dizaines et les unité de, respectivement, et de les tester pour voir ce qu'il faut ajouter à ce nombre.

C'est en python par la manière, donc je ne sais pas si d'autres langues seront en mesure de trouver le dernier ou l'avant-dernier caractère d'une chaîne, s'ils font cela devrait se traduire assez facilement.

def o(numb):
    if numb < 20: #determining suffix for < 20
        if numb == 1: 
            suffix = 'st'
        elif numb == 2:
            suffix = 'nd'
        elif numb == 3:
            suffix = 'rd'
        else:
            suffix = 'th'  
    else:   #determining suffix for > 20
        tens = str(numb)
        tens = tens[-2]
        unit = str(numb)
        unit = unit[-1]
        if tens == "1":
           suffix = "th"
        else:
            if unit == "1": 
                suffix = 'st'
            elif unit == "2":
                suffix = 'nd'
            elif unit == "3":
                suffix = 'rd'
            else:
                suffix = 'th'
    return str(numb)+ suffix

J'ai appelé la fonction "o" pour la facilité d'utilisation et peut être appelé par l'importation du nom de fichier que j'ai appelé "ordinal" par l'importation ordinale puis ordinale.o(nombre).

Laissez-moi savoir ce que vous en pensez 😀

Une autre solution est l' num2words bibliothèque (pip | github).
Il est particulièrement à l'offre de langues différentes, de sorte que la localisation/internationalisation (aka. l10n/i18n) est un no-brainer.

Utilisation est facile après que vous l'avez installé avec pip install num2words:

from num2words import num2words
# english is default
num2words(4458, to="ordinal_num")
'4458rd'

# examples for other languages
num2words(4458, lang="en", to="ordinal_num")
'4458rd'

num2words(4458, lang="es", to="ordinal_num")
'4458º'

num2words(4458, lang="de", to="ordinal_num")
'4458.'

num2words(4458, lang="id", to="ordinal_num")
'ke-4458'

Bonus:

num2words(4458, lang="en", to="ordinal")
'four thousand, four hundred and fifty-eighth'

Si l'aide de django, vous pouvez faire:

from django.contrib.humanize.templatetags.humanize import ordinal
var = ordinal(number)

(ou utilisez ordinale dans un django modèle que le modèle de filtre il était destiné à être, si l'appelant comme ce à partir de code python qui fonctionne aussi bien)

Si vous n'utilisez pas de django vous pourriez voler leur mise en œuvre qui est très soignée.

Si vous ne souhaitez pas importer un module externe et préfèrent une solution en ligne, puis le suivant est sans doute (un peu) plus lisible que l'on a accepté la réponse:

def suffix(i):
    return {1:"st", 2:"nd", 3:"rd"}.get(i%10*(i%100 not in [11,12,13]), "th"))

Il utilise le dictionnaire .get, comme suggéré par https://codereview.stackexchange.com/a/41300/90593 et https://stackoverflow.com/a/36977549/5069869.

J'ai fait usage de multiplication avec un booléen pour gérer les cas particuliers (11,12,13), sans avoir à lancer une si-bloc. Si la condition (i%100 not in [11,12,13]) évalue à False, le nombre entier 0 et nous obtenons la valeur par défaut 'th' cas.

C'est une alternative en utilisant les options de num2words paquet.

>>> from num2words import num2words
>>> num2words(42, to='ordinal_num')
    '42nd'

Ici est plus compliqué solution que j'ai juste écrit que prend en compte aggravé les ordinaux. Il fonctionne donc à partir de first tout le chemin à nine hundred and ninety ninth. J'en avais besoin pour convertir la chaîne de caractères des noms de rue pour le nombre ordinaux:

import re
from collections import OrderedDict
ONETHS = {
'first': '1ST', 'second': '2ND', 'third': '3RD', 'fourth': '4TH', 'fifth': '5TH', 'sixth': '6TH', 'seventh': '7TH',
'eighth': '8TH', 'ninth': '9TH'
}
TEENTHS = {
'tenth': '10TH', 'eleventh': '11TH', 'twelfth': '12TH', 'thirteenth': '13TH',
'fourteenth': '14TH', 'fifteenth': '15TH', 'sixteenth': '16TH', 'seventeenth': '17TH', 'eighteenth': '18TH',
'nineteenth': '19TH'
}
TENTHS = {
'twentieth': '20TH', 'thirtieth': '30TH', 'fortieth': '40TH', 'fiftieth': '50TH', 'sixtieth': '60TH',
'seventieth': '70TH', 'eightieth': '80TH', 'ninetieth': '90TH',
}
HUNDREDTH = {'hundredth': '100TH'}  # HUNDREDTH not s
ONES = {'one': '1', 'two': '2', 'three': '3', 'four': '4', 'five': '5', 'six': '6', 'seven': '7', 'eight': '8',
'nine': '9'}
TENS = {'twenty': '20', 'thirty': '30', 'forty': '40', 'fifty': '50', 'sixty': '60', 'seventy': '70', 'eighty': '80',
'ninety': '90'}
HUNDRED = {'hundred': '100'}
# Used below for ALL_ORDINALS
ALL_THS = {}
ALL_THS.update(ONETHS)
ALL_THS.update(TEENTHS)
ALL_THS.update(TENTHS)
ALL_THS.update(HUNDREDTH)
ALL_ORDINALS = OrderedDict()
ALL_ORDINALS.update(ALL_THS)
ALL_ORDINALS.update(TENS)
ALL_ORDINALS.update(HUNDRED)
ALL_ORDINALS.update(ONES)
def split_ordinal_word(word):
ordinals = []
if not word:
return ordinals 
for key, value in ALL_ORDINALS.items():
if word.startswith(key):
ordinals.append(key)
ordinals += split_ordinal_word(word[len(key):])
break
return ordinals
def get_ordinals(s):
ordinals, start, end = [], [], []
s = s.strip().replace('-', ' ').replace('and', '').lower()
s = re.sub(' +',' ', s)  # Replace multiple spaces with a single space
s = s.split(' ')
for word in s:
found_ordinals = split_ordinal_word(word)
if found_ordinals:
ordinals += found_ordinals
else:  # else if word, for covering blanks
if ordinals:  # Already have some ordinals
end.append(word)
else:
start.append(word)
return start, ordinals, end
def detect_ordinal_pattern(ordinals):
ordinal_length = len(ordinals)
ordinal_string = '' # ' '.join(ordinals)
if ordinal_length == 1:
ordinal_string = ALL_ORDINALS[ordinals[0]]
elif ordinal_length == 2:
if ordinals[0] in ONES.keys() and ordinals[1] in HUNDREDTH.keys():
ordinal_string = ONES[ordinals[0]] + '00TH'
elif ordinals[0] in HUNDRED.keys() and ordinals[1] in ONETHS.keys():
ordinal_string = HUNDRED[ordinals[0]][:-1] + ONETHS[ordinals[1]]
elif ordinals[0] in TENS.keys() and ordinals[1] in ONETHS.keys():
ordinal_string = TENS[ordinals[0]][0] + ONETHS[ordinals[1]]
elif ordinal_length == 3:
if ordinals[0] in HUNDRED.keys() and ordinals[1] in TENS.keys() and ordinals[2] in ONETHS.keys():
ordinal_string = HUNDRED[ordinals[0]][0] + TENS[ordinals[1]][0] + ONETHS[ordinals[2]]
elif ordinals[0] in ONES.keys() and ordinals[1] in HUNDRED.keys() and ordinals[2] in ALL_THS.keys():
ordinal_string =  ONES[ordinals[0]] + ALL_THS[ordinals[2]]
elif ordinal_length == 4:
if ordinals[0] in ONES.keys() and ordinals[1] in HUNDRED.keys() and ordinals[2] in TENS.keys() and \
ordinals[3] in ONETHS.keys():
ordinal_string = ONES[ordinals[0]] + TENS[ordinals[2]][0] + ONETHS[ordinals[3]]
return ordinal_string

Et voici quelques exemples d'utilisation:

# s = '32 one   hundred and forty-third st toronto, on'
#s = '32 forty-third st toronto, on'
#s = '32 one-hundredth st toronto, on'
#s = '32 hundred and third st toronto, on'
#s = '32 hundred and thirty first st toronto, on'
# s = '32 nine hundred and twenty third st toronto, on'
#s = '32 nine hundred and ninety ninth st toronto, on'
s = '32 sixty sixth toronto, on'
st, ords, en = get_ordinals(s)
print st, detect_ordinal_pattern(ords), en

Gareth code exprimée à l'aide de la moderne .format()

ordinal = lambda n: "{}{}".format(n,"tsnrhtdd"[(n/10%10!=1)*(n%10<4)*n%10::4])