Truncado a tres decimales en Python

¿Cómo obtengo 1324343032.324?

Como puede ver a continuación, lo siguiente no funciona:

>>1324343032.324325235 * 1000 / 1000 1324343032.3243253 >>int(1324343032.324325235 * 1000) / 1000.0 1324343032.3239999 >>round(int(1324343032.324325235 * 1000) / 1000.0,3) 1324343032.3239999 >>str(1324343032.3239999) '1324343032.32' 

'%.3f'%(1324343032.324325235)

Utilice un float() adicional float() a su alrededor si desea conservarlo como un flotador.

Puede usar la siguiente función para truncar un número a un número determinado de decimales:

 import math def truncate(number, digits) -> float: stepper = pow(10.0, digits) return math.trunc(stepper * number) / stepper 

Uso:

 >> truncate(1324343032.324325235, 3) >> 1324343032.324 

He encontrado otra solución (debe ser más eficiente que las soluciones de “brujería de cuerdas”):

 >>> import decimal # By default rounding setting in python is decimal.ROUND_HALF_EVEN >>> decimal.getcontext().rounding = decimal.ROUND_DOWN >>> c = decimal.Decimal(34.1499123) # By default it should return 34.15 due to '99' after '34.14' >>> round(c,2) Decimal('34.14') >>> float(round(c,2)) 34.14 >>> print(round(c,2)) 34.14 

Acerca del módulo de decimales

Acerca de las configuraciones de redondeo

Qué tal esto:

 In [1]: '%.3f' % round(1324343032.324325235 * 1000 / 1000,3) Out[1]: '1324343032.324' 

Posible duplicado de round () en Python no parece estar redondeando correctamente

[EDITAR]

Dados los comentarios adicionales, creo que querrás hacer:

 In : Decimal('%.3f' % (1324343032.324325235 * 1000 / 1000)) Out: Decimal('1324343032.324') 

La precisión del punto flotante no va a ser lo que quieres:

 In : 3.324 Out: 3.3239999999999998 

(Todos los ejemplos son con Python 2.6.5)

Usa el módulo decimal. Pero si debe usar flotadores y, de alguna manera, obligarlos a obtener un número determinado de puntos decimales que se convierten en una cuerda, un tema (pero me parece torpe) de hacerlo.

 >>> q = 1324343032.324325235 * 1000 / 1000 >>> a = "%.3f" % q >>> a '1324343032.324' >>> b = float(a) >>> b 1324343032.324 

Asi que:

 float("%3.f" % q) 

‘% .3f’% (1324343032.324325235)

Está bien solo en este caso particular.

Simplemente cambia el número un poco:

1324343032.324 7 25235

Y entonces:

 '%.3f'%(1324343032.324725235) 

te da 1324343032.325

Intenta esto en su lugar:

 def trun_n_d(n,d): s=repr(n).split('.') if (len(s)==1): return int(s[0]) return float(s[0]+'.'+s[1][:d]) 

Otra opción para trun_n_d :

 def trun_n_d(n,d): dp = repr(n).find('.') #dot position if dp == -1: return int(n) return float(repr(n)[:dp+d+1]) 

Otra opción más (una oneliner uno) para trun_n_d [esto, asume que ‘ n ‘ es una cadena y ‘ d ‘ es una int ]:

 def trun_n_d(n,d): return ( n if not n.find('.')+1 else n[:n.find('.')+d+1] ) 

trun_n_d te da el resultado deseado en Python 2.7 y Python 3.6

trun_n_d (1324343032.324325235,3) devuelve 1324343032.324

Asimismo, trun_n_d (1324343032.324 7 25235,3) devuelve 1324343032.324.


Nota 1 En Python 3.6 (y, probablemente, en Python 3.x) algo como esto, funciona bien:

 def trun_n_d(n,d): return int(n*10**d)/10**d 

Pero, de esta manera, el fantasma redondeado siempre está merodeando por ahí.

Nota 2 En situaciones como esta, debido a los elementos internos de python , como el redondeo y la falta de precisión, trabajar con n como una cadena es mucho mejor que usar su contraparte int ; Siempre puedes lanzar tu número a un flotador al final.

El enlace de Almo explica por qué sucede esto. Para resolver el problema, usa la biblioteca decimal .

Creo que usar la función de format es una mala idea. Por favor, vea el siguiente. Redondea el valor. Yo uso Python 3.6.

 >>> '%.3f'%(1.9999999) '2.000' 

Use una expresión regular en su lugar:

 >>> re.match(r'\d+.\d{3}', str(1.999999)).group(0) '1.999' 

Después de buscar una manera de resolver este problema, sin cargar ningún módulo de Python 3 ni operaciones matemáticas adicionales, resolví el problema utilizando solo str.format () e .float (). Creo que esta forma es más rápida que usar otras operaciones matemáticas, como en la solución más común. Necesitaba una solución rápida porque trabajo con un conjunto de datos muy grande y por eso funciona muy bien aquí.

 def truncate_number(f_number, n_decimals): strFormNum = "{0:." + str(n_decimals+5) + "f}" trunc_num = float(strFormNum.format(f_number)[:-5]) return(trunc_num) # Testing the 'trunc_num()' function test_num = 1150/252 [(idx, truncate_number(test_num, idx)) for idx in range(0, 20)] 

Devuelve el siguiente resultado:

 [(0, 4.0), (1, 4.5), (2, 4.56), (3, 4.563), (4, 4.5634), (5, 4.56349), (6, 4.563492), (7, 4.563492), (8, 4.56349206), (9, 4.563492063), (10, 4.5634920634), (11, 4.56349206349), (12, 4.563492063492), (13, 4.563492063492), (14, 4.56349206349206), (15, 4.563492063492063), (16, 4.563492063492063), (17, 4.563492063492063), (18, 4.563492063492063), (19, 4.563492063492063)] 

También puedes usar:

 import math nValeur = format(float(input('Quelle valeur ? ')), '.3f') 

En Python 3.6 funcionaría.

Tal vez de esta manera:

 def myTrunc(theNumber, theDigits): myDigits = 10 ** theDigits return (int(theNumber * myDigits) / myDigits) 
 >>> float(1324343032.324325235) * float(1000) / float(1000) 1324343032.3243253 >>> round(float(1324343032.324325235) * float(1000) / float(1000), 3) 1324343032.324