Dacă aveți nevoie pentru a face acest lucru, face

isinstance(, int)

dacă nu sunt în Python 2.x în cazul în care doriți

isinstance(, (int, long))

Nu folosiți "tip". Este aproape niciodată răspunsul corect în Python, deoarece blochează toate flexibilitatea de polimorfism. De exemplu, dacă subclasa int, noua clasă ar trebui să se înregistreze ca un int, care " tip " nu va face:

class Spam(int): pass
x = Spam(0)
type(x) == int # False
isinstance(x, int) # True

Acest aderă la Python's puternic polimorfism: tu ar trebui să permită orice obiect care se comportă ca un int, în loc de obligativitatea ca acesta să fie unul.

DAR

Clasic Python mentalitate, totuși, este că-l's mai ușor pentru a cere iertarea decât permisiunea. Cu alte cuvinte, don't verificați dacă x este un număr întreg; presupunem că este și prinde excepție rezultatele e't:

try:
    x += 1
except TypeError:
    ...

Această mentalitate este lent, fiind depășit prin utilizarea de abstract clase de bază, care vă permite să înregistreze exact ce proprietăți obiect ar trebui să aibă (adăugând? înmulțirea? dublarea?) făcându-l moștenesc de la un special construite clasa. Care ar fi cea mai bună soluție, deoarece aceasta va permite exact acele obiecte necesare și suficiente atribute, dar va trebui să citiți documente de pe cum să-l folosească.

Toate propunerile de răspunsuri de până acum par să dor de faptul că dubla (plutește în python sunt de fapt dublu) poate fi, de asemenea, un număr întreg (dacă nu are nimic de după punctul zecimal). Eu folosesc built-in is_integer() metoda pe dublu pentru a verifica acest lucru.

Exemplu (pentru a face ceva în fiecare x timp într-o buclă):

for index in range(y): 
    # do something
    if (index/x.).is_integer():
        # do something special

Edit:

Puteți converti întotdeauna la un float înainte de a apela la această metodă. Cele trei posibilități:

>>> float(5).is_integer()
True
>>> float(5.1).is_integer()
False
>>> float(5.0).is_integer()
True

În caz contrar, ai putea verifica dacă acesta este un int prima ca Agostino a spus:

def is_int(val):
    if type(val) == int:
        return True
    else:
        if val.is_integer():
            return True
        else:
            return False

Dacă într-adevăr ** trebuie să verificați atunci este's mai bine să utilizați abstract clase de bază, mai degrabă decât clasele de beton. Pentru un număr întreg care ar însemna:

>>> import numbers
>>> isinstance(3, numbers.Integral)
True

Asta nu't limiteze verificarea doar la int, sau int si "lung", dar permite, de asemenea, alte definite de utilizator tipuri care se comportă ca numere întregi de la serviciu.

Aici's un rezumat al diferitelor metode menționate aici:

• int(x) == x
• încearcă x = operator.index(x)`
• isinstance(x, int)
• isinstance(x, numere.Integral)

și aici's cum acestea se aplică la o varietate de tipuri numerice care au valoare întreagă:

Puteți vedea că nu sunt't potrivesc 100%. Fracțiune și Rațional sunt din punct de vedere conceptual la fel, dar unul furnizează o `.index () metodă și alte nu't. Tipuri complexe don't ca să se convertească la int, chiar dacă partea reală este parte integrantă și partea imaginară este 0.

(np.int8|16|32|64(5) înseamnă că np.int8(5), np.int32(5), etc. toate se comporte identic)

>>> isinstance(3, int)
True

A se vedea aici pentru mai multe.

Rețineți că acest lucru nu ajuta daca're în căutarea pentru int-ca atribute. În acest caz, de asemenea, poate doriți să verificați pentru "lung":

>>> isinstance(3L, (long, int))
True

Am'am văzut controale de acest fel împotriva unei matrice/index de tip în sursă Python, dar nu't cred că's vizibile în afara C.

