පයිතන්හිදී, සංඛ්‍යාත්මක නූලක් "545.2222"එහි අනුරූප පාවෙන අගයට සමාන 545.2222කරන්නේ කෙසේද? හෝ වැල විග්රහ කළ "31", පූර්ණ සංඛ්යාවක් කිරීමට 31?

මම යන්තම් විග්රහ කළ යුතු ආකාරය දැන ගැනීමට අවශ්ය පාවෙන str වෙත float, සහ (, ෙවන් ෙවන් වශෙයන්) යනු int str ෙවත int.

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

def num(s):
    try:
        return int(s)
    except ValueError:
        return float(s)

නූලක් පාවෙන දැයි පරීක්ෂා කිරීමට පයිතන් ක්‍රමය:

def is_float(value):
  try:
    float(value)
    return True
  except:
    return False

මෙම ශ්‍රිතය සඳහා දිගු හා වඩා නිවැරදි නමක් විය හැකිය: is_convertible_to_float(value)

කුමක්ද, හා තුළ පාවෙන නොවේ Python ඔබ පුදුම විය හැක:

val                   is_float(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         Hexadecimal
"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

අංක මොනවාදැයි ඔබ දන්නවා යැයි ඔබ සිතනවාද? ඔබ සිතන තරම් ඔබ හොඳ නැත! ලොකු පුදුමයක් නොවේ.

ජීවිත විවේචනාත්මක මෘදුකාංග වල මෙම කේතය භාවිතා නොකරන්න!

මේ ආකාරයෙන් පුළුල් ව්‍යතිරේකයන් හසුකර ගැනීම, කැනරි killing ාතනය කිරීම සහ ව්‍යතිරේකය අවුල් කිරීම, වලංගු ලෙස පාවෙන නූලක් ව්‍යාජ ලෙස නැවත පැමිණීමට ඉතා කුඩා අවස්ථාවක් නිර්මාණය කරයි. මෙම float(...)කේතය රේඛාවක් වැල අන්තර්ගතය කිසිදු සම්බන්ධයක් නැති බව දහසක් හේතු ඕනෑම නිසා අසාර්ථක විය හැක. නමුත් ඔබ පයිතන් වැනි තාරාවන්ගේ යතුරු ලියනය කරන මූලාකෘති භාෂාවෙන් ජීවිත විවේචනාත්මක මෘදුකාංගයක් ලියන්නේ නම්, එවිට ඔබට වඩා විශාල ගැටලු තිබේ.

මෙය මෙහි සඳහන් කළ යුතු තවත් ක්‍රමයක් වන ast.literal_eval :

විශ්වාසනීය නොවන ප්‍රභවයන්ගෙන් පයිතන් ප්‍රකාශන අඩංගු නූල් ආරක්ෂිතව තක්සේරු කිරීම සඳහා මෙය භාවිතා කළ හැකිය.

එනම්, ආරක්ෂිත 'එවාල්'

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

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

ප්‍රාදේශීයකරණය සහ කොමාව

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ද ඇත, නමුත් තර්කය පූර්ණ සංඛ්‍යාවක් විය යුතුය.

ඔබ තෙවන පාර්ශවීය මොඩියුල වලට අකමැති නම්, ඔබට වේගවත් සංඛ්‍යා මොඩියුලය පරීක්ෂා කළ හැකිය . එය 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

පරිශීලකයින් කෝඩෙලොජික් සහ හාර්ලි නිවැරදියි, නමුත් නූල පූර්ණ සංඛ්‍යාවක් බව ඔබ දන්නේ නම් මතක තබා ගන්න (නිදසුනක් ලෙස 545) ඔබට පාවීමට පළමුවෙන්ම වාත්තු නොකර int ("545") අමතන්න.

ඔබේ නූල් ලැයිස්තුවක තිබේ නම්, ඔබට සිතියම් ක්‍රියාකාරිත්වය ද භාවිතා කළ හැකිය.

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

එය හොඳ වන්නේ ඒවා සියල්ලම එකම වර්ගයේ නම් පමණි.

පයිතන්හිදී, "545.2222" වැනි සංඛ්‍යාත්මක නූලක් එහි අනුරූප පාවෙන අගය වන 542.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

දශම නොවන (එනම් පූර්ණ සංඛ්‍යා) වෙනත් පදනම් වලින් සාහිත්‍යය

ඔබේ අභිප්‍රේරණය ඔබේම කේතයක් දෘඩ කේත සහිත නිශ්චිත අගයන් පැහැදිලිව නිරූපණය කිරීමට නම්, කෙසේ වෙතත්, ඔබට පදනම් වලින් පරිවර්තනය වීමට අවශ්‍ය නොවනු ඇත - නිවැරදි වාක්‍ය ඛණ්ඩය සමඟ ඔබට ස්වයංක්‍රීයව එය කිරීමට පයිතන්ට ඉඩ දිය හැකිය.

පහත දැක්වෙන වචනාර්ථයන් සමඟ පූර්ණ සංඛ්‍යා වලට ස්වයංක්‍රීයව පරිවර්තනය ලබා ගැනීම සඳහා ඔබට ඇප්‍රොපොස් උපසර්ග භාවිතා කළ හැකිය . මේවා පයිතන් 2 සහ 3 සඳහා වලංගු වේ:

ද්විමය, උපසර්ගය 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 අෂ්ටක සෑදීම

පයිතන් 2 හි 0 කින් ආරම්භ වන පූර්ණ සංඛ්‍යාවක් ඔබ දුටුවහොත් මෙය (අතහැර දැමූ) අෂ්ටක වාක්‍ය ඛණ්ඩයකි.

>>> 037
31

වටිනාකම නරක විය යුතු බව පෙනෙන නිසා එය නරක ය 37. එබැවින් පයිතන් 3 හි එය දැන් මතු කරයි SyntaxError:

>>> 037
  File "<stdin>", line 1
    037
      ^
SyntaxError: invalid token

ඔබේ පයිතන් 2 අෂ්ටක 0oඋපසර්ගය සමඟ 2 සහ 3 යන දෙවර්ගයේම වැඩ කරන අෂ්ටක බවට පරිවර්තනය කරන්න :

>>> 0o37
31

ප්‍රශ්නය ටිකක් පැරණි බව පෙනේ. නමුත් parseStr නම් ශ්‍රිතයක් යෝජනා කිරීමට මට ඉඩ දෙන්න, එය සමාන දෙයක් කරයි, එනම් පූර්ණ සංඛ්‍යාවක් හෝ පාවීමක් ලබා දෙයි. දී ඇති ASCII නූලක් ඒ කිසිවකට පරිවර්තනය කළ නොහැකි නම් එය ස්පර්ශ නොකර ආපසු ලබා දේ. පා course මාලා කේතය ඔබට අවශ්‍ය දේ පමණක් කිරීමට ගැලපේ:

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

මෙම YAML ව්යාකරණ විග්රහ ඔබ ඔබේ සංකේත datatype කුමක් දැයි උදව් විය හැක. භාවිතා කරන්න yaml.load(), ඉන්පසු ඔබට 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'>

මම ඒ සඳහා මෙම ශ්‍රිතය භාවිතා කරමි

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

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

මෙය නිසියාකාරව සිදු කිරීම සඳහා ඔබ වටකුරු කිරීම සැලකිල්ලට ගත යුතුය.

එනම් 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)

