[Python] Convertit les nombres naturels en nombres ordinaux

Contents Il s'agit d'une méthode pour convertir un nombre naturel de type entier en un nombre ordinal de type chaîne (0e, 1er, 2e, 3e, ..). Ici, 0 est également inclus dans le nombre naturel. Chaque code peut être téléchargé depuis le référentiel GitHub.

Rule Avant la mise en œuvre, considérez d'abord les règles en vous référant à Liste des notations et lectures de l'ordre anglais 1 à 1000.

1. Le suffixe de commande (la chaîne qui suit le nombre) est essentiellement "th"! (Grossièrement)
2. Par exception, si le dernier chiffre est 1, ce sera "st", s'il est 2, ce sera "nd", et s'il est 3, ce sera "rd".
3. À titre d'exception à la règle d'exception, si les deux derniers chiffres sont 11, ce sera "th" (onzième).

Solution

Codez les règles ci-dessus dans l'ordre, et enfin refactorisez (organisez le code sans changer le comportement).

Paquet à utiliser:

#Bibliothèque standard
from collections import defaultdict

1. Fondamentalement "th"

En utilisant le package de collections defaultdict [^ 1],

[^ 1]: Comment utiliser Python defaultdict

def int2ordinal_1(num):
    ordinal_dict = defaultdict(lambda: "th")
    suffix = ordinal_dict[num]
    return f"{num}{suffix}"

#Sans discernement"th"rends le
print(int2ordinal_1(0))
# -> '0th'
print(int2ordinal_1(1))
# -> '1th':Correspond à la règle 2,Correctement 1er'
print(int2ordinal_1(11))
# -> '11th':Correspond à la règle 3

2. "st" si le dernier chiffre est 1, "nd" si le dernier chiffre est 2, "rd" si le dernier chiffre est 3.

Mettez à jour le dictionnaire.

ordinal_dict.update({1: "st", 2: "nd", 3: "rd"})

Modifiez-le ensuite pour déterminer l'ordre en fonction du dernier chiffre de la valeur d'entrée.

mod = num % 10
suffix = ordinal_dict[mod]

Si vous ajoutez ceci au traitement à l'intérieur de la fonction,

def int2ordinal_2(num):
    ordinal_dict = defaultdict(lambda: "th")
    ordinal_dict.update({1: "st", 2: "nd", 3: "rd"})
    mod = num % 10
    suffix = ordinal_dict[mod]
    return f"{num}{suffix}"

print(int2ordinal_2(0))
# -> '0th'
print(int2ordinal_2(1))
# -> '1st'
print(int2ordinal_2(11))
# -> '11st':Correspond à la règle 3,Correctement 11e'

3. "th" si les 2 derniers chiffres sont 11

Si vous divisez par 100 et que le reste est 11, vous pouvez renvoyer "th", donc

if num % 100 == 11:
    suffix = "th"
else:
    suffix = ordinal_dict[mod]

Si vous ajoutez ceci au traitement à l'intérieur de la fonction,

def int2ordinal_3(num):
    ordinal_dict = defaultdict(lambda: "th")
    ordinal_dict.update({1: "st", 2: "nd", 3: "rd"})
    mod = num % 10
    if num % 100 == 11:
        suffix = "th"
    else:
        suffix = ordinal_dict[mod]
    return f"{num}{suffix}"

print(int2ordinal_3(0))
# -> '0th'
print(int2ordinal_3(1))
# -> '1st'
print(int2ordinal_3(11))
# -> '11th'

4. Refactoring

Ce n'est pas un processus qui prend du temps, c'est donc juste un bonus.

«num% 100 == 11» équivaut à «le reste lorsque le quotient« num // 10 »est divisé par 10 est 1».

#Changer avant
mod = num % 10
if num % 100 == 11:
    suffix = "th"
else:
    suffix = ordinal_dict[mod]
#Après le changement
q = num // 10
mod = num % 10
if q % 10 == 1:
    suffix = "th"
