পাইথনে কোনও স্ট্রিংকে ফ্লোতে রূপান্তর করা যায় কিনা তা পরীক্ষা করা হচ্ছে

Question

আমি কিছু পাইথন কোড পেয়েছি যা স্ট্রিংয়ের তালিকার মধ্য দিয়ে চলে এবং যদি সম্ভব হয় তবে তাদের পূর্ণসংখ্যা বা ভাসমান পয়েন্ট সংখ্যায় রূপান্তর করে। পূর্ণসংখ্যার জন্য এটি করা বেশ সহজ

if element.isdigit():
  newelement = int(element)

ভাসমান পয়েন্ট সংখ্যাগুলি আরও কঠিন। এই মুহুর্তে আমি partition('.')স্ট্রিংটি বিভক্ত করার জন্য ব্যবহার করছি এবং এক বা উভয় পক্ষই সংখ্যার কিনা তা পরীক্ষা করতে।

partition = element.partition('.')
if (partition[0].isdigit() and partition[1] == '.' and partition[2].isdigit()) 
    or (partition[0] == '' and partition[1] == '.' and partition[2].isdigit()) 
    or (partition[0].isdigit() and partition[1] == '.' and partition[2] == ''):
  newelement = float(element)

এটি কাজ করে তবে স্পষ্টতই যদি এর জন্য বিবৃতিটি ভালুকের কিছুটা থাকে। অন্য যে সমাধানটি আমি বিবেচনা করেছি তা হ'ল কেবল একটি চেষ্টা / ধরার ব্লকে রূপান্তরটি গুটিয়ে রাখা এবং এটি সফল হয় কিনা তা এই প্রশ্নের বর্ণনায় বর্ণিত to ।

অন্য কারও ধারণা আছে? পার্টিশনের আপেক্ষিক যোগ্যতা সম্পর্কে মতামত এবং চেষ্টা / দৃষ্টিভঙ্গি ধরুন?

Answer 1

আমি শুধু ব্যবহার করব ..

try:
    float(element)
except ValueError:
    print "Not a float"

এটা সহজ, এবং এটি কার্যকর

অন্য বিকল্পটি নিয়মিত প্রকাশ হবে:

import re
if re.match(r'^-?\d+(?:\.\d+)?$', element) is None:
    print "Not float"

Comments

@ এস.লোট: এর সাথে প্রয়োগ করা বেশিরভাগ স্ট্রিংগুলি ইনট বা ফ্লোটে পরিণত হবে।

— ক্রিস আপচর্চ

আপনার রেজেক্সটি অনুকূল নয়। "^ \ d + \। \ d + $" উপরের মতো একই গতিতে একটি ম্যাচ ব্যর্থ করবে, তবে দ্রুত সাফল্য পাবে। এছাড়াও, আরও সঠিক উপায় হ'ল: "^ [+ -]? \ D (>? \। \ D +)? $" তবে, এখনও এটির মতো সংখ্যা মেলে না: + 1.0e-10

— জন গিয়েটেন

আপনি নিজের ফাংশনটির নাম "উইল_ইট_ফ্লোয়েট" ভুলে গেছেন তা বাদে।

— আনমাউন্ট করা

দ্বিতীয় বিকল্পটি ন্যান এবং ঘৃণ্য এক্সপ্রেশনটি ধরবে না - যেমন 2e3।

— প্যাট্রিক বি।

আমি মনে করি রেজেক্স নেতিবাচক সংখ্যাকে পার্স করছে না।

— কার্লোস

Answer 2

ভাসমান পরীক্ষা করার জন্য পাইথন পদ্ধতি:

def isfloat(value):
  try:
    float(value)
    return True
  except ValueError:
    return False

ভাসা নৌকায় লুকিয়ে থাকা গব্লিনরা কিছুটা পেল না! পরীক্ষা পরীক্ষা করুন!

কী এবং কোন ফ্লোট নয় তা আপনাকে অবাক করে দিতে পারে:

