दिलचस्प पोस्ट
जावास्क्रिप्ट रेगेक्स लटका हुआ है (वी 8 का उपयोग कर) संकेत 11 SIGSEGV दुर्घटना Android कार्यान्वयन C ++ 14 make_integer_sequence एंड्रॉइड: चेकबॉक्स श्रोता एक छवि w / कोई इनपुट फ़ील्ड पर क्लिक करके JQuery Datepicker खोलें एक्सेल VBA – खाली पंक्तियाँ हटाएं 'If' स्टेटमेंट्स में बहु-लाइन की स्थिति स्टाइल करना? जावा और .NET स्ट्रिंग literals कहाँ रहते हैं? "मुख्य वर्ग का पता या लोड नहीं किया जा सकता है" इसका मतलब क्या है? C # का उपयोग कर छवि को कैसे क्रॉप करना है? एंड्रॉइड में पृष्ठभूमि को कैसे सेट किया जा सकता है? कैसे जावास्क्रिप्ट के साथ विंडो पूर्ण स्क्रीन बनाने के लिए (स्क्रीन पर सभी को खींच कर) प्रोग्राम बैकस्टैक्स में पिछले खंड पर वापस जाएं स्ट्रिंग लिटरल संशोधित जावास्क्रिप्ट डोम हेरफेर के बाद इंटरनेट एक्सप्लोरर में डॉम रीफ्रेश को मजबूर करना

जांचते हुए कि कोई चर एक पूर्णांक है या नहीं

मैं कैसे जांचूं कि एक चर एक पूर्णांक है या नहीं?

वेब के समाधान से एकत्रित समाधान "जांचते हुए कि कोई चर एक पूर्णांक है या नहीं"

यदि आपको ऐसा करने की आवश्यकता है, तो क्या करें

 isinstance(<var>, int) 

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

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

type उपयोग न करें यह पायथन में लगभग सही उत्तर नहीं है, क्योंकि यह बहुरूपता के सभी लचीलेपन को ब्लॉक करता है। उदाहरण के लिए, यदि आप subclass 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: ... 

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

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

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

 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 

यदि आपको वास्तव में जांचना है तो कंक्रीट वर्गों के बजाय अमूर्त मूल कक्षाओं का उपयोग करना बेहतर होगा। एक पूर्णांक के लिए जिसका मतलब होगा:

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

यह चेक को सिर्फ int , या सिर्फ int और long सीमित नहीं करता है, बल्कि अन्य उपयोगकर्ता-निर्धारित प्रकार की अनुमति देता है जो काम करने के लिए पूर्णांक के रूप में व्यवहार करते हैं।

 >>> isinstance(3, int) True 

अधिक के लिए यहां देखें।

ध्यान दें कि यदि आप इंटैप्टीएचर एट्रिब्यूट्स की तलाश में हैं तो यह मदद नहीं करता है। इस मामले में आप long लिए भी जांच कर long :

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

मैंने अजगर स्रोत में एक सरणी / अनुक्रमणिका प्रकार के खिलाफ इस प्रकार की जांच देखी है, लेकिन मुझे नहीं लगता कि यह सी के बाहर दिखाई दे रहा है।

टोकन एसओ उत्तर: क्या आप सुनिश्चित हैं कि आपको इसके प्रकार की जांच होनी चाहिए? या तो एक ऐसे प्रकार को पारित नहीं करें जो आप को संभाल नहीं सकते, या अपने संभावित कोड रिउसर्स को चकमा देने की कोशिश न करें, उनके पास आपके फ़ंक्शन के लिए कोई अंतर नहीं निकालने का एक अच्छा कारण हो सकता है।

चीजों को उलझाना, बल्कि सिर्फ एक सरल क्यों नहीं

 if type(var) is int: 

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

 if x%1 == 0: 

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

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

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

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

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

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

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

मैं अपने सभी सॉफ्टवेयर में उपयोग करने वाला एक सरल तरीका यह है यह जांचता है कि क्या चर संख्याओं से बना है या नहीं।

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

यदि आप यह जांचना चाहते हैं कि एक स्ट्रिंग में केवल अंक होते हैं, लेकिन किसी इंट को परिवर्तित करने में मदद नहीं मिलेगी, तो आप हमेशा 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" 

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

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

 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 की तरह

एक संबंधित प्रश्न यहां पर स्वयं को मिला

पायथन डेवलपर्स प्रकारों को चेक नहीं करना पसंद करते हैं, लेकिन एक प्रकार के विशिष्ट ऑपरेशन करते हैं और एक TypeError अपवाद पकड़ते हैं। लेकिन अगर आपको इस प्रकार का पता नहीं है तो आपके पास निम्न है

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

क्यों न सिर्फ जांच करें कि क्या आप जितना मूल्य जांचना चाहते हैं, वह खुद के बराबर है, जैसा कि नीचे दिखाया गया है?

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

यदि चर एक स्ट्रिंग की तरह दर्ज किया जाता है (जैसे '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 फ़ंक्शन का उपयोग करें

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

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

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

यहां एक सरल उदाहरण है कि आप एक पूर्णांक कैसे निर्धारित कर सकते हैं

 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 

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

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

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

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

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

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

यह वही है जो __index__ लिए शुरू किया गया था!

यदि आप पायथन संस्करण (2.x बनाम 3.x) के संबंध में कोई भी जांच नहीं करना चाहते हैं, तो six ( पीईपीआई ) का उपयोग करें और यह integer_types विशेषता है:

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

six (एक बहुत ही हल्के वजन एकल-फ़ाइल मॉड्यूल) के भीतर, यह बस यह कर रहा है:

 import sys PY3 = sys.version_info[0] == 3 if PY3: integer_types = int, else: integer_types = (int, long) 
 #!/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) 

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

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

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

 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 

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

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

आप यह कर सकते हैं:

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

और यह 'यह काम करता है' वापस करेगा … लेकिन यदि आप नाम बदलते हैं (1) तो यह 'यह काम नहीं करेगा' वापस करेगा क्योंकि यह अब एक स्ट्रिंग है … आप भी कोशिश कर सकते हैं:

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

और यही बात होगी

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

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

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

तुम यह केर सकते हो।

 if type(x) is int: 

मामले पर विचार करें x = n ** (1.0 / मी), जहां 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') 

यह सभी के लिए सही और बी के लिए उत्पादन करता है।

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

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

 def is_int(x): if x - round(x) == 0 : return True else: return False 
 if type(input('enter = '))==int: print 'Entered number is an Integer' else: print 'Entered number isn't an Integer' 

यह यह जांचने के लिए काम करेगा कि संख्या एक पूर्णांक है या नहीं

 import numpy as np if (np.floor(x)-x == 0): return "this is an int"