Hoe controleer ik of een variabele een geheel getal is?

Antwoord 1, autoriteit 100%

Als je dit moet doen, doe dan

isinstance(<var>, int)

tenzij je in Python 2.x zit, in welk geval je wilt

isinstance(<var>, (int, long))

Gebruik geen type. Het is bijna nooit het juiste antwoord in Python, omdat het alle flexibiliteit van polymorfisme blokkeert. Als u bijvoorbeeld intsubclasseert, moet uw nieuwe klasse zich registreren als een int, wat typeniet zal doen:

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

Dit komt overeen met het sterke polymorfisme van Python: je moet elk object toestaan dat zich als een intgedraagt, in plaats van te verplichten dat het er één is.

MAAR

De klassieke Python-mentaliteit is echter dat het gemakkelijker is om vergeving te vragen dan om toestemming. Met andere woorden, controleer niet of xeen geheel getal is; neem aan dat dit het geval is en vang de uitzonderingsresultaten als dit niet het geval is:

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

Deze mentaliteit wordt langzaam ingehaald door het gebruik van abstracte basisklassen , die liet U registreert precies welke eigenschappen uw object zou moeten hebben (toevoegen? Vermenigvuldigen? Verdubbeling?) Door het te laten erven van een speciaal geconstrueerde klasse. Dat zou de beste oplossing zijn, omdat het precies toestaan ​​met de noodzakelijke en voldoende attributen, maar u moet de documenten lezen over het gebruik ervan.

Antwoord 2, Autoriteit 10%

Alle voorgestelde antwoorden tot nu toe lijken het feit te missen dat een dubbele (drijftingen in Python eigenlijk verdubbelt) kan ook een geheel getal zijn (als het niets na het decimale punt heeft). Ik gebruik de ingebouwde is_integer()methode op doubles om dit te controleren.

Voorbeeld (om iets elke XTE-keer in een voor lus te doen):

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

EDIT:

U kunt altijd converteren naar een float voordat u deze methode belt. De drie mogelijkheden:

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

Anders zou je kunnen controleren of het een int is als eerste zoals Agostino zei:

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

Antwoord 3, Autoriteit 9%

Hier is een samenvatting van de verschillende hier genoemde methoden:

• int(x) == x
• try x = operator.index(x)
• isinstance(x, int)
• isinstance(x, numbers.Integral)

en hier is hoe ze van toepassing zijn op verschillende numerieke typen die een geheel getal hebben:

Je kunt zien dat ze niet 100% consistent zijn. Breuk en Rationeel zijn conceptueel hetzelfde, maar de ene levert een .index()methode en de andere niet. Complexe typen worden niet graag geconverteerd naar int, zelfs als het reële deel integraal is en het imaginaire deel 0.

(np.int8|16|32|64(5)betekent dat np.int8(5), np.int32(5), enz. gedragen zich allemaal identiek)

Antwoord 4, autoriteit 6%

Als u echtmoet controleren, kunt u beter abstracte basisklassenin plaats van concrete klassen. Voor een geheel getal zou dat betekenen:

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

Dit beperkt de controle niet tot alleen int, of alleen inten long, maar staat ook andere door de gebruiker gedefinieerde typen toe die gedraag je als gehele getallen om te werken.

Antwoord 5, autoriteit 3%

>>> isinstance(3, int)
True

Zie hiervoor meer informatie.

Merk op dat dit niet helpt als u op zoek bent naar int-achtige attributen. In dit geval wil je misschien ook longcontroleren:

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

Ik heb dit soort controles gezien met een array/index-type in de Python-bron, maar ik denk niet dat dat zichtbaar is buiten C.

Token SO antwoord:Weet je zeker dat je het type moet controleren? Geef geen type door dat u niet aankan, of probeer uw potentiële codehergebruikers niet te slim af te zijn, ze kunnen een goede reden hebben om geen int door te geven aan uw functie.

Antwoord 6, autoriteit 2%

Waarom probeer je niet zoiets als:

if x%1 == 0: 

Antwoord 7

In plaats van dingen te ingewikkeld te maken, waarom niet gewoon een simpele

if type(var) is int:

Antwoord 8

Een eenvoudige methode die ik in al mijn software gebruik, is deze. Het controleert of de variabele uit getallen bestaat.

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

Antwoord 9

het is echt verbazingwekkend om zo’n verhitte discussie te zien opkomen wanneer zo’n fundamentele, geldige en, geloof ik, alledaagse vraag wordt gesteld.

sommige mensen hebben erop gewezen dat typecontrole met int(en long) gevallen kan opleveren waarin een groot decimaal getal wordt aangetroffen. helemaal gelijk.

