पायथन में, मैं "545.2222"अपने संबंधित फ्लोट मान की तरह एक संख्यात्मक स्ट्रिंग को पार्स कैसे कर सकता हूं 545.2222? या स्ट्रिंग "31"को पूर्णांक में पार्स करें 31,?
मैं बस जानना चाहता हूं कि फ्लोट को पार्स कैसे किया जाए , और (अलग से) एक इंट टू strए ।float strint
int(x) if int(x) == float(x) else float(x)
जवाबों:
>>> a = "545.2222"
>>> float(a)
545.22220000000004
>>> int(float(a))
545int(a)लेकिन int(float(a))?
int(a)एक त्रुटि देगा कि स्ट्रिंग एक वैध पूर्णांक नहीं है: ValueError: invalid literal for int() with base 10: '545.222'लेकिन एक फ्लोट से एक इंट में परिवर्तित करना एक समर्थित रूपांतरण है।
ValueErrorयदि आप सुरक्षित रहना चाहते हैं तो आपको संभालना चाहिए
def num(s):
try:
return int(s)
except ValueError:
return float(s)/पर ऑपरेटर के लिए अलग-अलग परिणामों के साथ या फ्लोट्स के साथ काम करने पर सटीक मिश्रण के संभावित नुकसान के कारण निहित मिक्सिंग फ़्लोट्स / इन्ट्स सूक्ष्म बग हो सकते हैं । संदर्भ के आधार पर या तो इंट या फ्लोट पर लौटना बेहतर हो सकता है, दोनों पर नहीं।
tryतैरने के लिए परिवर्तनीय नहीं होते हैं तो आप एक अपवाद को फेंक सकते हैं ।
s = u'\u0000'
ValueErrorइसी में फेंकने की सलाह देता हूं except: पी
def is_float(value):
try:
float(value)
return True
except:
return Falseइस फ़ंक्शन का एक लंबा और अधिक सटीक नाम हो सकता है: is_convertible_to_float(value)
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आपको लगता है कि आपको पता है कि नंबर क्या हैं? आप इतने अच्छे नहीं हैं जितना आप सोचते हैं! बड़ा आश्चर्य नहीं।
इस तरह से व्यापक अपवादों को पकड़ना, कैनरी को मारना और अपवाद को तोड़ना एक छोटा मौका बनाता है कि स्ट्रिंग के रूप में एक वैध फ्लोट झूठी वापस आ जाएगी। float(...)कोड की लाइन किसी भी एक हजार कारणों से विफल हो सकती है जिनका स्ट्रिंग की सामग्री से कोई लेना-देना नहीं है। लेकिन यदि आप पाइकॉन जैसी बतख-टाइप प्रोटोटाइप भाषा में जीवन-महत्वपूर्ण सॉफ़्टवेयर लिख रहे हैं, तो आपको बहुत बड़ी समस्याएं हैं।
UTF-8एक चीनी के लिए यह ग्लिफ़ 4वर्षों से बदल रहा है कि कैसे स्टैकओवरफ़्लो डेवलपर्स अपने माइक्रोसाफ्ट टूलस्टैक पर अपने चरित्र एन्कोडिंग योजना को बदलते हैं। यह नई परिवर्तन योजनाओं के रूप में अपनी नई विचारधाराओं का दावा करते हुए इसे वर्षों से फ्लिप फ्लॉप देखने की जिज्ञासा है। लेकिन हाँ, UTF-8पूर्वी प्राच्य संख्यात्मक के लिए कोई भी ग्लिफ़ पायथन फ्लोट नहीं है। Bazinga।
"- 12.3"और"45 e6"
TypeError, ValueError
यह एक और विधि है जिसका उल्लेख यहां किया जाना चाहिए, ast.literal_eval :
इसका उपयोग उन मूल्यों को पार्स करने की आवश्यकता के बिना अविश्वसनीय स्रोतों से पायथन अभिव्यक्तियों वाले तार के सुरक्षित मूल्यांकन के लिए किया जा सकता है।
वह है, एक सुरक्षित 'eval'
>>> import ast
>>> ast.literal_eval("545.2222")
545.2222
>>> ast.literal_eval("31")
31python >>> import ast >>> ast.literal_eval('1-800-555-1212') -2566 >>> यह स्पष्ट करने के लिए कि यह एक समस्या क्यों है, यदि आप चाहते हैं कि यह फोन नंबर को अकेला छोड़ दें और यह न मानें कि वे गणितीय अभिव्यक्ति हैं, तो यह दृष्टिकोण आपके लिए नहीं है।
float(x) if '.' in x else int(x)float("nan")एक पूरी तरह से वैध फ्लोट मूल्य है जो उपरोक्त उत्तर को बिल्कुल नहीं पकड़ेगा
192.168.0.1; या"This is not a good approach. :)"
आपको एक संख्या के स्ट्रिंग प्रतिनिधित्व में अल्पविराम की संभावना पर विचार करना चाहिए, ऐसे मामलों के लिए 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भी उपलब्ध है, लेकिन तर्क पूर्णांक होना चाहिए।
x = '1'; locale.atof(x)रिटर्न 1.0जब मैं वास्तव में चाहता हूं 1।
locale.atof(x) if locale.localeconv().get('decimal_point') in x else locale.atoi(x)
locale.atoilocale.atof
यदि आप तृतीय-पक्ष मॉड्यूल के विपरीत नहीं हैं, तो आप फास्टनरों मॉड्यूल की जांच कर सकते हैं । यह एक फ़ंक्शन प्रदान करता है जिसे 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 पर पार्स करें? मैं बस यह जानना चाहता हूं कि फ्लोट स्ट्रिंग को फ्लोट में पार्स कैसे करें, और (अलग से) एक इंट स्ट्रिंग को एक इंट में।
यह अच्छा है कि आप इन्हें अलग से करने को कहें। यदि आप उन्हें मिला रहे हैं, तो आप बाद में समस्याओं के लिए खुद को स्थापित कर सकते हैं। सरल उत्तर है:
"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यदि आप एक पूर्णांक देखते हैं जो कि पायथन 2 में 0 से शुरू होता है, तो यह (पदावनत) ऑक्टल सिंटैक्स है।
>>> 037
31यह बुरा है क्योंकि ऐसा लगता है कि मूल्य होना चाहिए 37। तो पायथन 3 में, यह अब एक उठाता है SyntaxError:
>>> 037
File "<stdin>", line 1
037
^
SyntaxError: invalid tokenअपने पाइथन 2 ऑक्टल्स को उन ऑक्टल्स में परिवर्तित करें जो 0oउपसर्ग के साथ 2 और 3 दोनों में काम करते हैं :
>>> 0o37
31सवाल थोड़ा पुराना लगता है। लेकिन मुझे एक फ़ंक्शन का सुझाव दें, 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'1e3अजगर में एक संख्या है, लेकिन आपके कोड के अनुसार एक स्ट्रिंग है।
मैं इस फ़ंक्शन का उपयोग करता हूं
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 Floatparse_str(' 1')(एक स्थान के साथ) वापस आ जाएगा None, नहीं 1।
YAML पार्सर आप यह पता लगाने की क्या डेटाप्रकार अपने स्ट्रिंग है कर सकते हैं। का उपयोग करें 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'>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_floatexceptअगर आप वहां कुछ नहीं कर रहे हैं तो आप अपने सेक्शन में क्यों वृद्धि करेंगे ? फ्लोट () आपके लिए उठाएंगे।
intया तो या 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')इसे ठीक से करने के लिए आपको राउंडिंग को ध्यान में रखना होगा।
Ie 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)intऔर float। और यह एक अपवाद देगा, जब nएक स्ट्रिंग है, जैसा कि ओपी वांछित है। शायद आपका मतलब था: जब कोई intपरिणाम वांछित होता है, तो roundफ्लोट करने के लिए AFTER रूपांतरण किया जाना चाहिए। यदि फ़ंक्शन को ALWAYS को वापस लौटना चाहिए, तो आपको अपवाद भाग की आवश्यकता नहीं है - संपूर्ण फ़ंक्शन बॉडी हो सकती है int(round(float(input)))। यदि फ़ंक्शन को संभव हो तो एक इंट वापस करना चाहिए, अन्यथा एक फ्लोट, तो जेवियर का मूल समाधान सही है!
मुझे आश्चर्य है कि किसी ने भी रेगेक्स का उल्लेख नहीं किया है क्योंकि कभी-कभी स्ट्रिंग को तैयार किया जाना चाहिए और नंबर डालने से पहले सामान्यीकृत किया जाना चाहिए
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)जो पास हुआ था, उसके आधार पर यह इंट, फ्लोट या स्ट्रिंग लौटाएगा।
स्ट्रिंग जो एक इंट है
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()यह सबसे पाइथोनिक तरीका है जिसके साथ मैं आ सकता था।
float। try... catchब्लॉक शायद अंदर होना चाहिए forपाश।
हेक्स, ऑक्टल, बाइनरी, दशमलव और फ्लोट को संभालता है
यह समाधान संख्याओं के लिए सभी स्ट्रिंग सम्मेलनों को संभाल लेगा (जो मुझे पता है)।
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) में परिवर्तित हो जाएगा । इसके अलावा अगर यह एक ऐसी वस्तु है जिसमें दोनों तरीके और विधियां हैं, तो यह उपयोग करने में चूक करता हैintfloat intfloat__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इंट और फ्लोट विधियों का उपयोग करके हम एक स्ट्रिंग को पूर्णांक और फ्लोट्स में बदल सकते हैं।
s="45.8"
print(float(s))
y='67'
print(int(y))eval()इस प्रश्न का बहुत अच्छा समाधान है। यह जाँचने की आवश्यकता नहीं है कि क्या संख्या अंतर है या फ्लोट है, यह सिर्फ इसी समतुल्य देता है। यदि अन्य तरीकों की आवश्यकता है, तो प्रयास करें
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()"। बिना किसी पृष्ठभूमि के जहां से स्ट्रिंग आती है, हालांकि, संभावना सैद्धांतिक अटकलें हैं। चूंकि प्रश्न अस्पष्ट है, इसलिए यह बिल्कुल स्पष्ट नहीं है कि यह भेद्यता वास्तव में मौजूद है या नहीं।
eval()तो 3 गुना से अधिक धीमा है try: int(s) except: float(s)।
evalबुरा अभ्यास है (आपको पता होना चाहिए क्योंकि आपके पास 310k प्रतिष्ठा है)
type(my_object)उस पर। परिणाम आमतौर पर रूपांतरण करने के लिए एक फ़ंक्शन के रूप में कहा जा सकता है। उदाहरण के लिएtype(100)परिणाम हैint, तो आप पूर्णांक मेंint(my_object)परिवर्तितmy_objectकरने का प्रयास कर सकते हैं । यह हमेशा काम नहीं करता है, लेकिन कोडिंग करते समय एक अच्छा "पहला अनुमान" है।