[Python] Konvertiert natürliche Zahlen in Ordnungszahlen

Contents Dies ist eine Methode zum Konvertieren einer natürlichen Anzahl von Ganzzahltypen in eine Ordnungszahl von Zeichenfolgentypen (0., 1., 2., 3., ..). Hier ist auch 0 in der natürlichen Zahl enthalten. Jeder Code kann aus dem [GitHub-Repository] heruntergeladen werden (https://github.com/lisphilar/article_qiita/tree/master/python/02_n-th_string).

Rule Berücksichtigen Sie vor der Implementierung zunächst die Regeln unter Bezugnahme auf Liste der Notationen und Lesungen der englischen Reihenfolge 1 bis 1000.

1. Das Ordnungssuffix (die Zeichenfolge nach der Nummer) ist grundsätzlich "th"! (Grob)
2. Wenn die letzte Ziffer 1 ist, ist sie ausnahmsweise "st", wenn sie 2 ist, ist sie "nd" und wenn sie 3 ist, ist sie "rd".
3. Wenn die letzten beiden Ziffern 11 sind, ist dies als Ausnahme von der Ausnahmeregel "th" (elftes).

Lösungen

Codieren Sie die oben genannten Regeln der Reihe nach und überarbeiten Sie sie schließlich (organisieren Sie den Code, ohne das Verhalten zu ändern).

Zu verwendendes Paket:

#Standardbibliothek
from collections import defaultdict

1. Grundsätzlich "th"

Verwenden des Sammlungspakets defaultdict [^ 1],

[^ 1]: Verwendung von Python defaultdict

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

#Wahllos"th"Gib es zurück
print(int2ordinal_1(0))
# -> '0th'
print(int2ordinal_1(1))
# -> '1th':Entspricht Regel 2,Richtig 1 ..'
print(int2ordinal_1(11))
# -> '11th':Entspricht Regel 3

2. "st", wenn die letzte Ziffer 1 ist, "nd", wenn die letzte Ziffer 2 ist, "rd", wenn die letzte Ziffer 3 ist.

Aktualisieren Sie das Wörterbuch.

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

Ändern Sie es dann, um die Reihenfolge basierend auf der letzten Ziffer des Eingabewerts zu bestimmen.

mod = num % 10
suffix = ordinal_dict[mod]

Wenn Sie dies zur Verarbeitung innerhalb der Funktion hinzufügen,

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':Entspricht Regel 3,Richtig 11 ..'

3. "th", wenn die letzten 2 Ziffern 11 sind

Wenn Sie durch 100 teilen und der Rest 11 ist, können Sie "th" zurückgeben

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

Wenn Sie dies zur Verarbeitung innerhalb der Funktion hinzufügen,

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

Es ist kein zeitaufwändiger Prozess, also nur ein Bonus.

"num% 100 == 11" ist dasselbe wie "der Rest, wenn der Quotient" num // 10 "durch 10 geteilt wird, ist 1".

#Vorher ändern
mod = num % 10
if num % 100 == 11:
    suffix = "th"
else:
    suffix = ordinal_dict[mod]
#Nach der veränderung
q = num // 10
mod = num % 10
if q % 10 == 1:
    suffix = "th"
else:
    suffix = ordinal_dict[mod]

Zusätzlich werden Quotient und Rest sofort mit der Funktion divmod berechnet.

Geben Sie außerdem die if-else-Anweisung in einer Zeile ein. Diesmal ist der Effekt schwach, aber da die Anzahl der Schreibvorgänge für das Algebra-Suffix reduziert ist, können Fehler reduziert werden.

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

Wenn Sie dies zur Verarbeitung innerhalb der Funktion hinzufügen,

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'

Ausgefülltes Formular: Eine Funktion, die eine Bestellung zurückgibt

Es ist wie folgt, wenn die Typprüfung des Arguments hinzugefügt wird.

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}"

Ausführungsbestätigung:

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

Eine andere Lösung (Methode ohne Standarddiktat)

Ich werde die Methode ohne Verwendung von defaultdict einführen, was von @shiracamus kommentiert wurde.

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'

Kombination der Negativform mit und ...

Bisher ist es schwer vorstellbar, aber die Verwendung von "oder" für die numerische Zuweisung ist praktisch. Sie können es beispielsweise verwenden, wenn Sie eine leere Liste von Standardargumenten für eine Funktion angeben möchten. (Beachten Sie, dass die Einstellung def func (x = []): x.append (0); return x usw. im Argument der Funktion zu unerwartetem Verhalten führt![^ 2])

[^ 2]: Beachten Sie, dass der Standardwert des [Python] -Arguments die Auswertung bei der Definition ist

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

Wenn values None, False oder leer ist, wird die leere Liste [] zugewiesen. Andernfalls wird das Argument "values" unverändert verwendet.

Nachwort

So kann Python natürliche Zahlen in Ordnungszahlen umwandeln!