it-swarm.com.de

Prüfen, ob eine Variable eine ganze Zahl ist oder nicht

Wie überprüfe ich, ob eine Variable eine ganze Zahl ist?

707
Hulk

Wenn Sie dies tun müssen, tun Sie dies

isinstance(<var>, int)

es sei denn, Sie befinden sich in Python 2.x. In welchem ​​Fall möchten Sie

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

Verwenden Sie nicht type. Es ist fast nie die richtige Antwort in Python, da es die Flexibilität des Polymorphismus blockiert. Wenn Sie beispielsweise die Unterklasse int verwenden, sollte sich Ihre neue Klasse als int registrieren, was type nicht tut:

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

Dies hält an Pythons starkem Polymorphismus fest: Sie sollten jedem Objekt, das sich wie eine int verhält, erlauben, anstatt zu verlangen, dass es eins ist.

ABER

Die klassische Python-Mentalität besteht jedoch darin, dass es leichter um Vergebung als um Erlaubnis zu bitten ist. Mit anderen Worten, prüfen Sie nicht, ob x eine ganze Zahl ist. Nehmen Sie an, dass dies der Fall ist, und fangen Sie die Ausnahmeergebnisse ab, wenn dies nicht der Fall ist:

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

Diese Mentalität wird langsam durch die Verwendung von abstrakten Basisklassen überholt, mit denen Sie genau registrieren können, welche Eigenschaften Ihr Objekt haben sollte (indem Sie "Multiplizieren" hinzufügen), indem Sie es von einer speziell konstruierten Klasse erben lassen. Das wäre die beste Lösung, da es genau Objekte mit den erforderlichen und ausreichenden Attributen zulässt, aber Sie müssen die Dokumente lesen, wie sie verwendet werden.

851
Katriel

Alle bisher vorgeschlagenen Antworten scheinen die Tatsache zu übersehen, dass ein Double (Floats in Python sind eigentlich Doubles) auch eine ganze Zahl sein kann (wenn es nach dem Dezimalzeichen nichts hat). Um dies zu überprüfen, verwende ich die eingebaute is_integer()-Methode für Doubles.

Beispiel (um jedes xte Mal in einer for-Schleife etwas zu tun):

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

Bearbeiten:

Sie können vor dem Aufruf dieser Methode immer in ein Float konvertieren. Die drei Möglichkeiten:

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

Andernfalls könnten Sie prüfen, ob es sich um ein int erstes handelt, wie Agostino sagte:

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

Wenn Sie really überprüfen müssen, ist es besser, abstrakte Basisklassen als konkrete Klassen zu verwenden. Für eine ganze Zahl würde das bedeuten:

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

Dies beschränkt die Prüfung nicht nur auf int oder nur int und long, sondern ermöglicht auch die Verwendung anderer benutzerdefinierter Typen, die sich als Ganzzahlen verhalten.

54
Scott Griffiths

Hier ist eine Zusammenfassung der verschiedenen hier genannten Methoden:

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

und so werden sie auf eine Vielzahl von numerischen Typen angewendet, die einen ganzzahligen Wert haben:

Table of methods for checking whether Python numerical types are integers

Sie können sehen, dass sie nicht zu 100% konsistent sind. Bruch und Rational sind konzeptionell identisch, aber einer liefert eine .index() -Methode und der andere nicht. Komplexe Typen konvertieren nicht gerne in int, auch wenn der Realteil ein Integral und der Imaginärteil 0 ist.

(np.int8|16|32|64(5) bedeutet, dass np.int8(5), np.int32(5) usw. sich alle gleich verhalten)

53
endolith
>>> isinstance(3, int)
True

hier für mehr.

Beachten Sie, dass dies nicht hilfreich ist, wenn Sie nach int-ähnlichen Attributen suchen. In diesem Fall können Sie auch nach long suchen:

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

Ich habe solche Prüfungen mit einem Array-/Indextyp in der Python-Quelle gesehen, aber ich glaube nicht, dass dies außerhalb von C sichtbar ist.

