Si vous avez besoin de le faire, faites
isinstance(<var>, int)
sauf si vous êtes dans Python 2.x, auquel cas vous voulez
isinstance(<var>, (int, long))
Ne pas utiliser type. Ce n'est presque jamais la bonne réponse en Python, car il bloque toute la flexibilité du polymorphisme. Par exemple, si vous sous-classe int, votre nouvelle classe doit être enregistrée en tant que int, ce que type ne fera pas:
class Spam(int): pass
x = Spam(0)
type(x) == int # False
isinstance(x, int) # True
Cela adhère au fort polymorphisme de Python: vous devriez autoriser tout objet qui se comporte comme un int, au lieu de l'exiger.
MAIS
La mentalité classique de Python, cependant, est que c'est plus facile de demander pardon que la permission. En d'autres termes, ne vérifiez pas si x est un entier; supposons qu'il en soit ainsi et interceptent les résultats de l'exception si ce n'est pas le cas:
try:
x += 1
except TypeError:
...
Cette mentalité est progressivement dépassée par l'utilisation de classes de base abstraites , qui vous permettent d'enregistrer exactement les propriétés que doit avoir votre objet (en ajoutant? Multipliant? Doublant?) En le faisant hériter d'une classe spécialement construite. Ce serait la meilleure solution, car elle autorisera exactement ces objets avec les attributs nécessaires et suffisants, mais vous devrez lire la documentation pour savoir comment l'utiliser.
Jusqu'à présent, toutes les réponses proposées semblent oublier le fait qu'un double (les flottants en python sont en fait des doubles) peut également être un entier (s'il n'a rien après le point décimal). J'utilise la méthode intégrée is_integer() sur doubles pour vérifier cela.
Exemple (faire quelque chose toutes les dix fois dans une boucle for):
for index in range(y):
# do something
if (index/x.).is_integer():
# do something special
Modifier:
Vous pouvez toujours convertir en float avant d'appeler cette méthode. Les trois possibilités:
>>> float(5).is_integer()
True
>>> float(5.1).is_integer()
False
>>> float(5.0).is_integer()
True
Sinon, vous pouvez vérifier si c'est un int d'abord comme le dit Agostino:
def is_int(val):
if type(val) == int:
return True
else:
if val.is_integer():
return True
else:
return False
Si vous vraiment devez vérifier, il vaut mieux utiliser classes de base abstraites plutôt que des classes concrètes. Pour un entier cela voudrait dire:
>>> import numbers
>>> isinstance(3, numbers.Integral)
True
Cela ne limite pas la vérification à int, ou simplement int et long, mais permet également aux autres types définis par l'utilisateur qui se comportent comme des entiers de fonctionner.
>>> isinstance(3, int)
True
Voir ici pour plus.
Notez que cela n’aide pas si vous recherchez des attributs de type int-. Dans ce cas, vous pouvez également vouloir vérifier long:
>>> isinstance(3L, (long, int))
True
J'ai vu des vérifications de ce type contre un type tableau/index dans le code source Python, mais je ne pense pas que cela soit visible en dehors de C.
Token SO réponse: Êtes-vous sûr de vérifier son type? Ne passez pas un type que vous ne pouvez pas gérer ou n'essayez pas de déjouer vos réutilisateurs de code potentiels, ils peuvent avoir une bonne raison de ne pas passer un int à votre fonction.
Pourquoi ne pas essayer quelque chose comme:
if x%1 == 0:
Plutôt que de compliquer les choses, pourquoi pas un simple
if type(var) is int:
Voici une méthode simple que j'utilise dans tous mes logiciels. Il vérifie si la variable est composée de nombres.
test = input("Enter some text here: ")
if test.isdigit() == True:
print("This is a number.")
else:
print("This is not a number.")
il est vraiment étonnant de voir une discussion aussi animée se dérouler lorsqu'une question aussi fondamentale, valable et, je crois, banale, est posée.
certaines personnes ont fait remarquer que la vérification de type avec int (et long) peut entraîner la perte de cas dans lesquels un grand nombre décimal est rencontré. tout à fait raison.
certaines personnes ont fait remarquer que vous devriez simplement «faire x + 1 et voir si cela échoue. Eh bien, d’une part, cela fonctionne aussi sur les flottants et, d’autre part, il est facile de construire une classe qui n’est certainement pas très numérique, mais qui définit d’une certaine manière l’opérateur +.
je suis en désaccord avec de nombreux messages déclarant avec vigueur que vous ne devriez pas vérifier les types. Eh bien, GvR a déjà dit quelque chose comme quoi, dans la théorie pure, cela peut être correct, mais en pratique, isinstance sert souvent à des fins utiles (cela fait longtemps, vous n'avez pas le lien; vous pouvez lire ce que GvR dit à propos de problèmes liés dans des messages comme celui-ci ).
ce qui est drôle, c’est combien de personnes semblent supposer que l’intention du PO était de vérifier si le type d’un x donné est un type entier numérique - ce que j’ai compris est ce que j’entends normalement lors de l’utilisation du PO mots: si x représente un nombre entier. et cela peut être très important: par exemple demander à quelqu'un combien d'articles ils voudraient choisir, vous pouvez vérifier si vous récupérez un nombre entier non négatif. cas d'utilisation comme celui-ci abondent.
il est également important, à mon avis, de constater que (1) la vérification de type n'est qu'une seule mesure - souvent assez grossière - de l'exactitude d'un programme, car (2) il s'agit souvent de valeurs délimitées ayant un sens et de valeurs hors limites. ça fait des bêtises. parfois, seules quelques valeurs intermittentes ont un sens - comme pour tous les nombres, seuls les nombres entiers réels (non complexes) peuvent être possibles dans un cas donné.
drôle non-un semble mentionner la vérification de x == math.floor( x ). si cela donne une erreur avec une grande classe décimale, eh bien, alors il est peut-être temps de repenser les paradigmes OOP. il existe également PEP 357 qui considère comment utiliser des valeurs non-aussi-évidemment -int- mais certainement semblables à des entiers, à utiliser comme index de liste. Je ne sais pas si j'aime la solution.
J'ai trouvé une question liée ici sur SO lui-même.
Les développeurs Python préfèrent ne pas vérifier les types, mais effectuer une opération spécifique au type et intercepter une exception TypeError. Mais si vous ne connaissez pas le type, vous avez les éléments suivants.
>>> i = 12345
>>> type(i)
<type 'int'>
>>> type(i) is int
True
Si vous voulez vérifier qu'une chaîne ne contient que des chiffres, mais que la conversion en int ne vous aidera pas, vous pouvez toujours utiliser regex.
import re
x = "01234"
match = re.search("^\d+$", x)
try: x = match.group(0)
except AttributeError: print("not a valid number")
Result: x == "01234"
Dans ce cas, si x était "hello", le convertir en un type numérique générerait une erreur ValueError, mais les données seraient également perdues au cours du processus. Utiliser une expression rationnelle et attraper un AttributeError vous permettrait de confirmer les caractères numériques d'une chaîne avec, par exemple, les 0 premiers.
Si vous ne voulez pas que cela jette un AttributeError, mais que vous vouliez simplement rechercher des problèmes plus spécifiques, vous pouvez modifier la regex et simplement vérifier la correspondance:
import re
x = "h01234"
match = re.search("\D", x)
if not match:
print("x is a number")
else:
print("encountered a problem at character:", match.group(0))
Result: "encountered a problem at character: h"
Cela vous montre en fait où le problème s'est produit sans l'utilisation d'exceptions. Encore une fois, ce n'est pas pour tester le type, mais plutôt les caractères eux-mêmes. Cela vous donne beaucoup plus de flexibilité que la simple recherche de types, en particulier lorsque la conversion entre types peut perdre des données de chaîne importantes, comme les 0 non en tête.
pourquoi ne pas simplement vérifier si la valeur que vous voulez vérifier est égale à elle-même convertie en un entier comme indiqué ci-dessous?
def isInt(val):
return val == int(val)
Voici un exemple simple pour déterminer un entier
def is_int(x):
print round(x),
if x == round(x):
print 'True',
else:
print 'False'
is_int(7.0) # True
is_int(7.5) # False
is_int(-1) # True
Si la variable est entrée comme une chaîne (par exemple '2010'):
if variable and variable.isdigit():
return variable #or whatever you want to do with it.
else:
return "Error" #or whatever you want to do with it.
Avant d’utiliser ceci, j’ai travaillé avec try/except et vérifié (int(variable)), mais c’était un code plus long. Je me demande s’il existe une différence d’utilisation des ressources ou de rapidité.
utiliser la fonction int pour aider
intchecker = float(input('Please enter a integer: '))
intcheck = 0
while intcheck != 1:
if intchecker - int(intchecker) > 0:
intchecker = float(input("You didn't enter a integer. "
"Please enter a integer: "))
else:
intcheck = 1
print('you have entered a integer')
Si vous lisez à partir d'un fichier et que vous avez un tableau ou un dictionnaire avec des valeurs de plusieurs types de données, voici ce qui est utile… .. Vérifiez simplement si la variable peut être transtypée en int (ou tout autre type de données que vous souhaitez appliquer) ou pas.
try :
int(a);
#Variable a is int
except ValueError :
# Variable a is not an int
Une méthode simple consiste à vérifier directement si le reste de la division par 1 est égal à 0 ou non.
if this_variable % 1 == 0:
list.append(this_variable)
else:
print 'Not an Integer!'
En présence de numpy, vérifiez comme ..
isinstance(var, numbers.Integral)
.. (lent) ou ..
isinstance(var, (int, long, np.integer))
.. afin de faire correspondre toutes les variantes de type comme np.int8, np.uint16, ...
(Supprimez long en troisième année)
Reconnaître TOUT OBJET DE TYPE ENTIER de n'importe où est un jeu de devinette difficile. Vérification
var & 0 == 0
pour la vérité et la non-exception peut être un bon pari. De même, en vérifiant exclusivement le type entier signé:
var ^ -1 == -var - 1
Si vous avez juste besoin de value, operator.index (méthode spéciale __index__) est la solution à mon avis. Puisqu'il devrait fonctionner pour tous les types pouvant être convertis en un entier en toute sécurité. C'est à dire. les flottants échouent, les entiers, même les classes entières sophistiquées qui n'implémentent pas la classe abstraite intégrale, fonctionnent en tapant du duck.
operator.index est ce qui est utilisé pour l'indexation de liste, etc. Et à mon avis, il devrait être utilisé pour beaucoup plus/promu.
En fait, je dirais que c’est la seule manière correcte d’obtenir des valeurs entières si vous voulez être certain que les points flottants, dus à des problèmes de troncature, etc. ils ne peuvent pas (encore) supporter la classe abstraite.
C’est ce que __index__ était introduit pour!
Si vous voulez vérifier sans égard pour la version de Python (2.x vs 3.x), utilisez six ( PyPI ) et son attribut integer_types:
import six
if isinstance(obj, six.integer_types):
print('obj is an integer!')
Dans six (un module très léger à fichier unique), cela se fait simplement comme suit:
import sys
PY3 = sys.version_info[0] == 3
if PY3:
integer_types = int,
else:
integer_types = (int, long)
Une approche plus générale qui tentera de vérifier à la fois les entiers et les entiers donnés sous forme de chaînes sera
def isInt(anyNumberOrString):
try:
int(anyNumberOrString) #to check float and int use "float(anyNumberOrString)"
return True
except ValueError :
return False
isInt("A") #False
isInt("5") #True
isInt(8) #True
isInt("5.88") #False *see comment above on how to make this True
Si vous n’avez pas int vous pouvez faire ceci:
var = 15.4
if(var - int(var) != 0):
print "Value is not integer"
J'écrivais un programme pour vérifier si un nombre était carré et j'ai rencontré ce problème, le code Que j'ai utilisé était le suivant:
import math
print ("this program will tell you if a number is square")
print ("enter an integer")
num = float(input())
if num > 0:
print ("ok!")
num = (math.sqrt(num))
inter = int(num)
if num == inter:
print ("It's a square number, and its root is")
print (num)
else:
print ("It's not a square number, but its root is")
print (num)
else:
print ("That's not a positive number!")
Pour dire si le nombre est un entier, j'ai converti le nombre flottant que vous obtenez en enracinant la saisie de l'utilisateur en un entier arrondi (stocké comme valeur). Si ces deux nombres étaient égaux, le premier nombre devait être un entier programme pour répondre. Ce n'est peut-être pas la façon la plus courte de le faire, mais cela a fonctionné pour moi.
#!/usr/bin/env python
import re
def is_int(x):
if(isinstance(x,(int,long))):
return True
matchObj = re.match(r'^-?\d+\.(\d+)',str(x))
if matchObj:
x = matchObj.group(1)
if int(x)-0==0:
return True
return False
print is_int(6)
print is_int(1.0)
print is_int(1.1)
print is_int(0.1)
print is_int(-956.0)
Je peux vérifier si le nombre est un nombre entier comprenant un nombre comme 7.0
def is_int(x):
if x - round(x) == 0 :
return True
else:
return False
Test, si l'objet est une chaîne (fonctionne avec Python 2. * et Python 3. *)
text = get_text()
try:
text = text+""
except:
return "Not a string"
do_something(text)
Considérons le cas x = n ** (1.0/m), où n = 10 ** 5, m = 5. En Python, x sera égal à 10.000000000000002, ce qui n’est pas un entier en raison d’opérations arithmétiques à virgule flottante.
Donc je vérifierais
if str(float(x)).endswith('.0'): print "It's an integer."
Je l'ai testé avec ce code:
for a in range(2,100):
for b in range(2,100):
x = (a**b)**(1.0/b)
print a,b, x, str(float(x)).endswith('.0')
Il génère la valeur True pour tous a et b.
Tu peux le faire.
if type(x) is int:
val=3
>>> isinstance(val,int )
True
marchera.
#######################################
# Value_Is_Int
#######################################
def value_is_int(value):
try:
tempVal = int(value)
return True
except:
return False
Appelez cette fonction:
if value_is_int(value):
print "Integer"
else:
print "Not integer"
Le moyen le plus simple est:
if n==int(n):
--do something--
Où n est la variable
Si vous voulez écrire un code compatible Python 2-3
Pour tester si une valeur est un entier (de tout type), vous pouvez le faire:
# Python 2 and 3:
import sys
if sys.version_info < (3,):
integer_types = (int, long,)
else:
integer_types = (int,)
>>> isinstance(1, integer_types)
True
# Python 2 only:
if isinstance(x, (int, long)):
...
# Python 3 only:
if isinstance(x, int):
...
if type(input('enter = '))==int:
print 'Entered number is an Integer'
else:
print 'Entered number isn't an Integer'
Ça va travailler pour vérifier si le nombre est un entier ou non
J'ai essayé ça et ça marche.
x = 'place_hold'
num = input("num: ")
try:
int(num)
x = 'valid'
except ValueError:
x = 'invalid'
print(x)
Vous pouvez également utiliser str.isdigit. Essayez de regarder help(str.isdigit)
def is_digit(str):
return str.isdigit()
Il existe une autre option pour effectuer la vérification de type.
Par exemple:
n = 14
if type(n)==int:
return "this is an int"
vous pouvez le faire en:
name = 'Bob'
if type(name) == str:
print 'this works'
else:
print 'this does not work'
et il retournera 'ça marche' ... mais si vous changez le nom en int (1), alors il retournera 'ça ne marche pas' car c'est maintenant une chaîne ...
name = int(5)
if type(name) == int:
print 'this works'
else:
print 'this does not work'
et la même chose va arriver
C'est très simple de vérifier en python. Vous pouvez faire comme ça:
Supposons que vous souhaitiez vérifier qu'une variable est un entier ou non!
## For checking a variable is integer or not in python
if type(variable) is int:
print("This line will be executed")
else:
print("Not an integer")