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

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)