Command to parse                        Is it a float?  Comment
--------------------------------------  --------------- ------------
print(isfloat(""))                      False
print(isfloat("1234567"))               True 
print(isfloat("NaN"))                   True            nan is also float
print(isfloat("NaNananana BATMAN"))     False
print(isfloat("123.456"))               True
print(isfloat("123.E4"))                True
print(isfloat(".1"))                    True
print(isfloat("1,234"))                 False
print(isfloat("NULL"))                  False           case insensitive
print(isfloat(",1"))                    False           
print(isfloat("123.EE4"))               False           
print(isfloat("6.523537535629999e-07")) True
print(isfloat("6e777777"))              True            This is same as Inf
print(isfloat("-iNF"))                  True
print(isfloat("1.797693e+308"))         True
print(isfloat("infinity"))              True
print(isfloat("infinity and BEYOND"))   False
print(isfloat("12.34.56"))              False           Two dots not allowed.
print(isfloat("#56"))                   False
print(isfloat("56%"))                   False
print(isfloat("0E0"))                   True
print(isfloat("x86E0"))                 False
print(isfloat("86-5"))                  False
print(isfloat("True"))                  False           Boolean is not a float.   
print(isfloat(True))                    True            Boolean is a float
print(isfloat("+1e1^5"))                False
print(isfloat("+1e1"))                  True
print(isfloat("+1e1.3"))                False
print(isfloat("+1.3P1"))                False
print(isfloat("-+1"))                   False
print(isfloat("(1)"))                   False           brackets not interpreted

Comments

দুর্দান্ত উত্তর। যেখানে আরও 2 টি যোগ করুন যেখানে ভাসা = সত্য: isfloat(" 1.23 ")এবং isfloat(" \n \t 1.23 \n\t\n")। ওয়েব অনুরোধে দরকারী; প্রথমে সাদা স্পেসগুলি ছাঁটাই করার দরকার নেই।

— বেরেনকেডকডার

Answer 3

'1.43'.replace('.','',1).isdigit()

যা trueকেবলমাত্র এক বা না থাকলেই ফিরে আসবে '' অঙ্কের স্ট্রিং এ।

'1.4.3'.replace('.','',1).isdigit()

ফিরে আসবে false

'1.ww'.replace('.','',1).isdigit()

ফিরে আসবে false

Comments

অনুকূল নয় তবে আসলে বেশ চালাক। +/- এবং ক্ষতিকারককে পরিচালনা করবে না।

— ম্যাড পদার্থবিদ

কয়েক বছর দেরীতে, তবে এটি একটি দুর্দান্ত পদ্ধতি। পান্ডাস ডেটাফ্রেমে নিম্নলিখিতটি ব্যবহার করে আমার জন্য কাজ করেছেন:[i for i in df[i].apply(lambda x: str(x).replace('.','').isdigit()).any()]

— চিহ্নিত করুন

@ মার্কমোরেটো আপনি যখন নেতিবাচক সংখ্যার অস্তিত্ব সম্পর্কে জানতে পারবেন তখন আপনি একটি ধাক্কা খেয়ে যাবেন

— ডেভিড হেফারনান

আমার দৃশ্যের জন্য সেরা ওয়ান-লাইনার, যেখানে আমাকে কেবল ইতিবাচক ফ্লোট বা সংখ্যাগুলি পরীক্ষা করতে হবে। আমি পছন্দ করি.

— এম জোহনিজে

Answer 4

টিএল; ডিআর :

• যদি আপনার ইনপুটটি বেশিরভাগ স্ট্রিং থাকে যা ফ্লোটে রূপান্তরিত হতে পারে thetry: except: পদ্ধতি সেরা নেটিভ পাইথন পদ্ধতি।
• যদি আপনার ইনপুটটি বেশিরভাগ স্ট্রিং থাকে যা না পারে ফ্লোটে রূপান্তর করা , নিয়মিত প্রকাশ বা পার্টিশন পদ্ধতি আরও ভাল।
• যদি আপনি 1) আপনার ইনপুট সম্পর্কে অনিশ্চিত হন বা আরও গতির প্রয়োজন হয় এবং 2) কিছু মনে করবেন না এবং তৃতীয় পক্ষের সি-এক্সটেনশনটি ইনস্টল করতে পারেন, ফাস্টন নাম্বারগুলি খুব ভাল কাজ করে।

---

তৃতীয় পক্ষের মডিউলটির মাধ্যমে ফাস্টনম্বার নামে আরও একটি পদ্ধতি উপলব্ধ রয়েছে (প্রকাশ, আমি লেখক); এটি ইসফ্লোট নামে একটি ফাংশন সরবরাহ করে । আমি এই উত্তরে জ্যাকব গ্যাব্রিয়েলসনের দ্বারা বর্ণিত একক উদাহরণটি গ্রহণ করেছি , তবে fastnumbers.isfloatপদ্ধতিটি যুক্ত করেছি। আমার এও লক্ষ্য করা উচিত যে জ্যাকব এর উদাহরণটি রেগেক্স বিকল্পের সাথে ন্যায়বিচার করেনি কারণ সেই উদাহরণটির বেশিরভাগ সময় ডট অপারেটরের কারণে বিশ্বব্যাপী দেখার জন্য ব্যয় করা হয়েছিল ... আমি এই ফাংশনটির সাথে একটি আরও ভাল তুলনা করতে সংশোধন করেছি try: except:।

