python - मैं पायथन में एक फ्लोट या int में स्ट्रिंग को कैसे पार्स करूं?
parsing floating-point (15)
पायथन में, मैं अपने संबंधित फ्लोट मान, 542.2222 पर "545.2222" जैसे संख्यात्मक स्ट्रिंग को कैसे पार्स कर सकता हूं? या एक पूर्णांक के लिए स्ट्रिंग "31" पार्स, 31? मैं बस एक फ्लोट स्ट्रिंग को एक फ्लोट पर कैसे पार्स करना चाहता हूं, और (अलग से) एक int स्ट्रिंग को int में कैसे करना है।
यह अच्छा है कि आप इन्हें अलग से करने के लिए कहते हैं। यदि आप उन्हें मिला रहे हैं, तो आप बाद में समस्याओं के लिए स्वयं को स्थापित कर सकते हैं। सरल जवाब है:
फ्लोट करने के लिए "545.2222"
>>> float("545.2222")
545.2222
एक पूर्णांक के लिए "31"
:
>>> int("31")
31
अन्य रूपांतरण, स्ट्रिंग्स और शाब्दिक से और इंक:
विभिन्न अड्डों से रूपांतरण, और आपको पहले से आधार पता होना चाहिए (10 डिफ़ॉल्ट है)। ध्यान दें कि आप उन्हें पाइथन को अपने अक्षर के लिए क्या उम्मीद करते हैं (नीचे देखें) के साथ उपसर्ग कर सकते हैं या उपसर्ग को हटा सकते हैं:
>>> int("0b11111", 2)
31
>>> int("11111", 2)
31
>>> int('0o37', 8)
31
>>> int('37', 8)
31
>>> int('0x1f', 16)
31
>>> int('1f', 16)
31
यदि आप पहले से आधार नहीं जानते हैं, लेकिन आपको पता है कि उनके पास सही उपसर्ग होगा, तो यदि आप आधार के रूप में 0
पास करते हैं तो पाइथन आपके लिए यह अनुमान लगा सकता है:
>>> int("0b11111", 0)
31
>>> int('0o37', 0)
31
>>> int('0x1f', 0)
31
अन्य आधारों से गैर-दशमलव (यानी पूर्णांक) साहित्य
यदि आपकी प्रेरणा आपके कोड को स्पष्ट रूप से हार्ड-कोडित विशिष्ट मानों का प्रतिनिधित्व करती है, तो आपको बेस से कन्वर्ट करने की आवश्यकता नहीं हो सकती है - आप पाइथन को स्वचालित वाक्यविन्यास के साथ स्वचालित रूप से आपके लिए ऐसा करने दे सकते हैं।
आप निम्न अक्षरों के साथ पूर्णांक में स्वत: रूपांतरण प्राप्त करने के लिए apropos उपसर्ग का उपयोग कर सकते हैं। ये पाइथन 2 और 3 के लिए मान्य हैं:
बाइनरी, उपसर्ग 0 0b
>>> 0b11111
31
ऑक्टल, उपसर्ग 0o
>>> 0o37
31
हेक्साडेसिमल, उपसर्ग 0x
>>> 0x1f
31
बाइनरी झंडे, कोड में फ़ाइल अनुमतियां, या रंगों के लिए हेक्स मानों का वर्णन करते समय यह उपयोगी हो सकता है - उदाहरण के लिए, कोई उद्धरण नोट करें:
>>> 0b10101 # binary flags
21
>>> 0o755 # read, write, execute perms for owner, read & ex for group & others
493
>>> 0xffffff # the color, white, max values for red, green, and blue
16777215
पाइथन 3 के साथ संगत अस्पष्ट पायथन 2 ऑक्टल बनाना
यदि आप एक पूर्णांक देखते हैं जो 0 से शुरू होता है, पाइथन 2 में, यह (बहिष्कृत) ऑक्टल वाक्यविन्यास है।
>>> 037
31
यह बुरा है क्योंकि ऐसा लगता है कि मान 37
होना चाहिए। तो पायथन 3 में, अब यह एक SyntaxError
उठाता है:
>>> 037
File "<stdin>", line 1
037
^
SyntaxError: invalid token
अपने पायथन 2 ऑक्टल को ऑक्टल में कनवर्ट करें जो 0o उपसर्ग के साथ 2 और 3 दोनों में काम करते हैं:
>>> 0o37
31
पायथन में, मैं अपने संबंधित फ्लोट मान, 542.2222
"545.2222"
जैसे संख्यात्मक स्ट्रिंग को कैसे पार्स कर सकता हूं? या एक पूर्णांक के लिए स्ट्रिंग "31"
पार्स, 31
?
मैं बस एक फ्लोट string
को एक float
कैसे पार्स करना चाहता हूं, और (अलग से) एक int string
को int
।
एक स्ट्रिंग एक फ्लोट है या नहीं, यह जांचने के लिए पायथन विधि:
def isfloat(value):
try:
float(value)
return True
except:
return False
इस फ़ंक्शन के लिए एक लंबा और अधिक सटीक नाम हो सकता है: isConvertibleToFloat(value)
क्या है, और Python में एक फ्लोट नहीं है आपको आश्चर्यचकित कर सकता है:
val isfloat(val) Note
-------------------- ---------- --------------------------------
"" False Blank string
"127" True Passed string
True True Pure sweet Truth
"True" False Vile contemptible lie
False True So false it becomes true
"123.456" True Decimal
" -127 " True Spaces trimmed
"\t\n12\r\n" True whitespace ignored
"NaN" True Not a number
"NaNanananaBATMAN" False I am Batman
"-iNF" True Negative infinity
"123.E4" True Exponential notation
".1" True mantissa only
"1,234" False Commas gtfo
u'\x30' True Unicode is fine.
"NULL" False Null is not special
0x3fade True Hexidecimal
"6e7777777777777" True Shrunk to infinity
"1.797693e+308" True This is max value
"infinity" True Same as inf
"infinityandBEYOND" False Extra characters wreck it
"12.34.56" False Only one dot allowed
u'四' False Japanese '4' is not a float.
"#56" False Pound sign
"56%" False Percent of what?
"0E0" True Exponential, move dot 0 places
0**0 True 0___0 Exponentiation
"-5e-5" True Raise to a negative number
"+1e1" True Plus is OK with exponent
"+1e1^5" False Fancy exponent not interpreted
"+1e1.3" False No decimals in exponent
"-+1" False Make up your mind
"(1)" False Parenthesis is bad
आपको लगता है कि आप जानते हैं कि संख्याएं क्या हैं? आप सोचते हैं कि आप इतने अच्छे नहीं हैं! बड़ा आश्चर्य नहीं है।
इसे ठीक से करने के लिए आपको राउंडिंग को ध्यान में रखना होगा।
आईई int (5.1) => 5 int (5.6) => 5 - गलत, 6 होना चाहिए इसलिए हम int करते हैं (5.6 + 0.5) => 6
def convert(n):
try:
return int(n)
except ValueError:
return float(n + 0.5)
उपयोग:
>>> str_float = "545.2222"
>>> float(str_float)
545.2222
>>> type(_) # Check its type
<type 'float'>
>>> str_int = "31"
>>> int(str_int)
31
>>> type(_) # Check its type
<type 'int'>
उपयोगकर्ता कोडेलोगिक और हार्ले सही हैं, लेकिन अगर आपको पता है कि स्ट्रिंग एक पूर्णांक है (उदाहरण के लिए, 545) तो आप पहली बार फ्लोट करने के बिना int ("545") कॉल कर सकते हैं।
यदि आपके तार एक सूची में हैं, तो आप मानचित्र फ़ंक्शन का भी उपयोग कर सकते हैं।
>>> x = ["545.0", "545.6", "999.2"]
>>> map(float, x)
[545.0, 545.60000000000002, 999.20000000000005]
>>>
यह केवल तभी अच्छा है जब वे सभी एक ही प्रकार के होते हैं।
पाइथन में एक लाइनर में पार्सिंग की यह बड़ी लचीलापन है।
str = "545.2222"
print ("int: ", + int(float(a)))
print ("float: ", +(float(a)))
मैं इसके लिए इस समारोह का उपयोग करता हूं
import ast
def parse_str(s):
try:
return ast.literal_eval(str(s))
except:
return
यह स्ट्रिंग को इसके प्रकार में बदल देगा
value = parse_str('1') # Returns Integer
value = parse_str('1.5') # Returns Float
यदि आप तृतीय-पक्ष मॉड्यूल के विपरीत नहीं हैं, तो आप fastnumbers मॉड्यूल देख सकते हैं। यह fast_real नामक एक फ़ंक्शन प्रदान करता है जो वास्तव में यह प्रश्न पूछता है और शुद्ध-पायथन कार्यान्वयन से तेज़ करता है:
>>> from fastnumbers import fast_real
>>> fast_real("545.2222")
545.2222
>>> type(fast_real("545.2222"))
float
>>> fast_real("31")
31
>>> type(fast_real("31"))
int
यहां आपके प्रश्न की एक और व्याख्या है (संकेत: यह अस्पष्ट है)। यह संभव है कि आप इस तरह कुछ ढूंढ रहे हों:
def parseIntOrFloat( aString ):
return eval( aString )
यह इस तरह काम करता है...
>>> parseIntOrFloat("545.2222")
545.22220000000004
>>> parseIntOrFloat("545")
545
सैद्धांतिक रूप से, एक इंजेक्शन भेद्यता है। स्ट्रिंग, उदाहरण के लिए "import os; os.abort()"
। स्ट्रिंग कहां से आती है, इस पर किसी भी पृष्ठभूमि के बिना, संभावना सैद्धांतिक अटकलें है। चूंकि सवाल अस्पष्ट है, इसलिए यह स्पष्ट नहीं है कि यह भेद्यता वास्तव में मौजूद है या नहीं।
सवाल थोड़ा सा लगता है। लेकिन मुझे एक फ़ंक्शन, parseStr का सुझाव दें, जो कुछ समान बनाता है, यानी, पूर्णांक या फ्लोट देता है और यदि किसी दिए गए ASCII स्ट्रिंग को उनमें से किसी भी रूप में परिवर्तित नहीं किया जा सकता है तो यह इसे छूटा नहीं जाता है। पाठ्यक्रम का कोड केवल वही करने के लिए समायोजित किया जा सकता है जो आप चाहते हैं:
>>> import string
>>> parseStr = lambda x: x.isalpha() and x or x.isdigit() and \
... int(x) or x.isalnum() and x or \
... len(set(string.punctuation).intersection(x)) == 1 and \
... x.count('.') == 1 and float(x) or x
>>> parseStr('123')
123
>>> parseStr('123.3')
123.3
>>> parseStr('3HC1')
'3HC1'
>>> parseStr('12.e5')
1200000.0
>>> parseStr('12$5')
'12$5'
>>> parseStr('12.2.2')
'12.2.2'
float("545.2222")
और int(float("545.2222"))
यह https://.com/a/33017514/5973334 का एक सही संस्करण है
यह एक स्ट्रिंग को पार्स करने की कोशिश करेगा और स्ट्रिंग का प्रतिनिधित्व करने के आधार पर या तो int
या float
लौटाएगा। यह पार्सिंग अपवादों को बढ़ा सकता है या कुछ अप्रत्याशित व्यवहार हो सकता है ।
def get_int_or_float(v):
number_as_float = float(v)
number_as_int = int(number_as_float)
return number_as_int if number_as_float == number_as_int else
number_as_float
def get_int_or_float(v):
number_as_float = float(v)
number_as_int = int(number_as_float)
return number_as_int if number_as_float == number_as_int else number_as_float
def num(s):
try:
return int(s)
except ValueError:
return float(s)
float(x) if '.' in x else int(x)