Voici comment je l'ai fait:

inNumber = somenumber
inNumberint = int(inNumber)
if inNumber == inNumberint:
    print "this number is an int"
else:
    print "this number is a float"

Quelque chose comme ca.
Existe-t-il des moyens plus agréables de procéder?

Utilisez l' instance .

>>> x = 12
>>> isinstance(x, int)
True
>>> y = 12.0
>>> isinstance(y, float)
True

Alors:

>>> if isinstance(x, int):
        print 'x is a int!'

x is a int!

_ÉDITER:_

Comme indiqué, en cas de longs entiers, ce qui précède ne fonctionnera pas. Vous devez donc faire:

>>> x = 12L
>>> import numbers
>>> isinstance(x, numbers.Integral)
True
>>> isinstance(x, int)
False

J'aime le plus la réponse de @ ninjagecko.

Cela fonctionnerait également:

pour Python 2.x

isinstance(n, (int, long, float)) 

Python 3.x n'a pas longtemps

isinstance(n, (int, float))

il existe également des types complexes pour les nombres complexes

Bon mot:

isinstance(yourNumber, numbers.Real)

Cela évite certains problèmes:

>>> isinstance(99**10,int)
False

Démo:

>>> import numbers

>>> someInt = 10
>>> someLongInt = 100000L
>>> someFloat = 0.5

>>> isinstance(someInt, numbers.Real)
True
>>> isinstance(someLongInt, numbers.Real)
True
>>> isinstance(someFloat, numbers.Real)
True

Il est plus facile de demander pardon que de demander la permission. Effectuez simplement l'opération. Si cela fonctionne, l'objet était d'un type acceptable, approprié et approprié. Si l'opération ne fonctionne pas, l'objet n'était pas d'un type approprié. Connaître le type aide rarement.

Essayez simplement l'opération et voyez si cela fonctionne.

inNumber = somenumber
try:
    inNumberint = int(inNumber)
    print "this number is an int"
except ValueError:
    pass
try:
    inNumberfloat = float(inNumber)
    print "this number is a float"
except ValueError:
    pass

Ce que vous pouvez aussi faire, c'est utiliser type() Exemple:

if type(inNumber) == int : print "This number is an int"
elif type(inNumber) == float : print "This number is a float"

Voici un morceau de code qui vérifie si un nombre est un entier ou non, il fonctionne à la fois pour Python 2 et Python 3.

import sys

if sys.version < '3':
    integer_types = (int, long,)
else:
    integer_types = (int,)

isinstance(yourNumber, integer_types)  # returns True if it's an integer
isinstance(yourNumber, float)  # returns True if it's a float

Notez que Python 2 a les deux types intet long, tandis que Python 3 n'a que le type int. Source .

Si vous souhaitez vérifier si votre numéro est un floatqui représente un int, procédez comme suit

(isinstance(yourNumber, float) and (yourNumber).is_integer())  # True for 3.0

Si vous n'avez pas besoin de faire la distinction entre int et float, et que vous êtes d'accord non plus, alors la réponse de ninjagecko est la voie à suivre

import numbers

isinstance(yourNumber, numbers.Real)

que diriez-vous de cette solution?

if type(x) in (float, int):
    # do whatever
else:
    # do whatever

Je sais que c'est un vieux fil mais c'est quelque chose que j'utilise et j'ai pensé que ça pourrait aider.

Il fonctionne en python 2.7 et python 3 <.

def is_float(num):
    """
    Checks whether a number is float or integer

    Args:
        num(float or int): The number to check

    Returns:
        True if the number is float
    """
    return not (float(num)).is_integer()


class TestIsFloat(unittest.TestCase):
    def test_float(self):
        self.assertTrue(is_float(2.2))

    def test_int(self):
        self.assertFalse(is_float(2))

Vous pouvez utiliser modulo pour déterminer si x est un entier numériquement. La isinstance(x, int)méthode détermine uniquement si x est un entier par type:

def isInt(x):
    if x%1 == 0:
        print "X is an integer"
    else:
        print "X is not an integer"

Testé dans Python version 3.6.3 Shell

>>> x = 12
>>> import numbers
>>> isinstance(x, numbers.Integral)
True
>>> isinstance(x,int)
True

Impossible de trouver quoi que ce soit pour travailler.

veuillez vérifier ceci: importer des numéros

import math

a = 1.1 - 0.1
print a 

print isinstance(a, numbers.Integral)
print math.floor( a )
if (math.floor( a ) == a):
    print "It is an integer number"
else:
    print False

Bien que X soit flottant mais que la valeur soit un entier, donc si vous voulez vérifier que la valeur est un entier, vous ne pouvez pas utiliser isinstance et vous devez comparer les valeurs et non les types.

absolute = abs(x)
rounded = round(absolute)
if absolute - rounded == 0:
  print 'Integer number'
else:
  print 'notInteger number'

Mise à jour: essayez ceci

inNumber = [32, 12.5, 'e', 82, 52, 92, '1224.5', '12,53',
            10000.000, '10,000459', 
           'This is a sentance, with comma number 1 and dot.', '121.124']

try:

    def find_float(num):
        num = num.split('.')
        if num[-1] is not None and num[-1].isdigit():
            return True
        else:
            return False

    for i in inNumber:
        i = str(i).replace(',', '.')
        if '.' in i and find_float(i):
            print('This is float', i)
        elif i.isnumeric():
            print('This is an integer', i)
        else:
            print('This is not a number ?', i)

except Exception as err:
    print(err)

Vous pouvez le faire avec une simple instruction if

Pour vérifier le flotteur

si type (a) == type (1.1)

Pour vérifier le type entier

si type (a) == type (1)

def is_int(x):
  absolute = abs(x)
  rounded = round(absolute)
  if absolute - rounded == 0:
    print str(x) + " is an integer"
  else:
    print str(x) +" is not an integer"


is_int(7.0) # will print 7.0 is an integer

Essaye ça...

def is_int(x):
  absolute = abs(x)
  rounded = round(absolute)
  return absolute - rounded == 0

variable.isnumeric vérifie si une valeur est un entier:

 if myVariable.isnumeric:
    print('this varibale is numeric')
 else:
    print('not numeric')