Come ottenere i numeri dopo il punto decimale?

Come ottengo i numeri dopo un punto decimale?

Ad esempio, se ce l'ho 5.55, come posso ottenerlo .55?

Un approccio facile per te:

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

5.55 % 1

Tieni presente che questo non ti aiuterà con i problemi di arrotondamento in virgola mobile. Vale a dire, potresti ottenere:

0.550000000001

O altrimenti un po 'fuori dallo 0,55 che ti aspetti.

Usa modf :

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

Che dire:

a = 1.3927278749291
b = a - int(a)

b
>> 0.39272787492910011

Oppure, usando numpy:

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

Utilizzando il decimalmodulo della libreria standard, è possibile mantenere la precisione originale ed evitare problemi di arrotondamento in virgola mobile:

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

Come Kindall note nei commenti, dovrete convertire i nativi floats in stringhe prima.

Prova Modulo:

5.55%1 = 0.54999999999999982

simile alla risposta accettata, sarebbe un approccio ancora più semplice usando le stringhe

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

Questa è una soluzione che ho provato:

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

A volte gli zeri finali contano

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)

Usando semplicemente la divisione dell'operatore "/" e la divisione del piano "//" puoi ottenere facilmente la parte frazionaria di un dato float.

number = 5.55

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

print(result)

Usa floor e sottrai il risultato dal numero originale:

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

I numeri in virgola mobile non vengono memorizzati in formato decimale (base10). Leggi la documentazione di Python su questo per capire perché. Pertanto, non è consigliabile ottenere una rappresentazione in base10 da un float.

Ora ci sono strumenti che consentono l'archiviazione di dati numerici in formato decimale. Di seguito è riportato un esempio che utilizza la Decimallibreria.

from decimal import *

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

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

Esempio:

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

Questo ti darà due numeri dopo il punto decimale, 55 da quell'esempio. Se hai bisogno di un numero, riduci di 10 i calcoli sopra o aumenta a seconda di quanti numeri vuoi dopo il decimale.

import math

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

Sicuramente ha funzionato

Che dire:

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

round(b, length-2)

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

Poiché il round viene inviato alla lunghezza della stringa di decimali ("0,234"), possiamo semplicemente meno 2 per non contare lo "0" e calcolare il numero di punti decimali desiderato. Questo dovrebbe funzionare la maggior parte delle volte, a meno che tu non abbia molte cifre decimali e l'errore di arrotondamento durante il calcolo di b interferisca con il secondo parametro di round.

Potresti provare questo:

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

Tornerà 0.55.

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

uscita: 0,55

Guarda cosa faccio spesso per ottenere numeri dopo il punto decimale in Python 3:

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

Se stai usando i panda:

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

Un'altra opzione potrebbe essere quella di utilizzare il remodulo 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))

Produzione

0.55
0.55
5

Se desideri semplificare / modificare / esplorare l'espressione, è stato spiegato nel pannello in alto a destra di regex101.com . Se lo desideri, puoi anche guardare in questo link , come corrisponderebbe ad alcuni input di esempio.

fonte

Come sbarazzarsi di numeri mobili aggiuntivi nella sottrazione di Python?

Ho scoperto che numeri molto grandi con parti frazionarie molto grandi possono causare problemi quando si utilizza il modulo 1 per ottenere la frazione.

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'>]

Invece ho preso la parte integrale e l'ho sottratta prima per semplificare il resto.

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

Un altro esempio di utilizzo di 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 soluzione sta usando modulo e arrotondamento.

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)))

Il tuo output sarà 0,55

Puoi usare questo:

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

Un'altra soluzione folle è (senza convertire in una stringa):

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