python मैं कैसे जांचूं कि कोई स्ट्रिंग एक संख्या है(फ्लोट)?




casting floating-point (24)

You may use regex.

number = raw_input("Enter a number: ")
if re.match(r'^\d+$', number):
    print "It's integer"
    print int(number)
elif re.match(r'^\d+\.\d+$', number):
    print "It's float"
    print float(number)
else:
    print("Please enter a number")

यह जांचने का सबसे अच्छा तरीका क्या है कि स्ट्रिंग को पायथन में किसी संख्या के रूप में प्रदर्शित किया जा सकता है?

वर्तमान में मेरे पास अभी कार्य है:

def is_number(s):
    try:
        float(s)
        return True
    except ValueError:
        return False

जो न केवल बदसूरत और धीमी है, गुंजाइश लगता है। हालांकि मुझे एक बेहतर तरीका नहीं मिला है क्योंकि मुख्य समारोह में float कॉल करना और भी बदतर है।


मुझे यह निर्धारित करने की आवश्यकता है कि एक स्ट्रिंग मूल प्रकार (फ्लोट, int, str, bool) में डाली गई है या नहीं। इंटरनेट पर कुछ भी नहीं ढूंढने के बाद मैंने इसे बनाया:

def str_to_type (s):
    """ Get possible cast type for a string

    Parameters
    ----------
    s : string

    Returns
    -------
    float,int,str,bool : type
        Depending on what it can be cast to

    """    
    try:                
        f = float(s)        
        if "." not in s:
            return int
        return float
    except ValueError:
        value = s.upper()
        if value == "TRUE" or value == "FALSE":
            return bool
        return type(s)

उदाहरण

str_to_type("true") # bool
str_to_type("6.0") # float
str_to_type("6") # int
str_to_type("6abc") # str
str_to_type(u"6abc") # unicode       

आप इस प्रकार को कैप्चर कर सकते हैं और इसका इस्तेमाल कर सकते हैं

s = "6.0"
type_ = str_to_type(s) # float
f = type_(s) 

int उपयोग के लिए यह:

>>> "1221323".isdigit()
True

लेकिन float हमें कुछ चाल की जरूरत है ;-)। प्रत्येक फ्लोट नंबर में एक बिंदु है ...

>>> "12.34".isdigit()
False
>>> "12.34".replace('.','',1).isdigit()
True
>>> "12.3.4".replace('.','',1).isdigit()
False

नकारात्मक संख्याओं के लिए भी lstrip() जोड़ें:

>>> '-12'.lstrip('-')
'12'

और अब हमें एक सार्वभौमिक तरीका मिलता है:

>>> '-12.34'.lstrip('-').replace('.','',1).isdigit()
True
>>> '.-234'.lstrip('-').replace('.','',1).isdigit()
False


If you want to know if the entire string can be represented as a number you'll want to use a regexp (or maybe convert the float back to a string and compare it to the source string, but I'm guessing that's not very fast).


मैं देखना चाहता था कि कौन सी विधि सबसे तेज है। कुल मिलाकर सर्वोत्तम और सबसे संगत परिणाम check_replace फ़ंक्शन द्वारा दिए गए थे। सबसे तेज़ परिणाम check_exception फ़ंक्शन द्वारा दिए गए थे, लेकिन केवल तभी निकाला गया था जब इसका कोई अपवाद नहीं था - जिसका अर्थ है कि इसका कोड सबसे कुशल है, लेकिन अपवाद फेंकने का ओवरहेड काफी बड़ा है।

कृपया ध्यान दें कि सफल कलाकारों की जांच करना एकमात्र तरीका है जो सटीक है, उदाहरण के लिए, यह check_exception साथ काम करता है लेकिन अन्य दो परीक्षण फ़ंक्शन एक वैध फ़्लोट के लिए गलत लौटाएंगे:

huge_number = float('1e+100')

बेंचमार्क कोड यहां दिया गया है:

import time, re, random, string

ITERATIONS = 10000000

class Timer:    
    def __enter__(self):
        self.start = time.clock()
        return self
    def __exit__(self, *args):
        self.end = time.clock()
        self.interval = self.end - self.start

def check_regexp(x):
    return re.compile("^\d*\.?\d*$").match(x) is not None

def check_replace(x):
    return x.replace('.','',1).isdigit()

