如何获取小数点后的数字？
例如，如果我有5.55，我该如何获得.55？
答案 0 :(得分：150)
5.55 % 1
请记住，这对浮点舍入问题没有帮助。即，你可能会得到：
0.550000000001
或者稍微偏离你期望的0.55。
答案 1 :(得分：120)
使用modf：
>>> import math
>>> frac, whole = math.modf(2.5)
>>> frac
0.5
>>> whole
2.0
答案 2 :(得分：48)
怎么样：
a = 1.3927278749291
b = a - int(a)
b
>> 0.39272787492910011
或者，使用numpy：
import numpy
a = 1.3927278749291
b = a - numpy.fix(a)
答案 3 :(得分：31)
使用标准库中的decimal模块，您可以保留原始精度并避免浮点舍入问题：
>>> from decimal import Decimal
>>> Decimal('4.20') % 1
Decimal('0.20')
答案 4 :(得分：22)
一种简单的方法：
number_dec = str(number-int(number))[1:]
答案 5 :(得分：6)
尝试Modulo：
5.55%1 = 0.54999999999999982
答案 6 :(得分：4)
import math
orig = 5.55
whole = math.floor(orig) # whole = 5.0
frac = orig - whole # frac = 0.55
答案 7 :(得分：3)
只需使用简单的运算符除法'/'和底除法'//'，您就可以轻松获取任何给定浮点数的分数部分。
number = 5.55
result = (number/1) - (number//1)
print(result)
答案 8 :(得分：3)
类似于接受的答案，使用字符串更简单的方法是
if "." in str(number): # quick check if it is decimal
number_dec = str(number).split(".")[1]
if 'e-' in str(number): # scientific notation
number_dec = format(float(number_dec), '.%df'%(len(number_dec.split(".")[1].split("e-")[0])+int(number_dec.split('e-')[1])))
答案 9 :(得分：2)
要使其同时适用于正数和负数：
试试 abs(x)%。对于负数，不带 abs 会出错。
5.55 % 1
输出 0.5499999999999998
-5.55 % 1
输出 0.4500000000000002
答案 10 :(得分：2)
>>> n=5.55
>>> if "." in str(n):
... print "."+str(n).split(".")[-1]
...
.55
答案 11 :(得分：1)
使用发言权并从原始数字中减去结果：
>> 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
答案 12 :(得分：1)
示例：
import math
x = 5.55
print((math.floor(x*100)%100))
这将给出小数点后面的两个数字，即该示例中的55。如果您需要一个数字，则将上述计算减少10或根据小数点后您想要的数量增加。
答案 13 :(得分：1)
浮点数不以十进制（base10）格式存储。请仔细阅读python documentation以了解原因。因此，不建议从float中获取base10表示。
现在有一些工具允许以十进制格式存储数字数据。以下是使用Decimal库的示例。
from decimal import *
x = Decimal('0.341343214124443151466')
str(x)[-2:] == '66' # True
y = 0.341343214124443151466
str(y)[-2:] == '66' # False
答案 14 :(得分：1)
有时尾随零很重要
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)
答案 15 :(得分：1)
import math
x = 1245342664.6
print( (math.floor(x*1000)%1000) //100 )
肯定有效
答案 16 :(得分：1)
仅当您要获取第一个小数位时
print(int(float(input()) * 10) % 10)
或者您可以尝试
num = float(input())
b = num - int(num)
c = b * 10
print(int(c))
答案 17 :(得分：1)
这是我尝试的解决方案：
num = 45.7234
(whole, frac) = (int(num), int(str(num)[(len(str(int(num)))+1):]))
答案 18 :(得分：0)
另一种选择是将re模块与re.findall或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))
0.55
0.55
5
如果您希望简化/修改/探索表达式，请在regex101.com的右上角进行说明。如果愿意，您还可以在this link中查看它如何与某些示例输入匹配。
How to get rid of additional floating numbers in python subtraction?
答案 19 :(得分：0)
如果输入是字符串，则更容易，我们可以使用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'
如果要输入数字类型 print（int（after_coma））＃456
答案 20 :(得分：0)
/**
* This callback is displayed as a global member.
* @callback someCallback
* @param {number} param1
* @param {number} param2
* @returns {number}
*/
/**
*
* @param {someCallback} cb
*/
function someFunction(cb) {
}
答案 21 :(得分：0)
必须对此速度进行测试
from math import floor
def get_decimal(number):
'''returns number - floor of number'''
return number-floor(number)
示例：
n = 765.126357123
get_decimal(n)
0.12635712300004798
答案 22 :(得分：0)
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
答案 23 :(得分：0)
您可以使用此：
if (jogo.indexOf(temp) == -1){
jogo.push(temp)
}
else {
i--;
}
}
答案 24 :(得分：0)
另一个使用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
答案 25 :(得分：0)
我发现，使用模1求分数时，具有很大分数部分的非常大的数会引起问题。
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'>]
我取而代之的是将组成部分减去，以简化其余部分。
>>> d - d.to_integral()
Decimal('0.1231200000000000000002013210')
答案 26 :(得分：0)
如果您使用的是熊猫：
df['decimals'] = df['original_number'].mod(1)
答案 27 :(得分：0)
看看我经常做什么来获取python小数点后的数字 3：
a=1.22
dec=str(a).split('.')
dec= int(dec[1])
答案 28 :(得分：0)
number=5.55
decimal=(number-int(number))
decimal_1=round(decimal,2)
print(decimal)
print(decimal_1)
输出：0.55
答案 29 :(得分：0)
您可能想尝试一下：
your_num = 5.55
n = len(str(int(your_num)))
float('0' + str(your_num)[n:])
它将返回0.55。
答案 30 :(得分：0)
怎么样：
a = 1.234
b = a - int(a)
length = len(str(a))
round(b, length-2)
输出：
print(b)
0.23399999999999999
round(b, length-2)
0.234
由于轮次被发送到小数字串的长度（＆＃39; 0.234＆＃39;），我们可以减去2而不计算＆＃39; 0。＆＃39;和计算出所需的小数点数。这应该工作很多次，除非你有很多小数位，并且计算b时的舍入误差干扰了第二轮的参数。
答案 31 :(得分：-1)
一种解决方案是使用取模和舍入。
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)))
您的输出将是0.55
答案 32 :(得分：-2)
另一个疯狂的解决方案是（不用字符串转换）：
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