यह 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

मुझे आश्चर्य है कि किसी ने रेगेक्स का उल्लेख नहीं किया क्योंकि कभी-कभी स्ट्रिंग को संख्या में कास्टिंग करने से पहले तैयार और सामान्यीकृत किया जाना चाहिए

import re
def parseNumber(value, as_int=False):
    try:
        number = float(re.sub('[^.\-\d]', '', value))
        if as_int:
            return int(number + 0.5)
        else:
            return number
    except ValueError:
        return float('nan')  # or None if you wish

उपयोग:

parseNumber('13,345')
> 13345.0

parseNumber('- 123 000')
> -123000.0

parseNumber('99999\n')
> 99999.0

और वैसे, कुछ सत्यापित करने के लिए आपके पास एक संख्या है:

import numbers
def is_number(value):
    return isinstance(value, numbers.Number)
    # will work with int, float, long, Decimal

यह एक और तरीका है जिसका उल्लेख यहां किया जाना चाहिए, ast.literal_eval :

इसका उपयोग अविश्वसनीय स्रोतों से पाइथन अभिव्यक्ति वाले तारों को सुरक्षित रूप से मूल्यांकन करने के लिए किया जा सकता है, बिना मूल्यों को पार्स करने की आवश्यकता के।

यही है, एक सुरक्षित 'eval'

>>> import ast
>>> ast.literal_eval("545.2222")
545.2222
>>> ast.literal_eval("31")
31

def num(s):
"""num(s)
num(3),num(3.7)-->3
num('3')-->3, num('3.7')-->3.7
num('3,700')-->ValueError
num('3a'),num('a3'),-->ValueError
num('3e4') --> 30000.0
"""
try:
    return int(s)
except ValueError:
    try:
        return float(s)
    except ValueError:
        raise ValueError('argument is not a string of number')

सवाल थोड़ा सा लगता है। लेकिन मुझे एक फ़ंक्शन, 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'

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

इसे ठीक से करने के लिए आपको राउंडिंग को ध्यान में रखना होगा।

आईई 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)

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

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

आपको लगता है कि आप जानते हैं कि संख्याएं क्या हैं? आप सोचते हैं कि आप इतने अच्छे नहीं हैं! बड़ा आश्चर्य नहीं है।

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

मैं इसके लिए इस समारोह का उपयोग करता हूं

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

YAML पार्सर आपको यह पता लगाने में मदद कर सकता है कि आपकी स्ट्रिंग क्या डेटाटाइप है। yaml.load() उपयोग करें, और फिर आप type(result) लिए परीक्षण करने के लिए type(result) का उपयोग कर सकते हैं:

>>> import yaml

>>> a = "545.2222"
>>> result = yaml.load(a)
>>> result
545.22220000000004
>>> type(result)
<type 'float'>

>>> b = "31"
>>> result = yaml.load(b)
>>> result
31
>>> type(result)
<type 'int'>

>>> c = "HI"
>>> result = yaml.load(c)
>>> result
'HI'
>>> type(result)
<type 'str'>

>>> a = "545.2222"
>>> float(a)
545.22220000000004
>>> int(float(a))
545

float(x) if '.' in x else int(x)

उपयोगकर्ता कोडेलोगिक और हार्ले सही हैं, लेकिन अगर आपको पता है कि स्ट्रिंग एक पूर्णांक है (उदाहरण के लिए, 545) तो आप पहली बार फ्लोट करने के बिना int ("545") कॉल कर सकते हैं।

यदि आपके तार एक सूची में हैं, तो आप मानचित्र फ़ंक्शन का भी उपयोग कर सकते हैं।

>>> x = ["545.0", "545.6", "999.2"]
>>> map(float, x)
[545.0, 545.60000000000002, 999.20000000000005]
>>>

यह केवल तभी अच्छा है जब वे सभी एक ही प्रकार के होते हैं।

उपयोग:

def num(s):
    try:
        for each in s:
            yield int(each)
    except ValueError:
        yield float(each)
a = num(["123.55","345","44"])
print a.next()
print a.next()

यह सबसे प्यारा तरीका है जिसके साथ मैं आ सकता हूं।

पाइथन में एक लाइनर में पार्सिंग की यह बड़ी लचीलापन है।

str = "545.2222"
print ("int: ", + int(float(a)))
print ("float: ", +(float(a)))

यहां आपके प्रश्न की एक और व्याख्या है (संकेत: यह अस्पष्ट है)। यह संभव है कि आप इस तरह कुछ ढूंढ रहे हों:

def parseIntOrFloat( aString ):
    return eval( aString )

यह इस तरह काम करता है...

>>> parseIntOrFloat("545.2222")
545.22220000000004
>>> parseIntOrFloat("545")
545

सैद्धांतिक रूप से, एक इंजेक्शन भेद्यता है। स्ट्रिंग, उदाहरण के लिए "import os; os.abort()" । स्ट्रिंग कहां से आती है, इस पर किसी भी पृष्ठभूमि के बिना, संभावना सैद्धांतिक अटकलें है। चूंकि सवाल अस्पष्ट है, इसलिए यह स्पष्ट नहीं है कि यह भेद्यता वास्तव में मौजूद है या नहीं।

स्थानीयकरण और अल्पविराम

float("545,545.2222") जैसे मामलों के लिए आपको एक संख्या के स्ट्रिंग प्रस्तुति में अल्पविराम की संभावना पर विचार करना चाहिए जो अपवाद फेंकता है। इसके बजाय, तारों को संख्याओं में परिवर्तित करने और अल्पविरामों को सही ढंग से समझने के लिए locale में विधियों का उपयोग करें। locale.atof विधि वांछित संख्या सम्मेलन के लिए लोकेल सेट किए जाने के बाद एक चरण में एक फ्लोट में परिवर्तित हो जाता है।

उदाहरण 1 - संयुक्त राज्य संख्या संख्या सम्मेलन

संयुक्त राज्य अमेरिका और ब्रिटेन में, अल्पविरामों को हजारों विभाजक के रूप में उपयोग किया जा सकता है। इस उदाहरण में अमेरिकी लोकेल के साथ, अल्पविराम को विभाजक के रूप में ठीक से संभाला जाता है:

>>> import locale
>>> a = u'545,545.2222'
>>> locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
'en_US.UTF-8'
>>> locale.atof(a)
545545.2222
>>> int(locale.atof(a))
545545
>>>

उदाहरण 2 - यूरोपीय संख्या सम्मेलन

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

>>> import locale
>>> b = u'545,2222'
>>> locale.setlocale(locale.LC_ALL, 'fr_FR')
'fr_FR'
>>> locale.atof(b)
545.2222

विधि locale.atoi भी उपलब्ध है, लेकिन तर्क एक पूर्णांक होना चाहिए।