Token SO antworten: Sind Sie sicher, dass Sie den Typ überprüfen sollten? Entweder übergeben Sie keinen Typ, mit dem Sie nicht umgehen können, oder versuchen Sie nicht, Ihre potenziellen Code-Wiederverwender zu überlisten. Sie haben möglicherweise einen guten Grund, ein int nicht an Ihre Funktion zu übergeben.

35
Matt Joiner

Warum versuchen Sie nicht etwas wie:

if x%1 == 0: 
21
Parsa

Anstatt zu kompliziert, warum nicht einfach ein einfaches

if type(var) is int:
18
Dairy Window

Eine einfache Methode, die ich in meiner gesamten Software verwende, ist diese. Es wird geprüft, ob die Variable aus Zahlen besteht.

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

es ist wirklich erstaunlich zu sehen, wie eine hitzige Diskussion entsteht, wenn eine so grundlegende, gültige und, wie ich glaube, banale Frage gestellt wird. 

einige Leute haben darauf hingewiesen, dass die Typprüfung gegen int (und long) Fälle verlieren kann, in denen eine große Dezimalzahl vorkommt. ganz richtig.

einige Leute haben darauf hingewiesen, dass Sie x + 1 einfach tun sollten und sehen sollten, ob dies fehlschlägt. Nun, zum einen funktioniert das auch auf Floats, und andererseits ist es einfach, eine Klasse zu konstruieren, die definitiv nicht sehr numerisch ist, jedoch den +-Operator irgendwie definiert.

ich stehe im Widerspruch zu vielen Beiträgen, die nachdrücklich erklären, dass Sie nicht nach Typen suchen sollten. Nun, der GvR hat einmal etwas dazu gesagt, dass in der reinen Theorie das vielleicht richtig sein könnte, aber in der Praxis dient isinstance oft einem nützlichen Zweck (das ist vor einer Weile, haben Sie den Link nicht; Sie können lesen, was GvR sagt zu verwandten Themen in Posts wie diesem ).

komisch ist, wie viele Leute anscheinend davon ausgehen, dass es das Ziel des OP war zu prüfen, ob der type eines gegebenen x ein numerischer Integer-Typ ist Wörter: Gibt an, ob x eine ganze Zahl ist. Und das kann sehr wichtig sein: Wenn Sie jemanden fragen, wie viele Elemente Sie auswählen möchten, möchten Sie vielleicht prüfen, ob Sie eine nicht negative Ganzzahl zurückbekommen. Anwendungsfälle wie diese gibt es zuhauf. 

meines Erachtens ist es auch wichtig zu sehen, dass (1) die Typprüfung nur EINES - und oft ziemlich grobe - Maß für die Programmkorrektheit ist, weil (2) oft beschränkte Werte Sinn machen und Werte außerhalb des zulässigen Bereichs liegen das macht Unsinn. Manchmal sind nur einige intermittierende Werte sinnvoll. Wenn Sie alle Zahlen berücksichtigen, sind in einem bestimmten Fall nur die reellen (nicht komplexen) Ganzzahlen möglich. 

ein lustiger Nicht-Eins scheint die Überprüfung auf x == math.floor( x ) zu erwähnen. Wenn dies einen Fehler mit einer großen Dezimalklasse ergeben sollte, dann ist es vielleicht an der Zeit, OOP Paradigmen zu überdenken. Es gibt auch PEP 357 , das überlegt, wie nicht so offensichtlich -int-, aber sicherlich ganzzahlige Werte verwendet werden, um als Listenindizes verwendet zu werden. Ich weiß nicht, ob ich die Lösung mag.

11
flow

Eine verwandte Frage hier auf SO selbst gefunden.

Python-Entwickler ziehen es vor, Typen nicht zu überprüfen, sondern eine typspezifische Operation auszuführen und eine TypeError-Ausnahme abzufangen. Wenn Sie den Typ nicht kennen, haben Sie Folgendes.

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