අංකයට වාත්තු කිරීමට පෙර සමහර විට නූල් සකස් කර සාමාන්‍යකරණය කළ යුතු බැවින් කිසිවෙකු රීජෙක්ස් ගැන සඳහන් නොකිරීම මට පුදුමයකි

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

පයිතන් යතුරු ලියනය කිරීම සඳහා පරාමිතියක් ලෙස නූල් (හෝ ඔබ වාත්තු කිරීමට උත්සාහ කරන ඕනෑම අගයක්) පසුකරමින්, වර්ගයෙහි ඉදිකිරීම්කරුවන්ගේ ක්‍රියාකාරකම් භාවිතා කරන්න.

උදාහරණයක් වශයෙන්:

>>>float("23.333")
   23.333

තිරයට පිටුපසින්, පයිතන් වස්තු __float__ක්‍රමය අමතයි, එමඟින් පරාමිතියේ පාවෙන නිරූපණයක් ලබා දිය යුතුය. මෙය විශේෂයෙන් බලවත් ය, මන්ද ඔබට ඔබේම වර්ග (පන්ති භාවිතා කරමින්) __float__ක්‍රමයක් සමඟ අර්ථ දැක්විය හැකි වන අතර එමඟින් එය පාවෙන (මයෝබෙක්ට්) භාවිතයෙන් පාවීමට දැමිය හැකිය.

