मैं जांच सकता हूं कि संख्या पूर्णांक है या नहीं, जैसे 7.0

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

अगर आपको ऐसा करने की ज़रूरत है, तो करो

isinstance(<var>, int)

जब तक कि आप Python 2.x में नहीं हैं, जिस स्थिति में आप चाहते हैं

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

type प्रयोग न करें। यह पाइथन में लगभग सही जवाब नहीं है, क्योंकि यह बहुरूपता की सभी लचीलापन को अवरुद्ध करता है। उदाहरण के लिए, यदि आप int subassass int , तो आपकी नई कक्षा को int रूप में पंजीकृत होना चाहिए, जो type नहीं करेगा:

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

यह पाइथन के मजबूत बहुरूपता का पालन करता है: आपको किसी भी वस्तु को एक int तरह व्यवहार करने की अनुमति देनी चाहिए, यह अनिवार्य है कि यह एक हो।

परंतु

शास्त्रीय पायथन मानसिकता, हालांकि, यह अनुमति से क्षमा मांगना आसान है । दूसरे शब्दों में, यह जांच न करें कि x एक पूर्णांक है या नहीं; मान लीजिए कि अपवाद परिणाम यह है और पकड़ते हैं यदि यह नहीं है:

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

इस मानसिकता को धीरे-धीरे अमूर्त आधार वर्गों के उपयोग से पीछे छोड़ दिया जा रहा है, जो आपको एक विशेष रूप से निर्मित कक्षा से प्राप्त करने के द्वारा आपके ऑब्जेक्ट में कौन से गुणों को जोड़ना चाहिए (जोड़ना? गुणा करना? दोगुना?)। यह सबसे अच्छा समाधान होगा, क्योंकि यह उन वस्तुओं को आवश्यक और पर्याप्त विशेषताओं के साथ अनुमति देगा, लेकिन आपको इसका उपयोग करने के तरीके पर दस्तावेज़ों को पढ़ना होगा।

इस तरह के एक बुनियादी, वैध और, मुझे विश्वास है कि इस तरह की एक गर्म चर्चा देखने के लिए वास्तव में आश्चर्यजनक है, सांसारिक सवाल पूछा जा रहा है।

कुछ लोगों ने इंगित किया है कि int (और long ) के खिलाफ टाइप-चेकिंग उन मामलों को खो सकती है जहां एक बड़ा दशमलव नंबर सामने आया है। बिलकुल सही।

कुछ लोगों ने इंगित किया है कि आपको ' x + 1 करना चाहिए और देखें कि क्या यह विफल रहता है। ठीक है, एक बात के लिए, यह भी तैरता पर काम करता है, और दूसरी तरफ, उस वर्ग को बनाना आसान है जो निश्चित रूप से बहुत संख्यात्मक नहीं है, फिर भी + ऑपरेटर को किसी भी तरह से परिभाषित करता है।

मैं कई पदों के साथ बाधाओं में जोरदार घोषणा कर रहा हूं कि आपको प्रकारों की जांच नहीं करनी चाहिए। ठीक है, जीवीआर ने एक बार प्रभाव के लिए कुछ कहा था कि शुद्ध सिद्धांत में, यह सही हो सकता है, लेकिन व्यावहारिक रूप से, isinstance अक्सर एक उपयोगी उद्देश्य प्रदान करता है (कुछ समय पहले, लिंक नहीं है; आप पढ़ सकते हैं कि जीवीआर संबंधित के बारे में क्या कहता है इस तरह की पोस्ट में मुद्दे)।

मजाकिया बात यह है कि कितने लोग मानते हैं कि ओपी का इरादा यह जांचना था कि किसी दिए गए x का प्रकार एक संख्यात्मक पूर्णांक प्रकार है-जो मैं समझता हूं वह है जिसका मतलब आम तौर पर ओपी के शब्दों का उपयोग करते समय होता है: क्या x एक पूर्णांक संख्या का प्रतिनिधित्व करता है । और यह बहुत महत्वपूर्ण हो सकता है: जैसे किसी से पूछें कि वे कितनी चीज़ें चुनना चाहते हैं, आप जांच सकते हैं कि आपको एक गैर-ऋणात्मक पूर्णांक संख्या वापस मिल जाएगी। इस तरह के मामलों का उपयोग करें।