---

def is_float_try(str):
    try:
        float(str)
        return True
    except ValueError:
        return False

import re
_float_regexp = re.compile(r"^[-+]?(?:\b[0-9]+(?:\.[0-9]*)?|\.[0-9]+\b)(?:[eE][-+]?[0-9]+\b)?$").match
def is_float_re(str):
    return True if _float_regexp(str) else False

def is_float_partition(element):
    partition=element.partition('.')
    if (partition[0].isdigit() and partition[1]=='.' and partition[2].isdigit()) or (partition[0]=='' and partition[1]=='.' and partition[2].isdigit()) or (partition[0].isdigit() and partition[1]=='.' and partition[2]==''):
        return True
    else:
        return False

from fastnumbers import isfloat


if __name__ == '__main__':
    import unittest
    import timeit

    class ConvertTests(unittest.TestCase):

        def test_re_perf(self):
            print
            print 're sad:', timeit.Timer('ttest.is_float_re("12.2x")', "import ttest").timeit()
            print 're happy:', timeit.Timer('ttest.is_float_re("12.2")', "import ttest").timeit()

        def test_try_perf(self):
            print
            print 'try sad:', timeit.Timer('ttest.is_float_try("12.2x")', "import ttest").timeit()
            print 'try happy:', timeit.Timer('ttest.is_float_try("12.2")', "import ttest").timeit()

        def test_fn_perf(self):
            print
            print 'fn sad:', timeit.Timer('ttest.isfloat("12.2x")', "import ttest").timeit()
            print 'fn happy:', timeit.Timer('ttest.isfloat("12.2")', "import ttest").timeit()


        def test_part_perf(self):
            print
            print 'part sad:', timeit.Timer('ttest.is_float_partition("12.2x")', "import ttest").timeit()
            print 'part happy:', timeit.Timer('ttest.is_float_partition("12.2")', "import ttest").timeit()

    unittest.main()

---

আমার মেশিনে, আউটপুটটি হ'ল:

fn sad: 0.220988988876
fn happy: 0.212214946747
.
part sad: 1.2219619751
part happy: 0.754667043686
.
re sad: 1.50515985489
re happy: 1.01107215881
.
try sad: 2.40243887901
try happy: 0.425730228424
.
----------------------------------------------------------------------
Ran 4 tests in 7.761s

OK

আপনি দেখতে পাচ্ছেন, রেজেক্স আসলে ততটা খারাপ নয় যতটা এটি প্রাথমিকভাবে মনে হয়েছিল এবং যদি আপনার গতির জন্য সত্যিকারের প্রয়োজন fastnumbersহয় তবে পদ্ধতিটি বেশ ভাল।

Comments

দ্রুত সংখ্যা চেকটি এত ভাল কাজ করে যদি আপনার বেশিরভাগ স্ট্রিং থাকে যা ফ্লোটে রূপান্তর করা যায় না, সত্যিই জিনিসগুলিকে গতি দেয়,

— থ্যাঙ্কিউ

Answer 5

আপনি যদি পারফরম্যান্স সম্পর্কে যত্নবান হন (এবং আমি আপনাকে পরামর্শ দেওয়ার পরামর্শ দিচ্ছি না), চেষ্টা-ভিত্তিক পদ্ধতিটি পরিষ্কার বিজয়ী (আপনার পার্টিশন-ভিত্তিক পদ্ধতির সাথে তুলনা করা) বা রেজিএক্সপ্যাক পদ্ধতির সাথে যতক্ষণ না আপনি অনেক আশা করেন না অবৈধ স্ট্রিং, এক্ষেত্রে এটি সম্ভাব্য ধীরে ধীরে (সম্ভবত ব্যতিক্রম হ্যান্ডলিংয়ের ব্যয়ের কারণে)।

আবার, আমি আপনাকে পারফরম্যান্সের প্রতি যত্নশীল হওয়ার পরামর্শ দিচ্ছি না, আপনি যদি সেকেন্ডে 10 বিলিয়ন বার এই কিছু করছেন বা কেবল আপনাকে ডেটা দিচ্ছেন giving এছাড়াও, পার্টিশন-ভিত্তিক কোড কমপক্ষে একটি বৈধ স্ট্রিং পরিচালনা করে না।