මෙය නිවැරදි අනුවාදය වේ පිළිබඳ https://stackoverflow.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 string_to_number(str):
  if("." in str):
    try:
      res = float(str)
    except:
      res = str  
  elif(str.isdigit()):
    res = int(str)
  else:
    res = str
  return(res)

සම්මත වූ දේ අනුව එය int, float හෝ string නැවත ලබා දෙනු ඇත.

int යනු int එකකි

print(type(string_to_number("124")))
<class 'int'>

පාවෙන නූලක්

print(type(string_to_number("12.4")))
<class 'float'>

නූලක් වන නූලක්

print(type(string_to_number("hello")))
<class 'str'>

පාවෙන පෙනුමක් ඇති නූල්

print(type(string_to_number("hel.lo")))
<class 'str'>

භාවිත:

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

මට ඉදිරිපත් කළ හැකි වඩාත්ම පයිතොනික් ක්‍රමය මෙයයි.

හෙක්ස්, අෂ්ටක, ද්විමය, දශම සහ පාවෙන හසුරුවයි

මෙම විසඳුම අංක සඳහා වන සියලුම සංගීත සම්මුතීන් හසුරුවනු ඇත (මා දන්නා සියල්ල).

def to_number(n):
    ''' Convert any number representation to a number 
    This covers: float, decimal, hex, and octal numbers.
    '''

    try:
        return int(str(n), 0)
    except:
        try:
            # python 3 doesn't accept "010" as a valid octal.  You must use the
            # '0o' prefix
            return int('0o' + n, 0)
        except:
            return float(n)

මෙම පරීක්ෂණ සිද්ධි ප්‍රතිදානය මා කතා කරන්නේ කුමක් ද යන්න පැහැදිලි කරයි.

======================== CAPTURED OUTPUT =========================
to_number(3735928559)   = 3735928559 == 3735928559
to_number("0xFEEDFACE") = 4277009102 == 4277009102
to_number("0x0")        =          0 ==          0
to_number(100)          =        100 ==        100
to_number("42")         =         42 ==         42
to_number(8)            =          8 ==          8
to_number("0o20")       =         16 ==         16
to_number("020")        =         16 ==         16
to_number(3.14)         =       3.14 ==       3.14
to_number("2.72")       =       2.72 ==       2.72
to_number("1e3")        =     1000.0 ==       1000
to_number(0.001)        =      0.001 ==      0.001
to_number("0xA")        =         10 ==         10
to_number("012")        =         10 ==         10
to_number("0o12")       =         10 ==         10
to_number("0b01010")    =         10 ==         10
to_number("10")         =         10 ==         10
to_number("10.0")       =       10.0 ==         10
to_number("1e1")        =       10.0 ==         10

පරීක්ෂණය මෙන්න:

class test_to_number(unittest.TestCase):

    def test_hex(self):
        # All of the following should be converted to an integer
        #
        values = [

                 #          HEX
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (0xDEADBEEF  , 3735928559), # Hex
                ("0xFEEDFACE", 4277009102), # Hex
                ("0x0"       ,          0), # Hex

                 #        Decimals
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (100         ,        100), # Decimal
                ("42"        ,         42), # Decimal
            ]



        values += [
                 #        Octals
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (0o10        ,          8), # Octal
                ("0o20"      ,         16), # Octal
                ("020"       ,         16), # Octal
            ]


        values += [
                 #        Floats
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                (3.14        ,       3.14), # Float
                ("2.72"      ,       2.72), # Float
                ("1e3"       ,       1000), # Float
                (1e-3        ,      0.001), # Float
            ]

        values += [
                 #        All ints
                 # ----------------------
                 # Input     |   Expected
                 # ----------------------
                ("0xA"       ,         10), 
                ("012"       ,         10), 
                ("0o12"      ,         10), 
                ("0b01010"   ,         10), 
                ("10"        ,         10), 
                ("10.0"      ,         10), 
                ("1e1"       ,         10), 
            ]

        for _input, expected in values:
            value = to_number(_input)

            if isinstance(_input, str):
                cmd = 'to_number("{}")'.format(_input)
            else:
                cmd = 'to_number({})'.format(_input)

            print("{:23} = {:10} == {:10}".format(cmd, value, expected))
            self.assertEqual(value, expected)