यह भी मेरी राय में है कि यह देखने के लिए महत्वपूर्ण है कि (1) टाइपिंग जांच एक है और अक्सर प्रोग्राम की शुद्धता का काफी मोटा-माप है, क्योंकि (2) यह अक्सर मूल्यों को बाध्य करता है जो समझ में आता है, और सीमा से बाहर मूल्य जो बकवास करता है। कभी-कभी केवल कुछ अंतराल मूल्यों को समझते हैं-जैसे सभी संख्याओं पर विचार करना, केवल उन वास्तविक (गैर-जटिल), किसी दिए गए मामले में पूर्णांक संख्या संभव हो सकती है।

अजीब गैर-एक x == math.floor( x ) लिए जांच का जिक्र करना प्रतीत होता है। अगर उसे कुछ बड़े दशमलव वर्ग के साथ कोई त्रुटि देनी चाहिए, तो शायद ओओपी प्रतिमानों को फिर से सोचने का समय हो सकता है। पीईपी 357 भी है जो इस बात पर विचार करता है कि सूची सूचकांक के रूप में उपयोग किए जाने वाले int -बॉट-निश्चित रूप से पूर्णांक-जैसे मानों का उपयोग कैसे किया जाए। सुनिश्चित नहीं है कि मुझे समाधान पसंद है या नहीं।

एक और सामान्य दृष्टिकोण जो तारों के रूप में दिए गए पूर्णांक और पूर्णांक दोनों की जांच करने का प्रयास करेगा

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

ऐसा करने का एक आसान तरीका यह है कि सीधे जांच करें कि विभाजन पर शेष 1 0 है या नहीं।

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

कुछ ऐसा क्यों न करें:

if x%1 == 0: 

जटिल चीजों की बजाय, क्यों न सिर्फ एक साधारण

if type(var) is int:

टाइप चेक करने का एक और विकल्प है।

उदाहरण के लिए:

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

मदद करने के लिए int फंक्शन का उपयोग करें

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

मामले x = n ** (1.0 / m) पर विचार करें, जहां n = 10 ** 5, m = 5। पायथन में, एक्स 10.000000000000002 होगा, जो फ्लोटिंग पॉइंट अंकगणितीय परिचालनों के कारण केवल पूर्णांक नहीं है।

तो मैं जांच करूंगा

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

मैंने इस कोड के साथ इसका परीक्षण किया है:

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

यह सभी ए और बी के लिए सच साबित होता है।

मैं यह जांचने के लिए एक प्रोग्राम लिख रहा था कि कोई संख्या वर्ग थी या मुझे इस समस्या का सामना करना पड़ा, मैंने जो कोड इस्तेमाल किया था वह था:

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

यह बताने के लिए कि क्या नंबर एक पूर्णांक था, मैंने उपयोगकर्ता इनपुट को एक गोलाकार पूर्णांक (मान के रूप में संग्रहीत) में रूट करने के लिए प्राप्त फ्लोट नंबर को परिवर्तित किया, यदि उन दो संख्या बराबर थी तो पहला नंबर एक पूर्णांक होना चाहिए जवाब देने के लिए कार्यक्रम। यह ऐसा करने का सबसे छोटा तरीका नहीं हो सकता है लेकिन यह मेरे लिए काम करता है।

यदि आप किसी फ़ाइल से पढ़ रहे हैं और आपके पास एकाधिक डेटाटाइप के मानों वाला सरणी या शब्दकोश है, तो निम्न उपयोगी होगा। बस जांचें कि चर को int (या किसी भी अन्य डेटाटाइप जिसे आप लागू करना चाहते हैं) में डाला जा सकता है या नहीं।

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

यदि आप यह जांचना चाहते हैं कि एक स्ट्रिंग में केवल अंक होते हैं, लेकिन एक int में कनवर्ट करने में मदद नहीं होगी, तो आप हमेशा रेगेक्स का उपयोग कर सकते हैं।

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

Result: x == "01234"

इस मामले में, यदि एक्स "हैलो" थे, तो इसे एक संख्यात्मक प्रकार में परिवर्तित करने से वैल्यूएरर फेंक दिया जाएगा, लेकिन प्रक्रिया में डेटा भी खो जाएगा। एक रेगेक्स का उपयोग करके और एट्रिब्यूट एरर को पकड़ने से आप स्ट्रिंग में संख्यात्मक अक्षरों की पुष्टि कर सकते हैं, उदाहरण के लिए, 0 का अग्रणी।