$ ./floatstr.py
এফ ..
বিভাজন দু: খ: 3.1102449894
পার্টিশনটি খুশি: 2.09208488464
..
দু: খিত: 7.76906108856
সুখী: 7.09421992302
..
দুঃখের চেষ্টা করুন: 12.1525540352
খুশি চেষ্টা করুন: 1.44165301323
।
================================================== ====================
ব্যর্থ: পরীক্ষা_বিভাজন (__ মেইন __। রূপান্তরকরণ)
-------------------------------------------------- --------------------
ট্রেসব্যাক (সবচেয়ে সাম্প্রতিকতম কল সর্বশেষ):
  ফাইল "./floatstr.py", পরীক্ষার_ভাগে লাইন 48,
    self.failUnless (is_float_partition ( "20e2"))
AssertionError

-------------------------------------------------- --------------------
33.670 এর দশকে 8 টি পরীক্ষা চালানো

ব্যর্থ (ব্যর্থতা = 1)

এখানে কোড (পাইথন ২.6, জন গীটজেনের উত্তর থেকে নেওয়া রেজিপ্সপ ):

def is_float_try(str):
    try:
        float(str)
        return True
    except ValueError:
        return False

import re
_float_regexp = re.compile(r"^[-+]?(?:\b[0-9]+(?:\.[0-9]*)?|\.[0-9]+\b)(?:[eE][-+]?[0-9]+\b)?$")
def is_float_re(str):
    return re.match(_float_regexp, str)


def is_float_partition(element):
    partition=element.partition('.')
    if (partition[0].isdigit() and partition[1]=='.' and partition[2].isdigit()) or (partition[0]=='' and partition[1]=='.' and pa\
rtition[2].isdigit()) or (partition[0].isdigit() and partition[1]=='.' and partition[2]==''):
        return True

if __name__ == '__main__':
    import unittest
    import timeit

    class ConvertTests(unittest.TestCase):
        def test_re(self):
            self.failUnless(is_float_re("20e2"))

        def test_try(self):
            self.failUnless(is_float_try("20e2"))

        def test_re_perf(self):
            print
            print 're sad:', timeit.Timer('floatstr.is_float_re("12.2x")', "import floatstr").timeit()
            print 're happy:', timeit.Timer('floatstr.is_float_re("12.2")', "import floatstr").timeit()

        def test_try_perf(self):
            print
            print 'try sad:', timeit.Timer('floatstr.is_float_try("12.2x")', "import floatstr").timeit()
            print 'try happy:', timeit.Timer('floatstr.is_float_try("12.2")', "import floatstr").timeit()

        def test_partition_perf(self):
            print
            print 'partition sad:', timeit.Timer('floatstr.is_float_partition("12.2x")', "import floatstr").timeit()
            print 'partition happy:', timeit.Timer('floatstr.is_float_partition("12.2")', "import floatstr").timeit()

        def test_partition(self):
            self.failUnless(is_float_partition("20e2"))

        def test_partition2(self):
            self.failUnless(is_float_partition(".2"))

        def test_partition3(self):
            self.failIf(is_float_partition("1234x.2"))

    unittest.main()

Answer 6

শুধু বিভিন্ন জন্য এখানে এটি করার অন্য একটি পদ্ধতি।

>>> all([i.isnumeric() for i in '1.2'.split('.',1)])
True
>>> all([i.isnumeric() for i in '2'.split('.',1)])
True
>>> all([i.isnumeric() for i in '2.f'.split('.',1)])
False

সম্পাদনা: আমি নিশ্চিত যে এটি ভাসমানের সব ক্ষেত্রেই ধরে রাখবে না যদিও বিশেষত যখন কোনও এক্সপোনেন্ট থাকে। এটির মতো দেখতে এটি সমাধান করা। এটি প্রত্যাবর্তন করবে সত্যিকারের ভ্যাল ইন্টের জন্য একটি ভাসা এবং মিথ্যা তবে সম্ভবত রেগেক্সের চেয়ে কম পারফরম্যান্ট।

>>> def isfloat(val):
...     return all([ [any([i.isnumeric(), i in ['.','e']]) for i in val],  len(val.split('.')) == 2] )
...
>>> isfloat('1')
False
>>> isfloat('1.2')
True
>>> isfloat('1.2e3')
True
>>> isfloat('12e3')
False