Token ATÂT de raspuns: Ești sigur că ar trebui să fie de verificare tipul acesteia? Nici nu't trece un tip te poate't mâner, sau don't încercați să mai deștept decât potențialul cod reutilizatori, poate au un motiv bun de a nu trece un int la funcție.

De ce nu incerci ceva de genul:

if x%1 == 0: 

Mai degrabă decât să complice lucrurile, de ce nu doar un simplu

if type(var) is int:

O simplă metodă pe care o folosesc în toate software-ul meu este asta. Se verifică dacă variabila este formata din numere.

test = input("Enter some text here: ")
if test.isdigit() == True:
   print("This is a number.")
else:
   print("This is not a number.")

l's cu adevărat uimitor pentru a vedea un astfel de discuții aprinse vine atunci când o astfel de bază, valabile și, cred eu, lumesc întrebarea este întrebat.

unii oameni au subliniat faptul că tipul de verificare împotriva int (și "lung") și-ar putea pierde cazurile în care un mare număr zecimal este întâlnită. destul de bine.

unii oameni au subliniat faptul că ar trebui să 'fă x + 1 și a vedea dacă aceasta nu reușește. ei bine, pentru un singur lucru, aceasta funcționează pe plutește prea, și, pe de altă parte,'s ușor de a construi o clasă care nu este cu siguranta foarte numeric, dar definește pe " + " operator într-un fel.

eu sunt în contradicție cu mai multe posturi viguros declarând că nu ar trebui să verificați pentru tipuri. ei bine, GvR a spus odată ceva în sensul că, în teorie pură, care poate fi drept, dar, în practică, isinstance de multe ori servește unui scop util (ca's un timp în urmă, don't au link-ul, puteți citi ce GvR spune despre problemele legate in mesaje de genul asta).

ceea ce este amuzant este cât de mulți oameni par să presupunem că PO's intenția a fost de a verifica dacă tip o dat " x "este un numerice de tip întreg—ceea ce am înțeles este ceea ce nu înseamnă în mod normal atunci când se utilizează OP's cuvinte: dacă" x " reprezintă un număr întreg. și acest lucru poate fi foarte important: ca întreb pe cineva cât de multe elemente au'd vreau sa iau, poate doriți să verificați ai un non-negative număr întreg înapoi. utilizați cazuri de acest gen abundă.

l's, de asemenea, în opinia mea, este important să vedem că (1) verificarea de tip, dar este UNUL—și de multe ori destul de grosier—măsură a corectitudinii programelor, pentru că (2) este de multe ori delimitată de valorile care au sens, și out-of-limite valori care fac prostii. uneori, doar unele intermitente valori sens—ca în considerare toate numerele, doar cei real (non-complexe), numere întregi ar putea fi posibil într-un caz dat.

amuzant non-pare să mai vorbim de verificare pentru x == math.floor( x ). dacă asta s-ar da o eroare cu un mare zecimal clasa, ei bine, atunci poate l's timp pentru a re-gândi OOP paradigme. există, de asemenea, PEP 357, care consideră că modul de a utiliza nu-așa-evident-int-dar-cu siguranță-număr întreg-ca valori pentru a fi folosit ca listă de indici. nu sunt sigur dacă îmi place soluția.

A găsit-o întrebare legate aici pe ATÂT de sine.

Dezvoltatorii Python prefera să nu pentru a verifica tipuri dar nu un tip specific de funcționare și prinde un Nume excepție. Dar dacă nu't știu tip apoi aveți următoarele.

>>> i = 12345
>>> type(i)

>>> type(i) is int
True

de ce nu a verifica dacă valoarea pe care doriți să verificați este egal cu sine însuși aruncat ca un întreg, așa cum se arată mai jos?

def isInt(val):
    return val == int(val)

Dacă doriți să verificați un șir de caractere format doar din cifre, ci de conversie la int câștigat't ajuta, întotdeauna puteți folosi doar 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"

