Cfxtrjtrk

Continuing from the comments above:

Using is_integer():

Example from the docs:

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

INPUT:

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

Hence:

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

Wrapped in a function:

def func(s):

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



print(func(s))

If you do not want any import:

def func(s):

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



print(func(s))

Using map() with lambda function and the iter s:

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

OR

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

OUTPUT:

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

In case your goal is to convert numbers to a concise string, you could simply use '%g' ("General Format") for formatting:

>>> '%g' % 1.0

'1'

>>> '%g' % 1

'1'

>>> '%g' % 1.5

'1.5'

>>> '%g' % 0.3

'0.3'

>>> '%g' % 0.9999999999

'1'

You can specify the desired accuracy:

>>> '%.15g' % 0.999999999999999

'0.999999999999999'

>>> '%.2g' % 0.999

'1'

float.is_integer is a method on floats that returns whether or not the float represents an integer.

You can just use this function I made called to_int, that uses is_integer to check whether it represents an integer (e.g. 1.0) or not (e.g. 1.5).

If it represents an integer, return int(a), otherwise just return it's original value.

As you see, I am not using elif or else because return returns only once:

def to_int(a):

   if a.is_integer():

      return int(a)

   return a



print(to_int(1.5))

print(to_int(1.0))

Output:

1.5

1

Python floats are approximations, so something that prints as 1.0 is not necessarily exactly 1.0. If you want to see if something is approximately an integer, use a sufficiently small epsilon value.

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

In general, if you're checking whether a float is == to something, that tends to be a code smell, as floating point values are inherently approximate. It's more appropriate in general to check whether a float is near something, within some epsilon range.

for list of numbers:

def get_int_if_possible(list_of_numbers):

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

for one number:

def get_int_if_possible(number):

    return int(number) if number == int(number) else number

A simple thing you could do is use the modulo operator:

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

else // numer is not an int

EDIT: Python code

if myFloat % 1 == 0:

  # myFloat is an integer.

else:

  # myFloat is NOT an integer

What I used to do in the past in C++ is, lets say you have these variables:

float x = 1.5;

float y = 1.0;

Then you could do something like this:

if(x == (int)x) 

    return 1;

else return 0;

This will return 0 because 1.5 is not equal to 1

if(y == (int)y) 

    return 1;

else return 0;

This will return 1 because 1.0 is equal to 1

Of course your question is about Python and the function is_integer() should work great, I just thought some people might find this useful.

def your_function(i):

  if i.is_integer():

    return int(i)

  else:

    return float(i)

The answer to the question as it is put requires comparison of the float value. One must always avoid equality operations on floats. Some form of rounding is a valid approach.

But for this kind of use case, the decimals module is your friend. Decimals have the advantage of absolute accuracy for the values cited in the question compared to floats and also achieve completely reliable results in comparison operations.

divmod alternative:

def f(x):

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