Comments

ইসনুমুরিক ফাংশনটি একটি দুর্বল পছন্দ হিসাবে দেখায়, যেমনটি ভগ্নাংশের মতো বিভিন্ন ইউনিকোডের অক্ষরগুলিতে সত্য হয়। দস্তাবেজগুলি বলেছেন: "সংখ্যাসূচক অক্ষরগুলির মধ্যে অঙ্কের অক্ষর এবং ইউনিকোড সংখ্যাসম্য বৈশিষ্ট্যযুক্ত সমস্ত অক্ষর, যেমন ইউ + 2155, ভলগার খণ্ড এক পঞ্চম অন্তর্ভুক্ত থাকে"

— গ্রেডম্যানম্যান

Answer 7

এই রেজেক্স বৈজ্ঞানিক ভাসমান পয়েন্ট সংখ্যাগুলি পরীক্ষা করবে:

^[-+]?(?:\b[0-9]+(?:\.[0-9]*)?|\.[0-9]+\b)(?:[eE][-+]?[0-9]+\b)?$

তবে আমি বিশ্বাস করি যে আপনার সেরা বাজিটি চেষ্টা করে পার্সার ব্যবহার করা।

Answer 8

যদি আপনাকে বৈজ্ঞানিক বা সংখ্যার অন্যান্য অভিব্যক্তি সম্পর্কে উদ্বেগের প্রয়োজন না হয় এবং কেবলমাত্র এমন স্ট্রিংগুলির সাথে কাজ করছেন যা কোনও সময়ের সাথে বা ছাড়াই সংখ্যা হতে পারে:

ক্রিয়া

def is_float(s):
    result = False
    if s.count(".") == 1:
        if s.replace(".", "").isdigit():
            result = True
    return result

লাম্বদা সংস্করণ

is_float = lambda x: x.replace('.','',1).isdigit() and "." in x

উদাহরণ

if is_float(some_string):
    some_string = float(some_string)
elif some_string.isdigit():
    some_string = int(some_string)
else:
    print "Does not convert to int or float."

এইভাবে আপনি দুর্ঘটনাক্রমে কোন প্রচ্ছদটি হওয়া উচিত তা একটি ফ্লোটে রূপান্তর করছেন না।

Answer 9

ফাংশনের সরলীকৃত সংস্করণ is_digit(str) , যা বেশিরভাগ ক্ষেত্রেই যথেষ্ট ( ক্ষণস্থায়ী স্বরলিপি এবং "NaN" মান বিবেচনা করে না ):

def is_digit(str):
    return str.lstrip('-').replace('.', '').isdigit()

Answer 10

আমি ইতিমধ্যে উল্লিখিত ফাংশনটি ব্যবহার করেছি, তবে শীঘ্রই আমি লক্ষ্য করেছি যে স্ট্রিংগুলিকে "ন্যান", "ইনফ" এবং এর প্রকরণটি সংখ্যা হিসাবে বিবেচনা করা হয়। সুতরাং আমি আপনাকে ফাংশনের উন্নত সংস্করণটির প্রস্তাব দিচ্ছি, যা এই ধরণের ইনপুটটিতে মিথ্যা ফিরে আসবে এবং "1e3" রূপগুলি ব্যর্থ করবে না:

def is_float(text):
    # check for nan/infinity etc.
    if text.isalpha():
        return False
    try:
        float(text)
        return True
    except ValueError:
        return False

Comments

আমরা এখনই if text.isalpha():চেক দিয়ে শুরু করতে পারি না ?

— সিএসবা তোথ

বিটিডাব্লু আমার একই দরকার: আমি এনএএন, ইনফ এবং স্টাফ গ্রহণ করতে চাই না

— সিএসবা টথ

Answer 11

ভাসতে রূপান্তর করার চেষ্টা করুন। যদি কোনও ত্রুটি থাকে, মান ভ্যালুআরারের ব্যতিক্রমটি মুদ্রণ করুন।

try:
    x = float('1.23')
    print('val=',x)
    y = float('abc')
    print('val=',y)
except ValueError as err:
    print('floatErr;',err)

আউটপুট:

val= 1.23
floatErr: could not convert string to float: 'abc'

Answer 12

যুক্তি হিসাবে অভিধানটি পাস করা এটি স্ট্রিংগুলিকে রূপান্তর করবে যা ভাসাতে রূপান্তরিত হতে পারে এবং অন্যকে ছেড়ে চলে যায়