În acest caz, dacă x au fost "buna ziua", conversia de la un tip numeric-ar arunca o ValueError, dar datele vor fi, de asemenea, pierdut în acest proces. Folosind un regex și prinderea un AttributeError ar permite să confirmați caractere numerice într-un șir cu, de exemplu, de conducere 0's.

Dacă ai n't vreau pentru a arunca o AttributeError, ci a vrut doar să se uite pentru mai multe probleme specifice, ai putea varia regex și verificați meci:

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"

Care de fapt vă arată în cazul în care problema cu a avut loc fără utilizarea de excepții. Din nou, acest lucru nu este pentru testarea tip, ci mai degrabă în cea a personajelor. Acest lucru vă oferă mult mai multă flexibilitate decât pur și simplu de verificare pentru tipuri, mai ales atunci când de conversie între tipuri pot pierde importante de date șir de caractere, cum ar fi lider 0's.

Puteți folosi, de asemenea, str.isdigit. Încercați să căutați pentru ajutor(str.isdigit)`

def is_digit(str):
      return str.isdigit()

Dacă variabila este introdus ca un șir de caractere (de exemplu,'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.

Înainte de a utiliza acest lucru l-am lucrat cu încerc/cu excepția și verificare pentru(int(variabilă)), dar a fost mai mult cod. Mă întreb dacă nu's nici o diferență în utilizarea de resurse sau de viteza.

Aici este un exemplu simplu cum puteți determina un număr întreg

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    

Dacă ai nevoie doar de valoare**, operator.indicele (__index__ metodă specială) este calea de a merge, în opinia mea. Când ar trebui să funcționeze pentru toate tipurile care pot fi în condiții de siguranță a aruncat la un număr întreg. I. e. plutește eșua, numere întregi, chiar de lux întreg clase care nu pun în aplicare Integral clasă abstractă munca de rață dactilografiere.

operator.index este ceea ce este folosit pentru lista de indexare, etc. Și în opinia mea ar trebui să fie utilizate pentru mai mult/promovat.

De fapt, aș spune că este singura cale corectă pentru a obține valori întregi, dacă vrei să fii sigur că plutitoare de puncte, din cauza trunchierea probleme, etc. sunt respinse și funcționează cu toate integrantă tipuri (de exemplu, numpy, etc.) chiar dacă ele nu pot (încă) să sprijine clasă abstractă.

Aceasta este ceea ce __index__ a fost introdus pentru!

În prezența numpy verificați ca ..

isinstance(var, numbers.Integral)

.. (lent) sau ..

isinstance(var, (int, long, np.integer))

.. în scopul de a se potrivi toate tipurile de variante ca np.int8, np.uint16, ...

(Drop "lung" în PY3)

Recunoscând ORICE număr întreg-ca obiect de oriunde este un complicat joc de-a ghicitul. Verificarea

var & 0 == 0 

pentru adevăr și non-excepție ar putea fi un pariu bun. În mod similar, verificarea semnat de tip întreg exclusiv:

var ^ -1 ==  -var - 1

Dacă doriți să verificați cu nici un sens pentru versiunea Python (2.x vs 3.x), utilizarea ["șase"] (http://pythonhosted.org/six/) (PyPI) și it's integer_types atribut:

import six

if isinstance(obj, six.integer_types):
    print('obj is an integer!')

În "șase" (o lumină-greutate single-modul fișier), l's pur și simplu a face acest lucru:

import sys
PY3 = sys.version_info[0] == 3

if PY3:
    integer_types = int,
else:
    integer_types = (int, long)

Dacă sunteți de lectură dintr-un fișier și aveți o matrice sau un dictionar cu valori multiple tipuri de date, următoarele vor fi utile. Doar a verifica dacă variabila poate fi de tip puse la int(sau orice alt tip de date doriți să pună în aplicare) sau nu.

try :
    int(a);
    #Variable a is int
except ValueError : 
    # Variable a is not an int

Dacă nu te-ai int puteți face doar asta:

var = 15.4
if(var - int(var) != 0):
    print "Value is not integer"