Wenn Sie überprüfen möchten, dass eine Zeichenfolge nur aus Ziffern besteht, die Umwandlung in ein int jedoch nicht hilft, können Sie immer nur reguläre Ausdrücke verwenden.

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 diesem Fall würde, wenn x "Hallo" wäre, die Konvertierung in einen numerischen Typ einen ValueError auslösen, es würden jedoch auch Daten verloren gehen. Wenn Sie einen Regex verwenden und einen AttributeError abfangen, können Sie numerische Zeichen in einer Zeichenfolge beispielsweise mit führenden 0-Zeichen bestätigen.

Wenn Sie nicht wollten, dass ein AttributeError geworfen wird, sondern nur nach spezifischeren Problemen gesucht werden soll, können Sie den regulären Ausdruck variieren und einfach die Übereinstimmung überprüfen:

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"

Das zeigt Ihnen tatsächlich, wo das Problem aufgetreten ist, ohne Ausnahmen zu verwenden. Dies ist wiederum nicht zum Testen des Typs gedacht, sondern für die Zeichen selbst. Dies bietet Ihnen weitaus mehr Flexibilität als das einfache Prüfen auf Typen. Dies gilt insbesondere, wenn bei der Konvertierung zwischen Typen wichtige Zeichenfolgendaten wie führende Nullen verloren gehen können.

8
sudokode

warum nicht einfach prüfen, ob der Wert, den Sie prüfen möchten, gleich der als Ganzzahl gegossenen Zahl ist (siehe unten)?

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

Hier ist ein einfaches Beispiel, wie Sie eine ganze Zahl ermitteln können

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    
4
PradeepNama

