How to get numbers after decimal point?
PythonFloating PointDecimalPython Problem Overview
How do I get the numbers after a decimal point?
For example, if I have 5.55
, how do i get .55
?
Python Solutions
Solution 1 - Python
5.55 % 1
Keep in mind this won't help you with floating point rounding problems. I.e., you may get:
0.550000000001
Or otherwise a little off the 0.55 you are expecting.
Solution 2 - Python
Use modf:
>>> import math
>>> frac, whole = math.modf(2.5)
>>> frac
0.5
>>> whole
2.0
Solution 3 - Python
What about:
a = 1.3927278749291
b = a - int(a)
b
>> 0.39272787492910011
Or, using numpy:
import numpy
a = 1.3927278749291
b = a - numpy.fix(a)
Solution 4 - Python
Using the decimal
module from the standard library, you can retain the original precision and avoid floating point rounding issues:
>>> from decimal import Decimal
>>> Decimal('4.20') % 1
Decimal('0.20')
As kindall notes in the comments, you'll have to convert native float
s to strings first.
Solution 5 - Python
An easy approach for you:
number_dec = str(number-int(number))[1:]
Solution 6 - Python
Try Modulo:
5.55%1 = 0.54999999999999982
Solution 7 - Python
To make it work with both positive and negative numbers:
try abs(x)%1
. For negative numbers, without with abs
, it will go wrong.
5.55 % 1
output 0.5499999999999998
-5.55 % 1
output 0.4500000000000002
Solution 8 - Python
import math
orig = 5.55
whole = math.floor(orig) # whole = 5.0
frac = orig - whole # frac = 0.55
Solution 9 - Python
similar to the accepted answer, even easier approach using strings would be
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
Solution 10 - Python
>>> n=5.55
>>> if "." in str(n):
... print "."+str(n).split(".")[-1]
...
.55
Solution 11 - Python
Just using simple operator division '/' and floor division '//' you can easily get the fraction part of any given float.
number = 5.55
result = (number/1) - (number//1)
print(result)
Solution 12 - Python
Sometimes trailing zeros matter
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)
Solution 13 - Python
Another example using 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
Solution 14 - Python
This is a solution I tried:
num = 45.7234
(whole, frac) = (int(num), int(str(num)[(len(str(int(num)))+1):]))
Solution 15 - Python
Float numbers are not stored in decimal (base10) format. Have a read through the python documentation on this to satisfy yourself why. Therefore, to get a base10 representation from a float is not advisable.
Now there are tools which allow storage of numeric data in decimal format. Below is an example using the Decimal
library.
from decimal import *
x = Decimal('0.341343214124443151466')
str(x)[-2:] == '66' # True
y = 0.341343214124443151466
str(y)[-2:] == '66' # False
Solution 16 - Python
Use floor and subtract the result from the original number:
>> 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
Solution 17 - Python
Example:
import math
x = 5.55
print((math.floor(x*100)%100))
This is will give you two numbers after the decimal point, 55 from that example. If you need one number you reduce by 10 the above calculations or increase depending on how many numbers you want after the decimal.
Solution 18 - Python
import math
x = 1245342664.6
print( (math.floor(x*1000)%1000) //100 )
It definitely worked
Solution 19 - Python
I've found that really large numbers with really large fractional parts can cause problems when using modulo 1 to get the fraction.
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'>]
I instead grabbed the integral part and subtracted it first to help simplify the rest of it.
>>> d - d.to_integral()
Decimal('0.1231200000000000000002013210')
Solution 20 - Python
You can use this:
number = 5.55
int(str(number).split('.')[1])
Solution 21 - Python
This is only if you want toget the first decimal
print(int(float(input()) * 10) % 10)
Or you can try this
num = float(input())
b = num - int(num)
c = b * 10
print(int(c))
Solution 22 - Python
Using math module
speed of this has to be tested
from math import floor
def get_decimal(number):
'''returns number - floor of number'''
return number-floor(number)
Example:
n = 765.126357123
get_decimal(n)
> 0.12635712300004798
Solution 23 - Python
def fractional_part(numerator, denominator):
# Operate with numerator and denominator to
# keep just the fractional part of the quotient
if denominator == 0:
return 0
else:
return (numerator/ denominator)-(numerator // denominator)
print(fractional_part(5, 5)) # Should be 0
print(fractional_part(5, 4)) # Should be 0.25
print(fractional_part(5, 3)) # Should be 0.66...
print(fractional_part(5, 2)) # Should be 0.5
print(fractional_part(5, 0)) # Should be 0
print(fractional_part(0, 5)) # Should be 0
Solution 24 - Python
Easier if the input is a string, we can use split()
decimal = input("Input decimal number: ") #123.456
# split 123.456 by dot = ['123', '456']
after_coma = decimal.split('.')[1]
# because only index 1 is taken then '456'
print(after_coma) # '456'
if you want to make a number type print(int(after_coma)) # 456
Solution 25 - Python
What about:
a = 1.234
b = a - int(a)
length = len(str(a))
round(b, length-2)
Output:
print(b)
0.23399999999999999
round(b, length-2)
0.234
Since the round is sent to a the length of the string of decimals ('0.234'), we can just minus 2 to not count the '0.', and figure out the desired number of decimal points. This should work most times, unless you have lots of decimal places and the rounding error when calculating b interferes with the second parameter of round.
Solution 26 - Python
You may want to try this:
your_num = 5.55
n = len(str(int(your_num)))
float('0' + str(your_num)[n:])
It will return 0.55
.
Solution 27 - Python
number=5.55
decimal=(number-int(number))
decimal_1=round(decimal,2)
print(decimal)
print(decimal_1)
output: 0.55
Solution 28 - Python
See what I often do to obtain numbers after the decimal point in python 3:
a=1.22
dec=str(a).split('.')
dec= int(dec[1])
Solution 29 - Python
If you are using pandas:
df['decimals'] = df['original_number'].mod(1)
Solution 30 - Python
Another option would be to use the re
module with re.findall
or 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))
###Output
0.55
0.55
5
If you wish to simplify/modify/explore the expression, it's been explained on the top right panel of regex101.com. If you'd like, you can also watch in this link, how it would match against some sample inputs.
###Source
Solution 31 - Python
def fractional_part(numerator, denominator):
if denominator == 0:
return 0
else:
return numerator / denominator - numerator // denominator
print(fractional_part(5, 5)) # Should be 0
print(fractional_part(5, 4)) # Should be 0.25
print(fractional_part(5, 3)) # Should be 0.66...
print(fractional_part(5, 2)) # Should be 0.5
print(fractional_part(5, 0)) # Should be 0
print(fractional_part(0, 5)) # Should be 0
Solution 32 - Python
Late in the party, leaving comment for new visitors. If you know you need only 2 decimal places then you can use inbound round
round(1.15 % 1, 2)
Solution 33 - Python
I tried a lot of the other solutions but none of them work for me.
In my case, I have different operations and always in the last step, my result has more than the expected decimals.
For example, if you do:
61 * 0.1 the result is the float 6.1000000000000005
To get the 6.1 we have to parse the default float (at least in my case with 64bits) to a lower one:
import numpy as np
x = 61 * 0.1
y = np.float32(x)
If you have a lot of operations before, try to do the casting at the end :)
To answer better the original questions it would be:
import math
import numpy as np
x_deci, x_inte = math.modf(5.55)
decimals = np.float32(x_deci)
and the result for the decimals is 0.55 instead of 0.5499999999999998
Solution 34 - Python
I was interested in the relative timing of the more sensible answers given here. Using this script on my laptop (MacBookPro16, 6-Core Intel Core i7 2.6 GHz):
#!/bin/sh
python3 -V
python3 -m timeit -s 'a = 5.55' 'b = a % 1'
python3 -m timeit -s 'a = 5.55' 'b = a - a//1'
python3 -m timeit -s 'a = 5.55; import math' 'b = a - math.floor(a)'
python3 -m timeit -s 'a = 5.55' 'b = a - int(a)'
python3 -m timeit -s 'a = 5.55; import math' 'frac, whole = math.modf(a)'
I get the following timing:
Python 3.9.10
10000000 loops, best of 5: 34.9 nsec per loop
5000000 loops, best of 5: 51 nsec per loop
5000000 loops, best of 5: 69.2 nsec per loop
5000000 loops, best of 5: 84.1 nsec per loop
5000000 loops, best of 5: 97.7 nsec per loop
So the simple % 1
seems the fastest approach
Solution 35 - Python
A solution is using modulo and rounding.
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)))
Your output will be 0.55
Solution 36 - Python
Another crazy solution is (without converting in a string):
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