def covertDict_float(data):
        for i in data:
            if data[i].split(".")[0].isdigit():
                try:
                    data[i] = float(data[i])
                except:
                    continue
        return data

Answer 13

আমি কিছু অনুরূপ কোড সন্ধান করছিলাম, তবে দেখে মনে হচ্ছে চেষ্টা / ব্যাতিক্রমগুলি ব্যবহার করা সবচেয়ে ভাল উপায়। আমি যে কোডটি ব্যবহার করছি তা এখানে। যদি ইনপুটটি অবৈধ হয় তবে এটিতে পুনরায় চেষ্টা করুন। আমার ইনপুটটি 0 এর চেয়ে বড় ছিল কিনা তা যাচাই করা দরকার এবং যদি তাই এটি একটি ফ্লোটে রূপান্তরিত করে।

def cleanInput(question,retry=False): 
    inputValue = input("\n\nOnly positive numbers can be entered, please re-enter the value.\n\n{}".format(question)) if retry else input(question)
    try:
        if float(inputValue) <= 0 : raise ValueError()
        else : return(float(inputValue))
    except ValueError : return(cleanInput(question,retry=True))


willbefloat = cleanInput("Give me the number: ")

Answer 14

def try_parse_float(item):
  result = None
  try:
    float(item)
  except:
    pass
  else:
    result = float(item)
  return result

Comments

এই কোডটি কীভাবে এবং কেন সমস্যার সমাধান করে তার ব্যাখ্যা সহ প্রশ্নটি সমাধান করতে পারে যদিও আপনার পোস্টের মান উন্নত করতে সত্যিই সহায়তা করবে এবং সম্ভবত আরও বেশি ভোটের ফলাফল হবে। মনে রাখবেন যে আপনি ভবিষ্যতে পাঠকদের জন্য প্রশ্নের উত্তর দিচ্ছেন, কেবল এখনই জিজ্ঞাসা করা ব্যক্তি নয়। দয়া করে সম্পাদনা ব্যাখ্যা যোগ করতে পারেন এবং সীমাবদ্ধতা এবং অনুমানের কি প্রয়োগ একটি ইঙ্গিত দিতে আপনার উত্তর।

— ডাবল-বীপ

Answer 15

আমি উপরের কয়েকটি সহজ বিকল্প ব্যবহার করে একটি ফ্লোটে রূপান্তরিত করার চেষ্টা করে পরীক্ষা করে দেখেছি যে বেশিরভাগ জবাবতে সমস্যা আছে।

সাধারণ পরীক্ষা (উপরের উত্তরের রেখা বরাবর):

entry = ttk.Entry(self, validate='key')
entry['validatecommand'] = (entry.register(_test_num), '%P')

def _test_num(P):
    try: 
        float(P)
        return True
    except ValueError:
        return False

সমস্যাটি আসে যখন:

• Aণাত্মক সংখ্যা শুরু করতে আপনি '-' লিখুন:

তারপরে আপনি float('-')যা চেষ্টা করছেন তা ব্যর্থ

• আপনি একটি নম্বর লিখুন, তবে তারপরে সমস্ত অঙ্ক মুছতে চেষ্টা করুন

তারপরে আপনি চেষ্টা করছেন float('')যা একইভাবে ব্যর্থ হয়

আমার কাছে দ্রুত সমাধানটি হ'ল:

def _test_num(P):
    if P == '' or P == '-': return True
    try: 
        float(P)
        return True
    except ValueError:
        return False

Answer 16

str(strval).isdigit()

সহজ বলে মনে হচ্ছে

স্ট্রিং বা ইনট বা ফ্লোট হিসাবে সঞ্চিত মানগুলি পরিচালনা করে

Comments

ইন [2]: '123,123'.আইডিজিট () আউট [2]: মিথ্যা

— ড্যানিল মাশকিন

এটি নেতিবাচক সংখ্যার জন্য কাজ করে না আক্ষরিক, দয়া করে আপনার উত্তরটি ঠিক করুন

— এলোমেলো

'39 .1'.আইডিজিট ()

— ওহাদ দ্য লাড

সব ([x.isdigit () x x এর জন্য str (VAR)। স্ট্রিপ ('-')। প্রতিস্থাপন (',', '।')। বিভক্ত ('।')])) আপনি যদি আরও সম্পূর্ণ খুঁজছেন বাস্তবায়ন.

— লোট্রুস 28