else:
    suffix = ordinal_dict[mod]

De plus, le quotient et le reste sont calculés en même temps avec la fonction divmod.

Faites également l'instruction if-else sur une seule ligne. Cette fois, l'effet est faible, mais comme le nombre de fois où écrire l'algèbre «suffixe» est réduit, les erreurs peuvent être réduites.

q, mod = divmod(num, 10)
suffix = "th" if q % 10 == 1 else ordinal_dict[mod]

Si vous ajoutez ceci au traitement à l'intérieur de la fonction,

def int2ordinal_4(num):
    ordinal_dict = defaultdict(lambda: "th")
    ordinal_dict.update({1: "st", 2: "nd", 3: "rd"})
    q, mod = divmod(num, 10)
    suffix = "th" if q % 10 == 1 else ordinal_dict[mod]
    return f"{num}{suffix}"

print(int2ordinal_4(0))
# -> '0th'
print(int2ordinal_4(1))
# -> '1st'
print(int2ordinal_4(11))
# -> '11th'

Formulaire complété: une fonction qui renvoie une commande

C'est comme suit lorsque la vérification de type de l'argument est ajoutée.

ordinal_func.py

def int2ordinal(num):
    """
    Convert a natural number to a ordinal number.

    Args:
        num (int): natural number

    Returns:
        str: ordinal number, like 0th, 1st, 2nd,...

    Notes:
        Zero can be used as @num argument.
    """
    if not isinstance(num, int):
        raise TypeError(
            f"@num must be integer, but {num} was applied.")
    if num < 0:
        raise ValueError(
            f"@num must be over 0, but {num} was applied.")
    ordinal_dict = defaultdict(lambda: "th")
    ordinal_dict.update({1: "st", 2: "nd", 3: "rd"})
    q, mod = divmod(num, 10)
    suffix = "th" if q % 10 == 1 else ordinal_dict[mod]
    return f"{num}{suffix}"

Confirmation d'exécution:

ordinal_func.py

print(int2ordinal(0)) # 0th
print(int2ordinal(1)) # 1st
print(int2ordinal(2)) # 2nd
print(int2ordinal(3)) # 3rd
print(int2ordinal(4)) # 4th
print(int2ordinal(11)) # 11th
print(int2ordinal(21)) # 21st
print(int2ordinal(111)) # 111th
print(int2ordinal(121)) # 121st

Une autre solution (méthode sans defaultdict)

Je présenterai la méthode sans utiliser defaultdict, qui a été commenté par @shiracamus.

def int2ordinal_5(num):
    ordinal_dict = {1: "st", 2: "nd", 3: "rd"}
    q, mod = divmod(num, 10)
    suffix = q % 10 != 1 and ordinal_dict.get(mod) or "th"
    return f"{num}{suffix}"

print(int2ordinal_5(0))
# -> '0th'
print(int2ordinal_5(1))
# -> '1st'
print(int2ordinal_5(11))
# -> '11th'

Combiner la forme négative avec ʻet` ...

C'est difficile à trouver, mais utiliser «ou» pour l'affectation numérique est pratique. Par exemple, vous pouvez l'utiliser lorsque vous souhaitez donner une liste vide d'arguments par défaut pour une fonction. (Notez que définir def func (x = []): x.append (0); return x etc. dans l'argument de la fonction provoquera un comportement inattendu![^ 2])

[^ 2]: Notez que la valeur par défaut de l'argument [python] est l'évaluation à la définition

def func(values=None):
    values = values or []
    if not isinstance(values, list):
        raise TypeError(f"@values must be a list or None, but {values} was applied.")
    values.append(0)
    return values

Si values est None, False ou vide, la liste vide[] ʻest assignée. Sinon, l'argumentvalues` est utilisé tel quel.

Épilogue

C'est ainsi que Python peut convertir des nombres naturels en nombres ordinaux!