def check_exception(s):
    try:
        float(s)
        return True
    except ValueError:
        return False

to_check = [check_regexp, check_replace, check_exception]

print('preparing data...')
good_numbers = [
    str(random.random() / random.random()) 
    for x in range(ITERATIONS)]

bad_numbers = ['.' + x for x in good_numbers]

strings = [
    ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(random.randint(1,10)))
    for x in range(ITERATIONS)]

print('running test...')
for func in to_check:
    with Timer() as t:
        for x in good_numbers:
            res = func(x)
    print('%s with good floats: %s' % (func.__name__, t.interval))
    with Timer() as t:
        for x in bad_numbers:
            res = func(x)
    print('%s with bad floats: %s' % (func.__name__, t.interval))
    with Timer() as t:
        for x in strings:
            res = func(x)
    print('%s with strings: %s' % (func.__name__, t.interval))

2017 मैकबुक प्रो 13 पर पाइथन 2.7.10 के साथ परिणाम यहां दिए गए हैं:

check_regexp with good floats: 12.688639
check_regexp with bad floats: 11.624862
check_regexp with strings: 11.349414
check_replace with good floats: 4.419841
check_replace with bad floats: 4.294909
check_replace with strings: 4.086358
check_exception with good floats: 3.276668
check_exception with bad floats: 13.843092
check_exception with strings: 15.786169

2017 मैकबुक प्रो 13 पर पाइथन 3.6.5 के साथ परिणाम यहां दिए गए हैं:

check_regexp with good floats: 13.472906000000009
check_regexp with bad floats: 12.977665000000016
check_regexp with strings: 12.417542999999995
check_replace with good floats: 6.011045999999993
check_replace with bad floats: 4.849356
check_replace with strings: 4.282754000000011
check_exception with good floats: 6.039081999999979
check_exception with bad floats: 9.322753000000006
check_exception with strings: 9.952595000000002

2017 मैकबुक प्रो 13 पर पीपीपी 2.7.13 के साथ परिणाम यहां दिए गए हैं:

check_regexp with good floats: 2.693217
check_regexp with bad floats: 2.744819
check_regexp with strings: 2.532414
check_replace with good floats: 0.604367
check_replace with bad floats: 0.538169
check_replace with strings: 0.598664
check_exception with good floats: 1.944103
check_exception with bad floats: 2.449182
check_exception with strings: 2.200056

जो न केवल बदसूरत और धीमी है

मैं दोनों पर विवाद करेंगे।

एक रेगेक्स या अन्य स्ट्रिंग पार्सिंग उलझन और धीमी होगी।

मुझे यकीन नहीं है कि उपर्युक्त की तुलना में कुछ भी तेज हो सकता है। यह समारोह और रिटर्न कहते हैं। कोशिश करें / कैच अधिक ओवरहेड पेश नहीं करता है क्योंकि सबसे आम अपवाद स्टैक फ्रेम की व्यापक खोज के बिना पकड़ा जाता है।

मुद्दा यह है कि किसी भी संख्यात्मक रूपांतरण समारोह में दो प्रकार के परिणाम होते हैं

  • एक संख्या, यदि संख्या मान्य है
  • एक स्टेटस कोड (उदाहरण के लिए, इरनो के माध्यम से) या अपवाद यह दिखाने के लिए कि कोई मान्य संख्या पार्स नहीं की जा सकती है।

सी (उदाहरण के रूप में) इस कई तरीकों से हैक करता है। पायथन इसे स्पष्ट रूप से और स्पष्ट रूप से बताता है।

मुझे लगता है कि ऐसा करने के लिए आपका कोड सही है।


मैंने कुछ गति परीक्षण किया। आइए कहें कि यदि स्ट्रिंग एक संख्या होने की संभावना है तो कोशिश / छोड़ने की रणनीति सबसे तेज़ संभव है। यदि स्ट्रिंग एक संख्या होने की संभावना नहीं है और आप इंटीजर चेक में रुचि रखते हैं, तो यह कुछ परीक्षण करने के लायक है (isdigit प्लस शीर्षक '-')। यदि आप फ्लोट नंबर की जांच करना चाहते हैं, तो आपको कोशिश / कोड को छोड़कर कोड श्वेत निकालना का उपयोग करना होगा।


Try this.

 def is_number(var):
    try:
       if var == int(var):
            return True
    except Exception:
        return False

