¿Hay una biblioteca para convertir un entero a first/second/third

Question

Tengo una lista de enteros? ¿Hay una biblioteca para convertirlos en una clasificación de texto sin formato? IE: 1,2,3 -> "primero, segundo, tercero"?

Answer 1

¿Qué tan alto está planeando ir? (¿Alguna vez se espera más altos que, por ejemplo, "XX"?)

tal vez sólo necesita un dict,

nth = { 
    1: "first", 
    2: "second", 
    3: "third", 
    4: "fourth" 
    # etc 
} 

Answer 2

Dependiendo de su situación, puede que le resulte útil para retener la parte entera y añadir " st "," nd "," rd "y" th ". Si es así, aquí hay un algoritmo simple:

NOTA: Este algoritmo está escrito en Java. No sé Python. Cualquiera que quiera volver a escribirlo en Python, sea mi invitado.

public static String appendInt(int number) { 
    String value = String.valueOf(number); 
    if(value.length() > 1) { 
     // Check for special case: 11 - 13 are all "th". 
     // So if the second to last digit is 1, it is "th". 
     char secondToLastDigit = value.charAt(value.length()-2); 
     if(secondToLastDigit == '1') 
      return "th"; 
    } 
    char lastDigit = value.charAt(value.length()-1); 
    switch(lastDigit) { 
     case '1': 
      return "st"; 
     case '2': 
      return "nd"; 
     case '3': 
      return "rd"; 
     default: 
      return "th"; 
    } 
} 

Así

System.out.println(1 + appendInt(1)); 
System.out.println(2 + appendInt(2)); 
System.out.println(3 + appendInt(3)); 
System.out.println(4 + appendInt(4)); 
System.out.println(5 + appendInt(5)); 
System.out.println(11 + appendInt(11)); 
System.out.println(21 + appendInt(21)); 

pantallas

1st 
2nd 
3rd 
4th 
5th 
11th 
21st 

Answer 3

no puedo comentar sobre el post de ryvantage debido puntos, pero me escribió el mismo código para Python:

def appendInt(num): 
    if num > 9: 
     secondToLastDigit = str(num)[-2] 
     if secondToLastDigit == '1': 
      return 'th' 
    lastDigit = num % 10 
    if (lastDigit == 1): 
     return 'st' 
    elif (lastDigit == 2): 
     return 'nd' 
    elif (lastDigit == 3): 
     return 'rd' 
    else: 
     return 'th' 



def appendInt2(num): 
    value = str(num) 
    if len(value) > 1: 
     secondToLastDigit = value[-2] 
     if secondToLastDigit == '1': 
      return 'th' 
    lastDigit = value[-1] 
    if (lastDigit == '1'): 
     return 'st' 
    elif (lastDigit == '2'): 
     return 'nd' 
    elif (lastDigit == '3'): 
     return 'rd' 
    else: 
     return 'th' 

El el segundo es más una transmisión directa mento, pero he encontrado que la primera variación es considerablemente más rápido:

Vie Ago 28 de 2015 11:48:13 resulta

  300000005 function calls in 151.561 seconds 

    Ordered by: call count, name/file/line 

    ncalls tottime percall cumtime percall filename:lineno(function) 
100000000 6.674 0.000 6.674 0.000 {len} 
100000000 43.064 0.000 43.064 0.000 test.py:7(appendInt) 
100000000 66.664 0.000 73.339 0.000 test.py:22(appendInt2) 
     1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} 
     1 0.000 0.000 151.561 151.561 <string>:1(<module>) 
     1 0.000 0.000 151.561 151.561 test.py:51(main) 
     1 16.737 16.737 59.801 59.801 test.py:39(test1) 
     1 18.421 18.421 91.759 91.759 test.py:45(test2) 

Answer 4

De manera similar a la vena @Hugh Bothwellwas following, no sólo el uso de un dict (ya que su llaves ya están muy bien y numérica), he creado la siguiente "un trazador de líneas":

ordinal=lambda x:["first","second","third","fourth","fifth","sixth","seventh","eighth","ninth","tenth","eleventh","twelfth"][x-1] 

que cubre todos los casos hasta 12. Si y Necesitas algo más alto (en cientos, etc.), entonces probablemente necesites algo más sólido (con recursión, imagino, etc.).

Answer 5

Un agradable y simple reescritura:

def num_to_ith(num): 
    """1 becomes 1st, 2 becomes 2nd, etc.""" 
    value    = str(num) 
    before_last_digit = value[-2] 
    last_digit  = value[-1] 
    if len(value) > 1 and before_last_digit == '1': return value +'th' 
    if last_digit == '1': return value + 'st' 
    if last_digit == '2': return value + 'nd' 
    if last_digit == '3': return value + 'rd' 
    return value + 'th' 

Answer 6

El paquete pitón inflect tiene un método para la conversión de números en los ordinales:

import inflect 
p = inflect.engine() 

for i in range(1,25,5): 
    print(p.ordinal(i)) 

pantallas:

1st 
6th 
11th 
16th 
21st 

Answer 7

Mi código para este utiliza lista, módulo entero para encontrar el primer dígito y la división de piso entero para verificar fuera de ru Le 11 a través de 13.

def stringify(number): 
     suffix = ["th","st","nd","rd","th","th","th","th","th","th"] 
     return str(number) + suffix[number % 10] if str(number // 10)[-1] != 1 else str(number) + "th"   

La última línea más legible:

if str(number // 10)[-1] != '1':  
     return str(number) + suffix[number % 10] 
    else: 
     return str(number) + "th" 

Básicamente, estoy comprobando el segundo dígito de 1 * que indica un posible 11ª, 12ª, 13ª interruptor de la regla.Para los encargados de la regla, la lista se referencia por el resto de una división por 10 (operador de módulo).

No he probado la eficacia del código, y la comprobación de la longitud es mucho más legible, pero esto funciona.

* (str (número) [- 2]. Genera una IndexError si la entrada es un único dígito Uso de división piso en números enteros siempre resulta en al menos 1 dígitos lo que la cadena siempre tendrá un -1 índice)