यदि आप नहीं चाहते थे कि यह एक एट्रिब्यूट एरर फेंक दे, लेकिन इसके बजाय बस अधिक विशिष्ट समस्याओं की तलाश करना चाहते थे, तो आप रेगेक्स को बदल सकते हैं और बस मैच की जांच कर सकते हैं:

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"

यह वास्तव में आपको दिखाता है कि समस्याएं अपवादों के उपयोग के बिना हुईं। फिर, यह इस प्रकार के परीक्षण के लिए नहीं है, बल्कि पात्रों के लिए है। यह आपको आसानी से प्रकारों की जांच करने से अधिक लचीलापन देता है, विशेष रूप से जब प्रकारों के बीच परिवर्तित करना महत्वपूर्ण स्ट्रिंग डेटा खो देता है, जैसे 0 के अग्रणी।

यदि आपके पास int नहीं है तो आप यह कर सकते हैं:

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

यदि आपको केवल मूल्य की आवश्यकता है, operator.index ( __index__ विशेष विधि) मेरी राय में जाने का तरीका है। चूंकि इसे सभी प्रकार के लिए काम करना चाहिए जिन्हें सुरक्षित रूप से पूर्णांक में डाला जा सकता है। मैं फ्लोट असफल, पूर्णांक, यहां तक ​​कि फैंसी पूर्णांक कक्षाएं जो बतख टाइपिंग द्वारा इंटीग्रल अमूर्त वर्ग के काम को लागू नहीं करती हैं।

operator.index का उपयोग सूची अनुक्रमण आदि के लिए किया जाता है, और मेरी राय में इसे अधिक / प्रचारित के लिए उपयोग किया जाना चाहिए।

असल में मैं तर्क दूंगा कि यह पूर्णांक मान प्राप्त करने का एकमात्र सही तरीका है यदि आप यह सुनिश्चित करना चाहते हैं कि फ़्लोटिंग पॉइंट्स, फ्लोटिंग समस्याओं आदि के कारण अस्वीकार कर दिया गया है और यह सभी अभिन्न प्रकारों (यानी numpy, आदि) के साथ काम करता है, भले ही वे (अभी तक) अमूर्त वर्ग का समर्थन नहीं कर सकते हैं।

यह __index__ लिए पेश किया गया था!

यदि चर स्ट्रिंग की तरह दर्ज किया गया है (उदाहरण के लिए '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.

इसका उपयोग करने से पहले मैंने try/except और (int(variable)) जांच के साथ इसे काम किया, लेकिन यह लंबा कोड था। मुझे आश्चर्य है कि संसाधनों या गति के उपयोग में कोई अंतर है या नहीं।

यहां वर्णित विभिन्न विधियों का सारांश यहां दिया गया है:

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

और यहां बताया गया है कि वे विभिन्न संख्यात्मक प्रकारों पर कैसे लागू होते हैं जिनमें पूर्णांक मान होता है:

आप देख सकते हैं कि वे 100% अनुरूप नहीं हैं। फ्रैक्शन और तर्कसंगत वैचारिक रूप से वही हैं, लेकिन कोई एक .index() विधि प्रदान करता है और दूसरा नहीं करता है। जटिल भाग int में कनवर्ट करना पसंद नहीं करते हैं भले ही असली हिस्सा अभिन्न और काल्पनिक भाग 0 है।

सभी प्रस्तावित उत्तरों अब तक इस तथ्य को याद करते हैं कि एक डबल (पाइथन में तैरने वास्तव में युगल हैं) एक पूर्णांक भी हो सकता है (यदि उसके पास दशमलव बिंदु के बाद कुछ भी नहीं है)। मैं इसे जांचने के लिए युगल पर अंतर्निहित is_integer() विधि का उपयोग करता हूं।

उदाहरण (लूप के लिए प्रत्येक xth समय कुछ करने के लिए):

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

संपादित करें:

इस विधि को कॉल करने से पहले आप हमेशा एक फ्लोट में परिवर्तित कर सकते हैं। तीन संभावनाएं:

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

अन्यथा, आप जांच सकते हैं कि यह एंटोस्टिनो की तरह पहला इंट है या नहीं:

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

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

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

इस समारोह को कॉल करें:

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