निम्नलिखित मामलों का पालन करने के बाद इसका उपयोग करें: -

import re
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3') 
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '.3')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3sd')
a=re.match('((\d+[\.]\d*$)|(\.)\d+$)' ,  '2.3')

आपका कोड मुझे ठीक लग रहा है।

शायद आपको लगता है कि अपवादों का उपयोग करने के कारण कोड "गुंजाइश" है? ध्यान दें कि पायथन प्रोग्रामर कोड कम करने योग्यता में सुधार करते समय अपवादों का उदारतापूर्वक उपयोग करते हैं, इसके कम प्रदर्शन दंड के कारण धन्यवाद।


I also used the function you mentioned, but soon I notice that strings as "Nan", "Inf" and it's variation are considered as number. So I propose you improved version of your function, that will return false on those type of input and will not fail "1e3" variants:

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

गैर-संख्याओं के तारों के लिए, try: except: वास्तव में नियमित अभिव्यक्तियों से धीमा है। वैध संख्याओं के तारों के लिए, रेगेक्स धीमा है। तो, उचित विधि आपके इनपुट पर निर्भर करती है।

यदि आपको लगता है कि आप एक प्रदर्शन बाध्य में हैं, तो आप fastnumbers नामक एक नए थर्ड-पार्टी मॉड्यूल का उपयोग कर सकते हैं जो fastnumbers नामक फ़ंक्शन प्रदान करता है। पूर्ण प्रकटीकरण, मैं लेखक हूं। मैंने इसके परिणाम नीचे दिए गए समय में शामिल किए हैं।

from __future__ import print_function
import timeit

prep_base = '''\
x = 'invalid'
y = '5402'
z = '4.754e3'
'''

prep_try_method = '''\
def is_number_try(val):
    try:
        float(val)
        return True
    except ValueError:
        return False

'''

prep_re_method = '''\
import re
float_match = re.compile(r'[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$').match
def is_number_re(val):
    return bool(float_match(val))

'''

fn_method = '''\
from fastnumbers import isfloat

'''

print('Try with non-number strings', timeit.timeit('is_number_try(x)',
    prep_base + prep_try_method), 'seconds')
print('Try with integer strings', timeit.timeit('is_number_try(y)',
    prep_base + prep_try_method), 'seconds')
print('Try with float strings', timeit.timeit('is_number_try(z)',
    prep_base + prep_try_method), 'seconds')
print()
print('Regex with non-number strings', timeit.timeit('is_number_re(x)',
    prep_base + prep_re_method), 'seconds')
print('Regex with integer strings', timeit.timeit('is_number_re(y)',
    prep_base + prep_re_method), 'seconds')
print('Regex with float strings', timeit.timeit('is_number_re(z)',
    prep_base + prep_re_method), 'seconds')