භාවිත:

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

මෙම කිසිදු පරිවර්තනය වනු ඇත ශ්රිතයක් වේ object(පමණක් නොව strදක්වා) intහෝ floatසැබෑ string සපයා නම් මත පදනම් වගේ int හෝ float. තව දුරටත් එය ක්‍රම __floatසහ __int__ක්‍රම දෙකම ඇති වස්තුවක් නම් , එය භාවිතයට පෙරනිමිය__float__

def conv_to_num(x, num_type='asis'):
    '''Converts an object to a number if possible.
    num_type: int, float, 'asis'
    Defaults to floating point in case of ambiguity.
    '''
    import numbers

    is_num, is_str, is_other = [False]*3

    if isinstance(x, numbers.Number):
        is_num = True
    elif isinstance(x, str):
        is_str = True

    is_other = not any([is_num, is_str])

    if is_num:
        res = x
    elif is_str:
        is_float, is_int, is_char = [False]*3
        try:
            res = float(x)
            if '.' in x:
                is_float = True
            else:
                is_int = True
        except ValueError:
            res = x
            is_char = True

    else:
        if num_type == 'asis':
            funcs = [int, float]
        else:
            funcs = [num_type]

        for func in funcs:
            try:
                res = func(x)
                break
            except TypeError:
                continue
        else:
            res = x

Int සහ float ක්‍රම භාවිතා කිරීමෙන් අපට නූලක් පූර්ණ සංඛ්‍යාවක් හා පාවෙන බවට පරිවර්තනය කළ හැකිය.

s="45.8"
print(float(s))

y='67'
print(int(y))

eval()මෙම ප්‍රශ්නයට ඉතා හොඳ විසඳුමකි. අංකය int හෝ float ද යන්න පරීක්ෂා කිරීම අවශ්‍ය නොවේ, එය අනුරූප සමාන අගයක් ලබා දෙයි. වෙනත් ක්‍රම අවශ්‍ය නම් උත්සාහ කරන්න

if '.' in string:
    print(float(string))
else:
    print(int(string))

උත්සාහ කිරීම හැර විකල්පයක් ලෙසද භාවිතා කළ හැකිය. උත්සාහක කොටස තුළ නූල් int බවට පරිවර්තනය කිරීමට උත්සාහ කරන්න. නූල පාවෙන අගයක් නම්, එය දෝෂයක් හැර වෙනත් බ්ලොක් එකක හසු වේ

try:
    print(int(string))
except:
    print(float(string))

මෙන්න ඔබේ ප්‍රශ්නයේ තවත් අර්ථකථනයක් (ඉඟිය: එය නොපැහැදිලි). ඔබ මේ වගේ දෙයක් සොයන්නට පුළුවන:

def parseIntOrFloat( aString ):
    return eval( aString )

එය මේ ආකාරයට ක්‍රියා කරයි ...

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

න්‍යායාත්මකව, එන්නත් කිරීමේ අවදානමක් ඇත. නූල උදාහරණයක් විය හැකිය "import os; os.abort()". කෙසේ වෙතත්, නූල් පැමිණෙන්නේ කොතැනින්ද යන්න පිළිබඳ පසුබිමක් නොමැතිව, කෙසේ වෙතත්, හැකියාව න්‍යායාත්මක සමපේක්ෂනයකි. ප්‍රශ්නය අපැහැදිලි බැවින් මෙම අවදානම ඇත්ත වශයෙන්ම තිබේද නැද්ද යන්න කිසිසේත් පැහැදිලි නැත.