Python：将float 1.0作为int 1返回，但将float 1.5作为float 1.5返回

在Python中，有没有一种方法可以将

1.0

转换为整数

1

，而同一个函数忽略

1.5

，并将其保留为

float

---

现在，

int（）

将

1.0

转换为

1

，但它也将

1.5

向下取整为

1

，这不是我想要的。

继续上面的评论：

使用：

来自的示例：

>>> (1.5).is_integer()
False
>>> (1.0).is_integer()
True
>>> (1.4142135623730951).is_integer()
False
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

s = [1.5, 1.0, 2.5, 3.54, 1.0, 4.4, 2.0]

print([int(x) if x.is_integer() else x for x in s])

[1.5, 1, 2.5, 3.54, 1, 4.4, 2]

输入：

>>> (1.5).is_integer()
False
>>> (1.0).is_integer()
True
>>> (1.4142135623730951).is_integer()
False
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

s = [1.5, 1.0, 2.5, 3.54, 1.0, 4.4, 2.0]

print([int(x) if x.is_integer() else x for x in s])

[1.5, 1, 2.5, 3.54, 1, 4.4, 2]

因此：

>>> (1.5).is_integer()
False
>>> (1.0).is_integer()
True
>>> (1.4142135623730951).is_integer()
False
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

s = [1.5, 1.0, 2.5, 3.54, 1.0, 4.4, 2.0]

print([int(x) if x.is_integer() else x for x in s])

[1.5, 1, 2.5, 3.54, 1, 4.4, 2]

包装在函数中：

def func(s):
    return [int(x) if x.is_integer() else x for x in s]

print(func(s))

如果不需要任何

导入

：

def func(s):
    return [int(x) if x == int(x) else x for x in s]

print(func(s))

与功能和iter

s

一起使用：

print(list(map(lambda x: int(x) if x.is_integer() else x, s)))

或

print(list(map(lambda x: int(x) if int(x) == x else x, s)))

输出：

>>> (1.5).is_integer()
False
>>> (1.0).is_integer()
True
>>> (1.4142135623730951).is_integer()
False
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

s = [1.5, 1.0, 2.5, 3.54, 1.0, 4.4, 2.0]

print([int(x) if x.is_integer() else x for x in s])

[1.5, 1, 2.5, 3.54, 1, 4.4, 2]

是一个浮点数上的方法，返回浮点数是否表示整数

您只需使用我创建的名为

to_int

的函数，该函数使用

is_integer

来检查它是否表示整数（例如

1.0

），例如

1.5

）

如果它表示整数，则返回int（a），否则只返回其原始值

如您所见，我没有使用

elif

或

else

，因为

return

只返回一次：

def to_int(a):
   if a.is_integer():
      return int(a)
   return a

print(to_int(1.5))
print(to_int(1.0))

输出：

1.5
1

---

<>过去我在C++中做的是，假设你有这些变量：

float x = 1.5;
float y = 1.0;

然后你可以这样做：

if(x == (int)x) 
    return 1;
else return 0;

这将返回0，因为1.5不等于1

if(y == (int)y) 
    return 1;
else return 0;

这将返回1，因为1.0等于1

if(y == (int)y) 
    return 1;
else return 0;

---

当然，您的问题是关于Python的，函数

is_integer（）

应该可以很好地工作，我只是觉得有些人可能会觉得这很有用。

您可以做的一件简单的事情是使用模运算符：

if (myFloat % 1 == 0) // Number is an int
else // numer is not an int

编辑：Python代码

if myFloat % 1 == 0:
  # myFloat is an integer.
else:
  # myFloat is NOT an integer

---

如果您的目标是将数字转换为简明字符串，您只需使用

'%g'

（“通用格式”）即可：

您可以指定所需的精度：

>>> '%.15g' % 0.999999999999999
'0.999999999999999'
>>> '%.2g' % 0.999
'1'

---

Python浮点是近似值，因此打印为

1.0

的内容不一定完全是

1.0

。如果想知道某个值是否近似为整数，请使用足够小的ε值

EPSILON = 0.0001 # Make this smaller or larger depending on desired accuracy

def func(x):
  if abs(x - round(x)) < EPSILON:
    return round(x)
  else:
    return x

EPSILON=0.0001#根据所需的精度使其变小或变大
def func（x）：
如果abs（x-圆（x））

一般来说，如果要检查浮点值是否是某个值的

=

，这可能是一种代码味道，因为浮点值本质上是近似值。一般来说，检查浮点是否在某个ε范围内靠近某个对象更合适。

对于数字列表：

def get_int_if_possible(list_of_numbers):
    return [int(x) if x == int(x) else x for x in list_of_numbers]

对于一个数字：

def get_int_if_possible(number):
    return int(number) if number == int(number) else number

---

divmod

备选方案：

def f(x):
    return x if divmod(x, 1)[1] else int(x)

---

一种方法是使用

is_integer（）

检查浮点值，如果通过，将其转换为

int

？浮点值是近似值，

1.0

实际上可能是

1.00000000000001

或

0.99999999999

。注意，由于duck键入，您想要实现的这一段可能不合适或没有用，取决于上下文。请用文字/规则来指定您的确切要求，而不仅仅是一个例子

def f（x）：如果x==1.0:return 1 else return 1.5

问题是在所讨论的浮点值有整数值时将浮点值转换为int。在C++中，这是不可能的，因为你不能从函数..M.HelZkAMP返回不同的值。你可以有一个<代码>联合<代码>。而且，如果上面的条件是ME，C++上的离题并不相关，那么你可以设置另一个整型变量并保存浮点。在Python中也可以这样做：

foo=lambda x:int（x）if int（x）=x else x

。（或者在Python 3.8中，为了避免重复调用

int

，

lambda x:y if（y:=int（x））==x else x

filter

不会修改列表中的值；该函数只是一个谓词，决定是否为其输出选择原始值。请改用

map

。虽然大多数浮点值都是近似值，但有许多整数可以精确表示。64位IEEE 754浮点值g点编号（在Python和其他语言中使用）可以精确表示任何适合53位或更少的有符号整数。如果整数值可以用53位表示，则此类整数可以在64位浮点和64位整数之间转换为1比1。保持在53位整数空间内的加法、减法和乘法每个IE应产生相同的结果EE 754 spec.@penguin359虽然我同意整数可以用浮点表示，但如果你处于OP的情况下，你需要问问自己，对于你的目的来说，离一个整数“足够近”有多近。

1.0+1e-16

“足够近”吗？

1.0+2e-16

？这是一个重要的问题，因为IEEE 754是基于“整数”方法将对它们进行不同的处理，您可能会或可能不想考虑<代码> 1 +2E-16< /代码>“不是整数”，同时说“代码> 1 +1E-16<代码>为一。-具有显式ε（相对于IEEE 754的隐式）让你的愿望更清晰。一个似乎最适合这个答案的注释：设置ε与提供的示例一样有效。或者，特别是在处理美分（一般货币）时，我发现将Python默认的二进制表示形式更改为十进制表示形式更有用，如模块decimal（）所提供的那样。例如，在以0.1为增量从-1迭代到+1的循环中，差异要么非常接近于0，要么正好在0.0——不需要ε集（如何处理-1.387787807814457E-16货币单位？）。“因此打印为1.0的内容不一定完全是1.0“这取决于python的版本。在现代python 3（自python 3.2以来的IIRC）中，打印为1.0的浮点值正好是1.0。在较旧的python版本中，它是