print()
print('fastnumbers with non-number strings', timeit.timeit('isfloat(x)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print('fastnumbers with integer strings', timeit.timeit('isfloat(y)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print('fastnumbers with float strings', timeit.timeit('isfloat(z)',
    prep_base + 'from fastnumbers import isfloat'), 'seconds')
print()
Try with non-number strings 2.39108395576 seconds
Try with integer strings 0.375686168671 seconds
Try with float strings 0.369210958481 seconds

Regex with non-number strings 0.748660802841 seconds
Regex with integer strings 1.02021503448 seconds
Regex with float strings 1.08564686775 seconds

fastnumbers with non-number strings 0.174362897873 seconds
fastnumbers with integer strings 0.179651021957 seconds
fastnumbers with float strings 0.20222902298 seconds

जैसा कि आप देख सकते हैं

  • try: except: संख्यात्मक इनपुट के लिए तेज़ था लेकिन अमान्य इनपुट के लिए बहुत धीमा था
  • इनपुट अमान्य होने पर regex बहुत प्रभावी है
  • fastnumbers दोनों मामलों में जीतता है

To check if the input value is a float , you can compare the type of the input to a float

def isFloat(s):
    realFloat = 0.1

    if type(s) == type(realFloat):
        return True
    else:
        return False

यह दिखाता है:

False     # s = 5
True      # s = 1.2345

मूल पोस्ट वास्तव में वापसी होगी Trueके लिए s = 5के बाद से यह एक संख्या (पूर्णांक) है और आप एक डाल सकता intएक करने के लिए floatएक के बिना ValueError। यदि आप यह सत्यापित करने का प्रयास कर रहे हैं कि यह floatकेवल एक संख्या के बजाय वास्तविक है , तो आपको उस मामले के लिए खाते की आवश्यकता होगी।


यदि आप फ्लोट्स के बजाय पार्सिंग (पॉजिटिव, हस्ताक्षरित) पूर्णांक की तलाश में हैं, तो आप स्ट्रिंग ऑब्जेक्ट्स के लिए isdigit() फ़ंक्शन का उपयोग कर सकते हैं।

>>> a = "03523"
>>> a.isdigit()
True
>>> b = "963spam"
>>> b.isdigit()
False

स्ट्रिंग विधि - isdigit()

यूनिकोड स्ट्रिंग्स पर कुछ भी है, जो मैं यूनिकोड से बहुत परिचित नहीं हूं - दशमलव / दशमलव है


मुझे पता है कि यह विशेष रूप से पुराना है लेकिन मैं एक उत्तर जोड़ूंगा, मेरा मानना ​​है कि उच्चतम मतदान वाले उत्तर से लापता जानकारी को शामिल किया गया है जो इसे ढूंढने वाले किसी भी व्यक्ति के लिए बहुत मूल्यवान हो सकता है:

निम्न विधियों में से प्रत्येक के लिए उन्हें गिनती से कनेक्ट करें यदि आपको स्वीकार किए जाने वाले इनपुट की आवश्यकता है। (मान लीजिए कि हम 0-255, आदि के बजाय पूर्णांक की मुखर परिभाषाओं का उपयोग कर रहे हैं)

x.isdigit() जांचने के लिए अच्छी तरह से काम करता है कि x एक पूर्णांक है या नहीं।

x.replace('-','').isdigit() जांचने के लिए अच्छी तरह से काम करता है कि x नकारात्मक है या नहीं। (पहले स्थिति में चेक करें)

x.replace('.','').isdigit() जांचने के लिए अच्छी तरह से काम करता है कि x दशमलव है या नहीं।

x.replace(':','').isdigit() जांचने के लिए अच्छी तरह से काम करता है कि एक्स अनुपात है या नहीं।

x.replace('/','',1).isdigit() जांचने के लिए अच्छी तरह से काम करता है कि x एक अंश है या नहीं।


यह उत्तर स्ट्रिंग को खोजने के लिए उदाहरणों के साथ कार्य करने के चरण-दर-चरण मार्गदर्शिका प्रदान करता है:

  • सकारात्मक पूर्णांक
  • सकारात्मक / नकारात्मक - पूर्णांक / फ्लोट
  • संख्या की जांच करते समय "NaN" (संख्या नहीं) स्ट्रिंग को कैसे हटाएं?

जांचें कि स्ट्रिंग सकारात्मक पूर्णांक है या नहीं

आप isdigit() का उपयोग यह isdigit() लिए कर सकते हैं कि दिया गया स्ट्रिंग सकारात्मक पूर्णांक है या नहीं।

नमूना परिणाम:

# For digit
>>> '1'.isdigit()
True
>>> '1'.isalpha()
False

स्ट्रिंग के लिए सकारात्मक / नकारात्मक - पूर्णांक / फ्लोट के रूप में जांचें

str.isdigit() स्ट्रिंग रिटर्न देता है यदि स्ट्रिंग ऋणात्मक संख्या या फ्लोट नंबर है। उदाहरण के लिए:

# returns `False` for float
>>> '123.3'.isdigit()
False
# returns `False` for negative number
>>> '-123'.isdigit()
False

यदि आप नकारात्मक पूर्णांक और float की जांच भी करना चाहते हैं, तो आप इसे देखने के लिए एक कस्टम फ़ंक्शन लिख सकते हैं:

def is_number(n):
    try:
        float(n)   # Type-casting the string to `float`.
                   # If string is not a valid `float`, 
                   # it'll raise `ValueError` exception
    except ValueError:
        return False
    return True

नमूना रन:

>>> is_number('123')    # positive integer number
True

>>> is_number('123.4')  # positive float number
True

>>> is_number('-123')   # negative integer number
True

>>> is_number('-123.4') # negative `float` number
True

>>> is_number('abc')    # `False` for "some random" string
False

संख्या की जांच करते समय "NaN" (संख्या नहीं) स्ट्रिंग को छोड़ दें

उपरोक्त फ़ंक्शन "एनएएन" (संख्या नहीं) स्ट्रिंग के लिए True लौटाएंगे क्योंकि पाइथन के लिए यह मान्य फ्लोट का प्रतिनिधित्व करता है यह संख्या नहीं है। उदाहरण के लिए:

>>> is_number('NaN')
True

यह जांचने के लिए कि क्या संख्या "NaN" है, आप math.isnan() उपयोग इस math.isnan() कर सकते हैं:

>>> import math
>>> nan_num = float('nan')

>>> math.isnan(nan_num)
True

या यदि आप इसे जांचने के लिए अतिरिक्त लाइब्रेरी आयात नहीं करना चाहते हैं, तो आप इसे == का उपयोग करके स्वयं की तुलना करके इसकी जांच कर सकते हैं। पायथन लौटता है जब nan फ्लोट की तुलना स्वयं की तुलना में की जाती है। उदाहरण के लिए:

# `nan_num` variable is taken from above example
>>> nan_num == nan_num
False

इसलिए, उपरोक्त फ़ंक्शन is_number को "NaN" लिए False स्थानांतरित करने के लिए अपडेट किया जा सकता है :

def is_number(n):
    is_number = True
    try:
        num = float(n)
        # check for "nan" floats
        is_number = num == num   # or use `math.isnan(num)`
    except ValueError:
        is_number = False
    return is_number

नमूना रन:

>>> is_number('Nan')   # not a number "Nan" string
False

>>> is_number('nan')   # not a number string "nan" with all lower cased
False

>>> is_number('123')   # positive integer
True

>>> is_number('-123')  # negative integer
True

>>> is_number('-1.12') # negative `float`
True

>>> is_number('abc')   # "some random" string
False

PS: Each operation for each check depending on the type of number comes with additional overhead. Choose the version of is_number function which fits your requirement.


Here's my simple way of doing it. Let's say that I'm looping through some strings and I want to add them to an array if they turn out to be numbers.

try:
    myvar.append( float(string_to_check) )
except:
    continue

Replace the myvar.apppend with whatever operation you want to do with the string if it turns out to be a number. The idea is to try to use a float() operation and use the returned error to determine whether or not the string is a number.


बस नकल सी #

सी # में दो अलग-अलग फ़ंक्शन हैं जो स्केलर मानों के विश्लेषण को संभालते हैं:

  • Float.Parse ()
  • Float.TryParse ()

float.parse ():

def parse(string):
    try:
        return float(string)
    except Exception:
        throw TypeError

नोट: यदि आप सोच रहे हैं कि मैंने टाइपएरर में अपवाद क्यों बदल दिया है, तो यहां दस्तावेज़ है

float.try_parse ():

def try_parse(string, fail=None):
    try:
        return float(string)
    except Exception:
        return fail;

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

'पार्स ()' और 'try_parse ()' को शामिल करने के लिए फ्लोट का विस्तार करने के लिए आपको इन विधियों को जोड़ने के लिए 'फ्लोट' क्लास को बंदरगाह करना होगा।

यदि आप पूर्व-मौजूदा कार्यों का सम्मान करना चाहते हैं तो कोड कुछ ऐसा होना चाहिए:

def monkey_patch():
    if(!hasattr(float, 'parse')):
        float.parse = parse
    if(!hasattr(float, 'try_parse')):
        float.try_parse = try_parse

साइड नोट: मैं व्यक्तिगत रूप से इसे बंदर पंचिंग कहना पसंद करता हूं क्योंकि ऐसा लगता है कि जब मैं ऐसा करता हूं तो मैं भाषा का दुरुपयोग कर रहा हूं लेकिन वाईएमएमवी।

उपयोग:

float.parse('giggity') // throws TypeException
float.parse('54.3') // returns the scalar value 54.3
float.tryParse('twank') // returns None
float.tryParse('32.2') // returns the scalar value 32.2

और महान ऋषि पायथनस ने होली सी शार्पिसस से कहा, "जो कुछ भी आप कर सकते हैं मैं बेहतर कर सकता हूं; मैं आपसे कुछ भी बेहतर कर सकता हूं।"


ValueError को फ़्लोट करने और पकड़ने कास्टिंग शायद सबसे तेज़ तरीका है, क्योंकि फ्लोट () विशेष रूप से उस के लिए है। स्ट्रिंग पार्सिंग (रेगेक्स, इत्यादि) की आवश्यकता वाले किसी भी चीज की संभावना धीमी हो जाएगी क्योंकि इस ऑपरेशन के लिए यह ट्यून नहीं किया गया है। मेरा $ 0.02।


एक अपवाद है जिसे आप ध्यान में रखना चाहते हैं: स्ट्रिंग 'NaN'

यदि आप 'NaN' के लिए FALSE लौटने के लिए is_number चाहते हैं तो यह कोड काम नहीं करेगा क्योंकि पायथन इसे उस संख्या के प्रतिनिधित्व में परिवर्तित कर देता है जो संख्या नहीं है (पहचान समस्याओं के बारे में बात करें):

>>> float('NaN')
nan

अन्यथा, मुझे वास्तव में कोड के टुकड़े के लिए धन्यवाद देना चाहिए जो अब मैं बड़े पैमाने पर उपयोग करता हूं। :)

जी


इस बारे में कैसा है:

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

जो केवल तभी वापस आ जाएगा जब एक या नहीं '।' अंकों की स्ट्रिंग में।

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

झूठी वापसी होगी

संपादित करें: बस एक और टिप्पणी देखी ... अन्य मामलों के लिए एक .replace(badstuff,'',maxnum_badstuff) । यदि आप नमक गुजर रहे हैं और मनमानी मसालों नहीं हैं (रेफरी: xkcd#974 ) यह ठीक होगा: पी


तो इसे सभी को एक साथ रखने के लिए, नैन, अनंत और जटिल संख्याओं की जांच करें (ऐसा लगता है कि वे जे के साथ निर्दिष्ट हैं, नहीं, यानी 1 + 2j) इसके परिणामस्वरूप:

def is_number(s):
    try:
        n=str(float(s))
        if n == "nan" or n=="inf" or n=="-inf" : return False
    except ValueError:
        try:
            complex(s) # for complex
        except ValueError:
            return False
    return True

जो न केवल बदसूरत और धीमी है, गुंजाइश लगता है।

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

बतख टाइपिंग के पीछे केंद्रीय विचार यह है कि "अगर यह एक बतख की तरह चलता है और बात करता है, तो यह एक बतख है।" क्या होगा यदि आप तय करते हैं कि आपको स्ट्रिंग को उप-वर्ग करने की आवश्यकता है ताकि आप यह निर्धारित कर सकें कि आप कैसे निर्धारित करते हैं कि कुछ फ़्लोट में परिवर्तित किया जा सकता है? या क्या होगा यदि आप पूरी तरह से किसी अन्य वस्तु का परीक्षण करने का फैसला करते हैं? आप उपरोक्त कोड को बदलने के बिना इन चीजों को कर सकते हैं।

अन्य भाषाएं इंटरफेस का उपयोग करके इन समस्याओं को हल करती हैं। मैं विश्लेषण कर दूंगा कि कौन सा समाधान किसी अन्य थ्रेड के लिए बेहतर है। मुद्दा यह है कि पाइथन निश्चित रूप से समीकरण के बतख टाइपिंग पक्ष पर है, और यदि आप पाइथन में अधिक प्रोग्रामिंग करने की योजना बना रहे हैं तो आपको शायद इस तरह सिंटैक्स के लिए उपयोग करना होगा (लेकिन इसका मतलब यह नहीं है आपको इसे निश्चित रूप से पसंद करना है)।

एक और चीज जिसे आप ध्यान में रखना चाहते हैं: पाइथन कई अन्य भाषाओं की तुलना में अपवादों को फेंकने और पकड़ने में काफी तेज है (उदाहरण के लिए .NET से 30x तेज)। बिल्ली, भाषा स्वयं भी असाधारण, सामान्य कार्यक्रम स्थितियों (प्रत्येक बार जब आप लूप का उपयोग करते हैं) को संवाद करने के लिए अपवाद फेंकता है। इस प्रकार, जब तक आप कोई महत्वपूर्ण समस्या नहीं देखते हैं, तब तक मैं इस कोड के प्रदर्शन पहलुओं के बारे में बहुत ज्यादा चिंता नहीं करता।





type-conversion