sommige mensen hebben erop gewezen dat je ‘gewoon x + 1moet doen en kijken of dat niet lukt. Nou, om te beginnen werkt dit ook op floats, en aan de andere kant is het gemakkelijk om een klasse te construeren die zeker niet erg numeriek is, maar de operator +op de een of andere manier definieert.

Ik ben op gespannen voeten met veel berichten die krachtig verklaren dat u niet moet controleren op typen. Welnu, GVR zei ooit iets met het effect dat in pure theorie, die misschien goed is, maar in de praktijk, isinstancevaak een nuttig doel (dat is een tijdje geleden, niet de link kan lezen wat GVR zegt over gerelateerde problemen in posts zoals deze ).

Wat is grappig, is hoeveel mensen erop lijken aan te nemen dat de bedoeling de bedoeling was om te controleren of het type van een bepaalde xeen numeriek geheel getal is – wat ik begreep Is wat ik normaal gesproken bedoel bij het gebruik van de woorden van het OP: of xeen geheel getal weergeeft. En dit kan erg belangrijk zijn: zoals het vragen van iemand Hoeveel items die ze willen kiezen, wil je misschien controleren of je een niet-negatief getal-nummer terug krijgt. Gebruik gevallen zoals deze in overvloed.

Het is ook, naar mijn mening, belangrijk om te zien dat (1) typecontrole, maar één-en vaak behoorlijk grove maatstaf voor de juistheid van het programma, omdat (2) het vaak begrensde waarden is die logisch zijn, en uit -bonden waarden die onzin maken. Soms zijn slechts enkele intermitterende waarden sense-achtig gezien alle getallen, alleen die echte (niet-complexe), integer-nummers mogelijk in een bepaald geval mogelijk zijn.

Grappig Non-One lijkt te vermelden controleren op x == math.floor( x ). Als dat een foutmelding zou moeten geven met een grote decimale klas, dan is het misschien tijd om Oop Paradigma’s opnieuw te denken. Er is ook PEP 357 die rekening houdt met het gebruik van niet-zo-natuurlijk- int-Maar-zeker-integer-achtige waarden die als lijstindices moeten worden gebruikt. niet zeker of ik de oplossing leuk vind.

Antwoord 10

Gevonden een gerelateerde vraaghier op SO zelf.

Python-ontwikkelaars controleren liever geen typen, maar voeren een typespecifieke bewerking uit en vangen een TypeError-uitzondering op. Maar als je het type niet weet, heb je het volgende.

>>> i = 12345
>>> type(i)
<type 'int'>
>>> type(i) is int
True

Antwoord 11

Je kunt ook str.isdigitgebruiken. Probeer help(str.isdigit)

. op te zoeken

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

Antwoord 12

Als je wilt controleren of een string alleen uit cijfers bestaat, maar converteren naar een int niet helpt, kun je altijd regex gebruiken.

import re
x = "01234"
match = re.search("^\d+$", x)
try: x = match.group(0)
except AttributeError: print("not a valid number")
Result: x == "01234"

In dit geval, als x “hallo” zou zijn, zou het converteren naar een numeriek type een ValueError opleveren, maar er zouden ook gegevens verloren gaan in het proces. Als u een regex gebruikt en een AttributeError opvangt, kunt u numerieke tekens in een tekenreeks bevestigen met bijvoorbeeld voorloopnullen.

Als je niet wilt dat er een AttributeError wordt gegenereerd, maar in plaats daarvan naar meer specifieke problemen wilt zoeken, kun je de regex variëren en gewoon de overeenkomst controleren:

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"

Dat laat zien waar het probleem zich voordeed, zonder het gebruik van uitzonderingen. Nogmaals, dit is niet om het type te testen, maar eerder de karakters zelf. Dit geeft je veel meer flexibiliteit dan alleen het controleren op typen, vooral wanneer het converteren tussen typen belangrijke tekenreeksgegevens kan verliezen, zoals voorloopnullen.

Antwoord 13

waarom niet gewoon controleren of de waarde die u wilt controleren gelijk is aan zichzelf, gegoten als een geheel getal, zoals hieronder weergegeven?

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

Antwoord 14

In aanwezigheid van numpycontroleer zoals ..

isinstance(var, numbers.Integral)

.. (langzaam) of ..

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

.. om alle typevarianten zoals np.int8, np.uint16, …

te matchen

(Laat longvallen in PY3)

Het herkennen van ELKEinteger-achtig object van waar dan ook is een lastig raadspel. Controleren

var & 0 == 0 

want waarheid en niet-uitzondering kunnen een goede gok zijn. Evenzo, controleren op uitsluitend ondertekend integer type:

