¿Cómo obtener números después del punto decimal?

¿Cómo obtengo los números después de un punto decimal?

Por ejemplo, si lo tengo 5.55, ¿cómo lo consigo .55?

Un enfoque fácil para ti:

number_dec = str(number-int(number))[1:]

5.55 % 1

Tenga en cuenta que esto no le ayudará con los problemas de redondeo de coma flotante. Es decir, puede obtener:

0.550000000001

O de lo contrario, un poco por debajo del 0,55 que espera.

Utilice modf :

>>> import math
>>> frac, whole = math.modf(2.5)
>>> frac
0.5
>>> whole
2.0

Qué pasa:

a = 1.3927278749291
b = a - int(a)

b
>> 0.39272787492910011

O, usando numpy:

import numpy
a = 1.3927278749291
b = a - numpy.fix(a)

Con el decimalmódulo de la biblioteca estándar, puede conservar la precisión original y evitar problemas de redondeo de punto flotante:

>>> from decimal import Decimal
>>> Decimal('4.20') % 1
Decimal('0.20')

Como algunas notas en los comentarios, floatprimero tendrá que convertir los mensajes nativos en cadenas.

Prueba el módulo:

5.55%1 = 0.54999999999999982

similar a la respuesta aceptada, un enfoque aún más fácil usando cadenas sería

def number_after_decimal(number1):
    number = str(number1)
    if 'e-' in number: # scientific notation
        number_dec = format(float(number), '.%df'%(len(number.split(".")[1].split("e-")[0])+int(number.split('e-')[1])))
    elif "." in number: # quick check if it is decimal
        number_dec = number.split(".")[1]
    return number_dec

import math
orig = 5.55
whole = math.floor(orig)    # whole = 5.0
frac = orig - whole         # frac = 0.55

>>> n=5.55
>>> if "." in str(n):
...     print "."+str(n).split(".")[-1]
...
.55

Esta es una solución que probé:

num = 45.7234
(whole, frac) = (int(num), int(str(num)[(len(str(int(num)))+1):]))

A veces, los ceros finales son importantes

In [4]: def split_float(x):
   ...:     '''split float into parts before and after the decimal'''
   ...:     before, after = str(x).split('.')
   ...:     return int(before), (int(after)*10 if len(after)==1 else int(after))
   ...: 
   ...: 

In [5]: split_float(105.10)
Out[5]: (105, 10)

In [6]: split_float(105.01)
Out[6]: (105, 1)

In [7]: split_float(105.12)
Out[7]: (105, 12)

Con solo usar la división de operador simple '/' y la división de piso '//' , puede obtener fácilmente la parte fraccionaria de cualquier flotante dado.

number = 5.55

result = (number/1) - (number//1)

print(result)

Utilice floor y reste el resultado del número original:

>> import math #gives you floor.
>> t = 5.55 #Give a variable 5.55
>> x = math.floor(t) #floor returns t rounded down to 5..
>> z = t - x #z = 5.55 - 5 = 0.55

Los números flotantes no se almacenan en formato decimal (base10). Lea la documentación de Python sobre esto para saber por qué. Por lo tanto, no es aconsejable obtener una representación en base 10 de un flotante.

Ahora existen herramientas que permiten el almacenamiento de datos numéricos en formato decimal. A continuación se muestra un ejemplo con la Decimalbiblioteca.

from decimal import *

x = Decimal('0.341343214124443151466')
str(x)[-2:] == '66'  # True

y = 0.341343214124443151466
str(y)[-2:] == '66'  # False

Ejemplo:

import math
x = 5.55
print((math.floor(x*100)%100))

Esto le dará dos números después del punto decimal, 55 de ese ejemplo. Si necesita un número, reduce en 10 los cálculos anteriores o aumenta dependiendo de cuántos números desee después del decimal.

import math

x = 1245342664.6
print( (math.floor(x*1000)%1000) //100 )

Definitivamente funcionó

Qué pasa:

a = 1.234
b = a - int(a)
length = len(str(a))

round(b, length-2)

Salida:
print(b)
0.23399999999999999
round(b, length-2)
0.234

Dado que la ronda se envía a la longitud de la cadena de decimales ('0.234'), podemos simplemente menos 2 para no contar el '0.' y calcular el número deseado de puntos decimales. Esto debería funcionar la mayoría de las veces, a menos que tenga muchos lugares decimales y el error de redondeo al calcular b interfiera con el segundo parámetro de round.

Es posible que desee probar esto:

your_num = 5.55
n = len(str(int(your_num)))
float('0' + str(your_num)[n:])

Regresará 0.55.

number=5.55
decimal=(number-int(number))
decimal_1=round(decimal,2)
print(decimal)
print(decimal_1)

salida: 0.55

Vea lo que hago a menudo para obtener números después del punto decimal en Python 3:

a=1.22
dec=str(a).split('.')
dec= int(dec[1])

Si está usando pandas:

df['decimals'] = df['original_number'].mod(1)

Otra opción sería usar el remódulo con re.findallo re.search:

import re


def get_decimcal(n: float) -> float:
    return float(re.search(r'\.\d+', str(n)).group(0))


def get_decimcal_2(n: float) -> float:
    return float(re.findall(r'\.\d+', str(n))[0])


def get_int(n: float) -> int:
    return int(n)


print(get_decimcal(5.55))
print(get_decimcal_2(5.55))
print(get_int(5.55))

Salida

0.55
0.55
5

Si desea simplificar / modificar / explorar la expresión, se explica en el panel superior derecho de regex101.com . Si lo desea, también puede ver en este enlace cómo coincidiría con algunas entradas de muestra.

Fuente

¿Cómo deshacerse de números flotantes adicionales en la resta de Python?

Descubrí que números realmente grandes con partes fraccionarias realmente grandes pueden causar problemas al usar el módulo 1 para obtener la fracción.

import decimal

>>> d = decimal.Context(decimal.MAX_PREC).create_decimal(
... '143000000000000000000000000000000000000000000000000000000000000000000000000000.1231200000000000000002013210000000'
... )
...
>>> d % 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
decimal.InvalidOperation: [<class 'decimal.DivisionImpossible'>]

En lugar de eso, tomé la parte integral y la resté primero para ayudar a simplificar el resto.

>>> d - d.to_integral()
Decimal('0.1231200000000000000002013210')

Otro ejemplo usando modf

from math import modf
number = 1.0124584

# [0] decimal, [1] integer
result = modf(number)
print(result[0])
# output = 0124584
print(result[1])
# output = 1

Una solución es usar módulo y redondeo.

import math

num = math.fabs(float(5.55))
rem = num % 1

rnd_by =   len(str(num)) - len(str(int(num))) - 1

print(str(round(rem,rnd_by)))

Tu salida será 0.55

Puedes usar esto:

number = 5.55
int(str(number).split('.')[1])

Otra solución loca es (sin convertir en una cadena):

number = 123.456
temp = 1

while (number*temp)%10 != 0:
    temp = temp *10
    print temp
    print number

temp = temp /10
number = number*temp
number_final = number%temp
print number_final