पायथन में, मैं अपने संबंधित फ्लोट मान, 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

एक स्ट्रिंग एक फ्लोट है या नहीं, यह जांचने के लिए पायथन विधि:

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)