var ^ -1 ==  -var - 1

Antwoord 15

Als de variabele als een tekenreeks wordt ingevoerd (bijv. '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.

Voordat ik dit gebruikte, heb ik het uitgewerkt met try/excepten gecontroleerd op (int(variable)), maar het was langere code. Ik vraag me af of er enig verschil is in het gebruik van middelen of snelheid.

Antwoord 16

Hier is een eenvoudig voorbeeld hoe u een geheel getal kunt bepalen

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    

Antwoord 17

Als je alleen de waardenodig hebt, is operator.index(__index__speciale methode) naar mijn mening de juiste keuze. Omdat het zou moeten werken voor alle typen die veilig naar een geheel getal kunnen worden gecast. D.w.z. floats mislukken, integers, zelfs fancy integer-klassen die de Integral-abstract-klasse niet implementeren, werken door duck-typing.

operator.indexis wat wordt gebruikt voor het indexeren van lijsten, enz. En naar mijn mening zou het voor veel meer/promotie moeten worden gebruikt.

In feite zou ik zeggen dat dit de enige juiste manier is om integer-waarden te krijgen als je er zeker van wilt zijn dat zwevende punten, vanwege problemen met het afkappen, etc. worden afgewezen en het werkt met alle integrale typen (dwz numpy, etc. ) zelfs als ze de abstracte klasse (nog) niet ondersteunen.

Hiervoor werd __index__geïntroduceerd!

Antwoord 18

Als je wilt controleren zonder rekening te houden met de Python-versie (2.x vs 3.x), gebruik dan six(PyPI) en het is integer_typesattribuut:

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

binnen six(een zeer lichtgewicht single-file-module), het doet dit gewoon:

import sys
PY3 = sys.version_info[0] == 3
if PY3:
    integer_types = int,
else:
    integer_types = (int, long)

Antwoord 19

Een eenvoudige manier om dit te doen, is direct controleren of de rest op divisie met 1 0 is of niet.

if this_variable % 1 == 0:
    list.append(this_variable)
else:
    print 'Not an Integer!'

Antwoord 20

Als u uit een bestand leest en u een array of woordenboek hebt met waarden van meerdere datatypes, zijn het volgende handig.
Controleer gewoon of de variabele typen kan worden gegoten naar INT (of een ander datatype dat u wilt afdwingen) of niet.

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

Antwoord 21

Het is heel eenvoudig om in Python in te checken. Je kunt dit leuk doen:

Stel dat u een variabele wilt controleren, is integer of niet!

## 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")

Antwoord 22

Gebruik de int-functie om

te helpen

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')

Antwoord 23

U kunt dit doen.

if type(x) is int:

Antwoord 24

#######################################
# Value_Is_Int
#######################################
def value_is_int(value):
    try:
        tempVal = int(value)
        return True
    except:
        return False

Bel deze functie:

if value_is_int(value):
    print "Integer"
else:
    print "Not integer"

Antwoord 25

Als u niet int kunt u dit doen:

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

Antwoord 26

Als u een Python 2-3-compatibele code wilt schrijven

Te testen of een waarde een geheel getal is (van welke aard dan ook), kunt u dit doen:

# 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):
    ...

Bron: http://python3port.com/diffferences.html

Antwoord 27

Een meer algemene benadering die zal proberen te controleren op zowel gehele getallen als gehele getallen die als strings worden gegeven

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

Antwoord 28

Ik heb een programma aan het schrijven om te controleren of een cijfer vierkant was en ik deze kwestie tegenkwamen, de
Gebruikte code was:

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!")

Om te vertellen of het getal een geheel getal was, bekeerde ik het vlotternummer dat u krijgt van Square Rooting De gebruikerinvoer naar een afgerond geheel getal (opgeslagen als de waarde), als die twee nummers gelijk zijn, moet het eerste nummer een geheel getal zijn , waardoor het programma kan reageren. Dit is misschien niet de kortste manier om dit te doen, maar het werkte voor mij.

Antwoord 29

U kunt dit doen door:

name = 'Bob'
if type(name) == str:
    print 'this works'
else:
    print 'this does not work'

En het zal ‘dit werken’ terugkeren … maar als je de naam wisselt naar int (1), dan zal het terugkeren ‘Dit werkt niet’ omdat het nu een string is …
U kunt het ook proberen:

name = int(5)
if type(name) == int:
    print 'this works'
else:
    print 'this does not work'

en hetzelfde gebeurt

ANTWOORD 30

Er is een andere optie om de typecontrole te doen.

Bijvoorbeeld:

 n = 14
  if type(n)==int:
  return "this is an int"