Wenn die Variable wie eine Zeichenfolge eingegeben wird (z. B. '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.

Bevor ich das benutzte, arbeitete ich mit try/except und überprüfte (int(variable)), aber es war länger Code. Ich frage mich, ob es Unterschiede in der Verwendung von Ressourcen oder in der Geschwindigkeit gibt.

4
Ramon Suarez

verwenden Sie die Funktion int, um zu helfen

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')
3
the noob

Wenn Sie aus einer Datei lesen und über ein Array oder ein Wörterbuch mit Werten für mehrere Datentypen verfügen, ist Folgendes hilfreich: Prüfen Sie, ob die Variable in den Typ int konvertiert werden kann (oder einen anderen Datentyp, den Sie erzwingen möchten). oder nicht. 

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

Ein einfacher Weg, dies zu tun, besteht darin, direkt zu prüfen, ob der Rest bei Division durch 1 0 ist oder nicht.

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

In Anwesenheit von numpy check like ..

isinstance(var, numbers.Integral)

.. (langsam) oder ..

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

.. um alle Typvarianten wie np.int8, np.uint16, ... abzugleichen.

(Drop long in PY3)

Das Erkennen vonJEDEMInteger-ähnlichen Objekt von überall ist ein schwieriges Ratespiel. Überprüfung 

var & 0 == 0 

für Wahrheit und Nicht-Ausnahme kann eine gute Wette sein. Ebenso wird ausschließlich auf vorzeichenbehaftete Ganzzahl geprüft :

var ^ -1 ==  -var - 1
3
kxr

Wenn Sie nur das value benötigen, ist operator.index (__index__ spezielle Methode) meiner Meinung nach der richtige Weg. Da sollte es für alle Typen funktionieren, die sicher in eine Ganzzahl umgewandelt werden können. Das heißt Floats versagen, ganze Zahlen, sogar ausgefallene Ganzzahlenklassen, die die Arbeit der Integral-abstrakten Klasse nicht durch Ententypisierung implementieren.

operator.index ist das, was für die Indexierung von Listen usw. verwendet wird. Meiner Meinung nach sollte es für viel mehr verwendet werden.

In der Tat würde ich behaupten, dass es der einzige richtige Weg ist, ganzzahlige Werte zu erhalten, wenn Sie sicherstellen möchten, dass Fließpunkte aufgrund von Abschneidungsproblemen usw. abgelehnt werden und dass sie mit allen Integraltypen (z. B. numpy usw.) auch dann funktionieren Sie können die abstrakte Klasse (noch) nicht unterstützen. 

Dafür wurde __index__ eingeführt für!

3
seberg

Wenn Sie die Python-Version (2.x vs. 3.x) ohne Rücksicht prüfen möchten, verwenden Sie six ( PyPI ) und das integer_types-Attribut:

import six

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

Innerhalb von six (ein sehr leichtes Einzeldateimodul) wird einfach Folgendes ausgeführt:

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

if PY3:
    integer_types = int,
else:
    integer_types = (int, long)
3
Nick T

Ein allgemeinerer Ansatz, bei dem versucht wird, sowohl nach Ganzzahlen als auch nach Ganzzahlen zu suchen, die als Zeichenfolgen angegeben werden, ist

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
2
Julian Chukwu

Wenn Sie nicht int haben, können Sie Folgendes tun:

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

Ich schrieb ein Programm, um zu überprüfen, ob eine Zahl quadratisch war, und bei diesem Problem trat der -Code auf, den ich verwendete:

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

Um zu bestimmen, ob die Zahl eine Ganzzahl ist, wandelte ich die Float-Zahl um, die Sie erhalten, wenn Sie die Benutzereingabe in eine gerundete Ganzzahl setzen (als Wert gespeichert). Wenn diese beiden Zahlen gleich sind, muss die erste Zahl eine Ganzzahl gewesen sein Programm zu reagieren. Dies ist vielleicht nicht der kürzeste Weg, aber es hat für mich funktioniert. 

2
Tom
#!/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)
2
Ben

Ich kann überprüfen, ob die Zahl eine ganze Zahl ist wie 7.0

def is_int(x):
    if x - round(x) == 0 :
        return True
    else:
        return False
0
CRB BELOUIZDAD

Testen, ob Objekt eine Zeichenfolge ist (funktioniert mit Python 2. * und Python 3. *)

text = get_text()

try:
    text = text+""
except:
    return "Not a string"

do_something(text)
0
Mika72

Betrachten Sie den Fall x = n ** (1,0/m), wobei n = 10 ** 5, m = 5 ist. In Python ist x 10.000000000000002, was aufgrund von Gleitkomma-Arithmetikoperationen nur keine Ganzzahl ist.

Also würde ich nachsehen

if str(float(x)).endswith('.0'): print "It's an integer."

Ich habe es mit diesem Code getestet:

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

Es gibt True für alle a und b aus.

0
Péter Elekes

Du kannst das. 

if type(x) is int:
0
val=3
>>> isinstance(val,int ) 
True

wird funktionieren.

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

Rufen Sie diese Funktion auf:

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

Der einfachste Weg ist:

if n==int(n):
    --do something--    

Wobei n die Variable ist

0
youssef ahmd

Wenn Sie einen mit Python 2-3 kompatiblen Code schreiben möchten

Um zu testen, ob ein Wert eine ganze Zahl (irgendeiner Art) ist, können Sie Folgendes tun:

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

quelle: http://python3porting.com/differences.html

0
King's jester
if type(input('enter = '))==int:
     print 'Entered number is an Integer'
else:
     print 'Entered number isn't an Integer'

Dies funktioniert, um herauszufinden, ob number eine ganze Zahl ist oder nicht 

0
Prashant Shukla

Ich habe es versucht und es funktioniert.

x = 'place_hold' 
num = input("num: ")
try:
   int(num)
   x = 'valid'
except ValueError: 
   x = 'invalid' 
print(x)
0
Justin

Sie können auch str.isdigit verwenden. Nachschlagen help(str.isdigit)

def is_digit(str):
      return str.isdigit()
0
Fariman Kashani

Es gibt eine weitere Option, um die Typprüfung durchzuführen. 

Zum Beispiel:

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

sie können dies durch:

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

und es wird 'this works' zurückgegeben ... aber wenn Sie den Namen in int (1) ändern, wird 'this funktioniert nicht' zurückgegeben, da es sich jetzt um einen String handelt ... Sie können auch Folgendes versuchen:

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

und dasselbe wird passieren

0
user2422913

Das Einchecken von Python ist sehr einfach. Das kannst du so machen:

Angenommen, Sie möchten prüfen, ob eine Variable ganzzahlig ist oder nicht!

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