কোনও স্ট্রিং চেষ্টা / ব্যবহার না করেই কোনও স্ট্রিং কোনও আন্ত প্রতিনিধিত্ব করে কিনা তা আমি কীভাবে পরীক্ষা করতে পারি?

Question

কোনও স্ট্রিং কোনও চেষ্টা / ব্যবহার ব্যতীত ব্যবহার ছাড়াই কোনও পূর্ণসংখ্যা (উদাহরণস্বরূপ '3', '-17'তবে নয় '3.14'বা 'asfasfas') প্রতিনিধিত্ব করে কিনা তা বলার কোনও উপায় আছে ?

is_int('3.14') = False
is_int('-7')   = True

Comments

কেন উভয়ই এই "কঠোর উপায়ে" করার চেষ্টা করছে? চেষ্টা করে / বাদ দিয়ে কী দোষ হয়েছে?

— এস .লট

হ্যাঁ, চেষ্টা করে / বাদ দিয়ে কী হয়েছে? অনুমতি চেয়ে ক্ষমা চাইতে ভাল।

— এম কে 12

আমি জিজ্ঞাসা করব কেন এই সহজ জিনিসটির জন্য চেষ্টা করা উচিত / বাদে? ব্যতিক্রম সিস্টেম একটি জটিল জন্তু, তবে এটি একটি সাধারণ সমস্যা।

— আইভর

@ আইভর FUD ছড়িয়ে পড়া বন্ধ করুন একটি একক চেষ্টা / ব্লক ব্যতীত "জটিল" কাছেও যায় না।

— ট্রিপটিচ

যদিও এটি সত্যই FUD নয় not আপনি কার্যকরভাবে 4 টি লাইন কোড লিখতে চাইবেন, কিছু প্রস্ফুটিত হবে বলে আশা করছেন, সেই ব্যতিক্রমটি ধরুন এবং একটি লাইনার ব্যবহারের পরিবর্তে আপনার ডিফল্ট করুন।

— andersonvom

Answer 1

আপনি যদি try/exceptপুরো জায়গা জুড়ে এটি ব্যবহার করতে সত্যিই বিরক্ত হন তবে দয়া করে কেবল একটি সহায়ক ফাংশন লিখুন:

def RepresentsInt(s):
    try: 
        int(s)
        return True
    except ValueError:
        return False

>>> print RepresentsInt("+123")
True
>>> print RepresentsInt("10.0")
False

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

Comments

সুতরাং জটিল প্রক্রিয়া সহ সাধারণ সমস্যা সমাধান করা কি অজগর? ইন্টের ভিতরে লেখা লিখিত ফাংশন "ইনট" সনাক্ত করার জন্য একটি অ্যালগরিদম রয়েছে - আমি দেখতে পাচ্ছি না কেন এটি বুলিয়ান ফাংশন হিসাবে প্রকাশ করা হয়নি।

— আইভার

@ আইভর: এই পাঁচ লাইনের কাজটি কোনও জটিল প্রক্রিয়া নয়।

— ট্রিপটিচ

বাদে:>>> print RepresentsInt(10.0) True >>> print RepresentsInt(10.06) True

— ড্যানিড

আমি অনুমান করি যে এটি "পাইথোনিক" এই অর্থে যে পাইথন যদি মনে করে যে স্ট্রিংটি একটি ইনট, আপনার প্রোগ্রামটিও তাই করে। পাইথন যদি পরিবর্তন হয় তবে আপনার প্রোগ্রামটিও কোডের একক লাইন পরিবর্তন না করে। কিছু মূল্য আছে। পরিস্থিতিগুলির উপর নির্ভর করে এটি করা সঠিক জিনিস হতে পারে।

— শাওয়াইস

আমি জানি না কেন এটি গৃহীত উত্তর বা এতগুলি উত্স রয়েছে, যেহেতু এটি ওপি যা বলছে তার ঠিক বিপরীত।

— নির্ভয়ফিউচার

Answer 2

ইতিবাচক পূর্ণসংখ্যার সাহায্যে আপনি ব্যবহার করতে পারেন .isdigit:

>>> '16'.isdigit()
True

এটি যদিও নেতিবাচক পূর্ণসংখ্যার সাথে কাজ করে না। ধরুন আপনি নিম্নলিখিত চেষ্টা করতে পারেন:

>>> s = '-17'
>>> s.startswith('-') and s[1:].isdigit()
True

এটি '16.0'বিন্যাসের সাথে কাজ করবে না , যা intএই অর্থে কাস্টিংয়ের অনুরূপ ।

সম্পাদনা করুন :

def check_int(s):
    if s[0] in ('-', '+'):
        return s[1:].isdigit()
    return s.isdigit()

Comments

এটি অতিরিক্ত বিশেষ কেস ছাড়াই "+17" পরিচালনা করে না।

— ব্রায়ান ওকলে

আপনি উভয় ক্ষেত্রেই জন্য পরীক্ষার করতে হবে: ল্যামডা S: s.isdigit () বা (s.startswith ( '-') এবং এর [1:]। Isdigit ())

— ডাকাতি

@ রবার্তো: অবশ্যই আপনার উচিত! এবং আমি নিশ্চিত যে আপনি এটি করতে সক্ষম!

— সাইলেন্টগোস্ট

দ্রষ্টব্য: u'²'.isdigit()সত্য তবে int(u'²')মান মানক উত্থাপন করে। u.isdecimal()পরিবর্তে ব্যবহার করুন। str.isdigit()পাইথন 2 এর উপর স্থানীয়ভাবে নির্ভরশীল

— jfs

check_int('')ফিরে আসার পরিবর্তে একটি ব্যতিক্রম বাড়িয়ে False

— তুলবে

Answer 3

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

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

ব্রুনোর পোস্টের একটি দ্রুত এবং নোংরা সম্পাদনা এখানে:

import sys, time, re

g_intRegex = re.compile(r"^([+-]?[1-9]\d*|0)$")

testvals = [
    # integers
    0, 1, -1, 1.0, -1.0,
    '0', '0.','0.0', '1', '-1', '+1', '1.0', '-1.0', '+1.0', '06',
    # non-integers
    'abc 123',
    1.1, -1.1, '1.1', '-1.1', '+1.1',
    '1.1.1', '1.1.0', '1.0.1', '1.0.0',
    '1.0.', '1..0', '1..',
    '0.0.', '0..0', '0..',
    'one', object(), (1,2,3), [1,2,3], {'one':'two'},
    # with spaces
    ' 0 ', ' 0.', ' .0','.01 '
]

def isInt_try(v):
    try:     i = int(v)
    except:  return False
    return True

def isInt_str(v):
    v = str(v).strip()
    return v=='0' or (v if v.find('..') > -1 else v.lstrip('-+').rstrip('0').rstrip('.')).isdigit()

def isInt_re(v):
    import re
    if not hasattr(isInt_re, 'intRegex'):
        isInt_re.intRegex = re.compile(r"^([+-]?[1-9]\d*|0)$")
    return isInt_re.intRegex.match(str(v).strip()) is not None

def isInt_re2(v):
    return g_intRegex.match(str(v).strip()) is not None

def check_int(s):
    s = str(s)
    if s[0] in ('-', '+'):
        return s[1:].isdigit()
    return s.isdigit()    


def timeFunc(func, times):
    t1 = time.time()
    for n in range(times):
        for v in testvals: 
            r = func(v)
    t2 = time.time()
    return t2 - t1

def testFuncs(funcs):
    for func in funcs:
        sys.stdout.write( "\t%s\t|" % func.__name__)
    print()
    for v in testvals:
        if type(v) == type(''):
            sys.stdout.write("'%s'" % v)
        else:
            sys.stdout.write("%s" % str(v))
        for func in funcs:
            sys.stdout.write( "\t\t%s\t|" % func(v))
        sys.stdout.write("\r\n") 

if __name__ == '__main__':
    print()
    print("tests..")
    testFuncs((isInt_try, isInt_str, isInt_re, isInt_re2, check_int))
    print()

    print("timings..")
    print("isInt_try:   %6.4f" % timeFunc(isInt_try, 10000))
    print("isInt_str:   %6.4f" % timeFunc(isInt_str, 10000)) 
    print("isInt_re:    %6.4f" % timeFunc(isInt_re, 10000))
    print("isInt_re2:   %6.4f" % timeFunc(isInt_re2, 10000))
    print("check_int:   %6.4f" % timeFunc(check_int, 10000))

এখানে পারফরম্যান্স তুলনা ফলাফল:

timings..
isInt_try:   0.6426
isInt_str:   0.7382
isInt_re:    1.1156
isInt_re2:   0.5344
check_int:   0.3452

এসি পদ্ধতিটি একবারের মাধ্যমে এটি স্ক্যান করতে পারে এবং হয়ে যায়। এসি পদ্ধতিটি যা একবারে স্ট্রিংটিকে স্ক্যান করে তা হ'ল সঠিক জিনিস হবে বলে আমি মনে করি।

সম্পাদনা করুন:

আমি পাইথন 3.5 তে কাজ করার জন্য উপরের কোডটি আপডেট করেছি এবং বর্তমানে সর্বাধিক ভোট দেওয়া উত্তর থেকে চেক_ইন্ট ফাংশন অন্তর্ভুক্ত করতে এবং পূর্ণসংখ্যার-হুডের পরীক্ষার জন্য যে সর্বাধিক জনপ্রিয় রেগেক্স আমি খুঁজে পেতে পারি তা ব্যবহার করতে। এই রেজেক্স 'abc 123' এর মতো স্ট্রিংকে প্রত্যাখ্যান করে। আমি পরীক্ষার মান হিসাবে 'abc 123' যুক্ত করেছি।

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

বিল্ট ইন ইন () ফাংশনটি নিঃশব্দে একটি ভাসমান বিন্দু সংখ্যার ভগ্নাংশ অংশ কেটে দেয় এবং দশমিকের আগে পূর্ণসংখ্যার অংশটি প্রত্যাবর্তন করে, যদি না ভাসমান বিন্দু সংখ্যাটি প্রথমে একটি স্ট্রিংয়ে রূপান্তরিত হয়।

চেক_িন্ট () ফাংশনটি 0.0 এবং 1.0 (যা প্রযুক্তিগতভাবে পূর্ণসংখ্যা হয়) এর মত মানগুলির জন্য মিথ্যা প্রত্যাবর্তন করে এবং '06' এর মতো মানগুলির জন্য সত্য প্রদান করে।

এখানে বর্তমান (পাইথন 3.5) পরীক্ষার ফলাফল রয়েছে:

                  isInt_try |       isInt_str       |       isInt_re        |       isInt_re2       |   check_int   |
    0               True    |               True    |               True    |               True    |       True    |
    1               True    |               True    |               True    |               True    |       True    |
    -1              True    |               True    |               True    |               True    |       True    |
    1.0             True    |               True    |               False   |               False   |       False   |
    -1.0            True    |               True    |               False   |               False   |       False   |
    '0'             True    |               True    |               True    |               True    |       True    |
    '0.'            False   |               True    |               False   |               False   |       False   |
    '0.0'           False   |               True    |               False   |               False   |       False   |
    '1'             True    |               True    |               True    |               True    |       True    |
    '-1'            True    |               True    |               True    |               True    |       True    |
    '+1'            True    |               True    |               True    |               True    |       True    |
    '1.0'           False   |               True    |               False   |               False   |       False   |
    '-1.0'          False   |               True    |               False   |               False   |       False   |
    '+1.0'          False   |               True    |               False   |               False   |       False   |
    '06'            True    |               True    |               False   |               False   |       True    |
    'abc 123'       False   |               False   |               False   |               False   |       False   |
    1.1             True    |               False   |               False   |               False   |       False   |
    -1.1            True    |               False   |               False   |               False   |       False   |
    '1.1'           False   |               False   |               False   |               False   |       False   |
    '-1.1'          False   |               False   |               False   |               False   |       False   |
    '+1.1'          False   |               False   |               False   |               False   |       False   |
    '1.1.1'         False   |               False   |               False   |               False   |       False   |
    '1.1.0'         False   |               False   |               False   |               False   |       False   |
    '1.0.1'         False   |               False   |               False   |               False   |       False   |
    '1.0.0'         False   |               False   |               False   |               False   |       False   |
    '1.0.'          False   |               False   |               False   |               False   |       False   |
    '1..0'          False   |               False   |               False   |               False   |       False   |
    '1..'           False   |               False   |               False   |               False   |       False   |
    '0.0.'          False   |               False   |               False   |               False   |       False   |
    '0..0'          False   |               False   |               False   |               False   |       False   |
    '0..'           False   |               False   |               False   |               False   |       False   |
    'one'           False   |               False   |               False   |               False   |       False   |
    <obj..>         False   |               False   |               False   |               False   |       False   |
    (1, 2, 3)       False   |               False   |               False   |               False   |       False   |
    [1, 2, 3]       False   |               False   |               False   |               False   |       False   |
    {'one': 'two'}  False   |               False   |               False   |               False   |       False   |
    ' 0 '           True    |               True    |               True    |               True    |       False   |
    ' 0.'           False   |               True    |               False   |               False   |       False   |
    ' .0'           False   |               False   |               False   |               False   |       False   |
    '.01 '          False   |               False   |               False   |               False   |       False   |

ঠিক এখনই আমি এই ফাংশনটি যুক্ত করার চেষ্টা করেছি:

def isInt_float(s):
    try:
        return float(str(s)).is_integer()
    except:
        return False

এটি চেক_ইন্ট (0.3486) এর পাশাপাশি প্রায়শই সম্পাদন করে এবং এটি 1.0 এবং 0.0 এবং +1.0 এবং 0 এবং .0 এবং এর মতো মানের জন্য সত্য করে। তবে এটি '06' এর ক্ষেত্রেও সত্য ফিরে আসে। আপনার বিষটি বাছাই করুন, আমার ধারণা।

Comments

সম্ভবত এর কিছু অংশ সত্য থেকে আসে যে কোনও পূর্ণসংখ্যা নিজেই কিছুটা স্বেচ্ছাসেবী। কোনও প্রোগ্রামিং সিস্টেম এটি ধরে নেওয়ার বিলাসিতা নিতে পারে না যে এটি সর্বদা দশমিক প্রতিনিধিত্ব হতে চলেছে। 0x4df, কিছু জায়গায় একটি বৈধ পূর্ণসংখ্যার, এবং 0891 অন্যদের মধ্যে নেই। এই ধরণের চেকগুলিতে ইউনিকোড দেওয়া কি হতে পারে তা ভেবে আমি ভয় পাই।

— PlexQ

সময় জন্য +1। আমি সম্মত হই যে এই সম্পূর্ণ ব্যতিক্রম ব্যবসাটি এত সাধারণ প্রশ্নের জন্য সত্যই মার্জিত নয়। আপনি এই ধরনের একটি সাধারণ সমস্যার জন্য সহায়ক পদ্ধতি একটি বিল্ড আশা করতে চেয়েছিলেন ...

— রিকিয়া

আমি জানি এই থ্রেডটি মূলত সুপ্ত, তবে রান-টাইম বিবেচনার জন্য +1। লাইনের দৈর্ঘ্য সর্বদা অন্তর্নিহিত জটিলতার পরিচায়ক নয়; এবং নিশ্চিত, করে দেখুন / ব্যতীত যথাসাধ্য বর্ণন সহজ (এবং, সহজে পড়া যা অত্যন্ত গুরুত্বপূর্ণ), কিন্তু এটা হয় একটি ব্যয়বহুল অপারেশন। আমি যুক্তি দিয়েছি যে অগ্রাধিকার শ্রেণিবিন্যাস সর্বদা নিম্নলিখিতগুলির মতো হওয়া উচিত: ১. সুস্পষ্ট সমাধান (সাইলেন্টগোস্টের) পড়া সহজ read ২. অন্তর্নিহিত সমাধান পড়ার জন্য একটি সহজ (ট্রিপটাইকের)। 3. কোন তিনটি নেই।

— এরিক হামফ্রে

যেমন একটি আপাতদৃষ্টিতে তুচ্ছ বিষয় সম্পর্কে আপনার সফর তদন্তের জন্য ধন্যবাদ। আমি আইসন_স্ট্রি (), পাইথোনিকের সাথে যাব কিনা। আমার যে বিষয়টি ঘৃণা করছে তা হ'ল আমি v.find ('..') এর অর্থ সম্পর্কে কিছুই পাই না। এটি কি কোনও বিশেষ সন্ধানের বাক্য গঠন বা একটি সংখ্যা-স্ট্রিংয়ের প্রান্ত-কেস?

— জ্যাকলিমারডিউর

হ্যাঁ, কিছুটা তারিখযুক্ত তবে এখনও সত্যিই দুর্দান্ত এবং প্রাসঙ্গিক বিশ্লেষণ। পাইথন 3.5 tryতে আরও কার্যকর: #Int_try: 0.6552 / isInt_str: 0.6396 / isInt_re: 1.0296 / isInt_re2: 0.5168।

— ডেভ

Answer 4

str.isdigit() কৌতুক করা উচিত।

উদাহরণ:

str.isdigit("23") ## True
str.isdigit("abc") ## False
str.isdigit("23.4") ## False

সম্পাদনা : @ বাজমোশেটি যেমন উল্লেখ করেছে, এই উপায়টি বিয়োগ সংখ্যার জন্য ব্যর্থ হবে (যেমন, "-23" )। আপনার ইনপুট_নাম 0 এর চেয়ে কম হতে পারে , str.isdigit () প্রয়োগ করার আগে re.sub (regex_search, regex_replace, বিষয়বস্তু) ব্যবহার করুন । উদাহরণ স্বরূপ:

import re
input_num = "-23"
input_num = re.sub("^-", "", input_num) ## "^" indicates to remove the first "-" only
str.isdigit(input_num) ## True

Comments

কারণ -23 মিথ্যা ফলন করে।

— বাজ মোসচেটি

@ বুজমোশেটি আপনি ঠিক বলেছেন ঠিক করার একটি দ্রুত উপায় হ'ল str.isdigit ()

— ক্যাটবিল্টস

Answer 5

একটি নিয়মিত অভিব্যক্তি ব্যবহার করুন:

import re
def RepresentsInt(s):
    return re.match(r"[-+]?\d+$", s) is not None

আপনার অবশ্যই দশমিক ভগ্নাংশ গ্রহণ করতে হবে:

def RepresentsInt(s):
    return re.match(r"[-+]?\d+(\.0*)?$", s) is not None

উন্নত পারফরম্যান্সের জন্য যদি আপনি প্রায়শই এই কাজটি করেন তবে একবার ব্যবহার করার পরে নিয়মিত এক্সপ্রেশনটি সংকলন করুন re.compile()।

Comments

+1: দেখায় যে চেষ্টা / বাদ দিয়ে তুলনা করা হলে এটি ভয়াবহ জটিল এবং ব্যয়বহুল।

— এস .লট

আমি অনুভব করি এটি @ সাইলেন্টগোস্ট দ্বারা প্রদত্ত 'ইসনুমেরিক' সমাধানটির মূলত একটি ধীর, কাস্টম সংস্করণ।

— গ্রেগ

@ গ্রেগ: যেহেতু @ সাইলেন্টগোস্ট চিহ্নগুলি সঠিকভাবে আবরণ করে না, এই সংস্করণটি আসলে কাজ করে।

— এস .লট

@ এস.লোট: অবশ্যই, এসও তে পোস্ট করতে সক্ষম যে কেউ, আমার চিহ্নগুলিকে চিহ্নগুলি আবরণে প্রসারিত করতে সক্ষম হবে।

— সাইলেন্টগোস্ট 12:58

নিয়মিত প্রকাশগুলি অস্তিত্বের সবচেয়ে জটিল এবং অস্পষ্ট জিনিস সম্পর্কে হয়, আমি দেখতে পেলাম যে উপরের সরল চেকটি যথেষ্ট পরিমাণে সুস্পষ্ট, এমনকি আমি যদি এখনও এটি কুৎসিত মনে করি তবে এটি কুশ্রী।

— PlexQ

Answer 6

সঠিক রেগেক্স সমাধানটি গ্রেগ হিউগিল এবং নওলের ধারণাগুলি একত্রিত করবে তবে বৈশ্বিক পরিবর্তনশীল ব্যবহার করবে না। আপনি পদ্ধতির কোনও বৈশিষ্ট্য সংযুক্ত করে এটি সম্পাদন করতে পারেন। এছাড়াও, আমি জানি যে কোনও পদ্ধতিতে আমদানি করা উচিত নয়, তবে আমি যা যাচ্ছি তা হ'ল "অলস মডিউল" প্রভাব যেমন http://peak.telecommune.com/DevCenter/Importing#lazy-portorts

সম্পাদনা করুন: আমার প্রিয় কৌশলটি এখন পর্যন্ত স্ট্রিং অবজেক্টের একচেটিয়া পদ্ধতিগুলি ব্যবহার করা।

#!/usr/bin/env python

# Uses exclusively methods of the String object
def isInteger(i):
    i = str(i)
    return i=='0' or (i if i.find('..') > -1 else i.lstrip('-+').rstrip('0').rstrip('.')).isdigit()

# Uses re module for regex
def isIntegre(i):
    import re
    if not hasattr(isIntegre, '_re'):
        print("I compile only once. Remove this line when you are confident in that.")
        isIntegre._re = re.compile(r"[-+]?\d+(\.0*)?$")
    return isIntegre._re.match(str(i)) is not None

# When executed directly run Unit Tests
if __name__ == '__main__':
    for obj in [
                # integers
                0, 1, -1, 1.0, -1.0,
                '0', '0.','0.0', '1', '-1', '+1', '1.0', '-1.0', '+1.0',
                # non-integers
                1.1, -1.1, '1.1', '-1.1', '+1.1',
                '1.1.1', '1.1.0', '1.0.1', '1.0.0',
                '1.0.', '1..0', '1..',
                '0.0.', '0..0', '0..',
                'one', object(), (1,2,3), [1,2,3], {'one':'two'}
            ]:
        # Notice the integre uses 're' (intended to be humorous)
        integer = ('an integer' if isInteger(obj) else 'NOT an integer')
        integre = ('an integre' if isIntegre(obj) else 'NOT an integre')
        # Make strings look like strings in the output
        if isinstance(obj, str):
            obj = ("'%s'" % (obj,))
        print("%30s is %14s is %14s" % (obj, integer, integre))

এবং ক্লাসের কম দু: সাহসিক সদস্যদের জন্য, এখানে আউটপুট:

I compile only once. Remove this line when you are confident in that.
                             0 is     an integer is     an integre
                             1 is     an integer is     an integre
                            -1 is     an integer is     an integre
                           1.0 is     an integer is     an integre
                          -1.0 is     an integer is     an integre
                           '0' is     an integer is     an integre
                          '0.' is     an integer is     an integre
                         '0.0' is     an integer is     an integre
                           '1' is     an integer is     an integre
                          '-1' is     an integer is     an integre
                          '+1' is     an integer is     an integre
                         '1.0' is     an integer is     an integre
                        '-1.0' is     an integer is     an integre
                        '+1.0' is     an integer is     an integre
                           1.1 is NOT an integer is NOT an integre
                          -1.1 is NOT an integer is NOT an integre
                         '1.1' is NOT an integer is NOT an integre
                        '-1.1' is NOT an integer is NOT an integre
                        '+1.1' is NOT an integer is NOT an integre
                       '1.1.1' is NOT an integer is NOT an integre
                       '1.1.0' is NOT an integer is NOT an integre
                       '1.0.1' is NOT an integer is NOT an integre
                       '1.0.0' is NOT an integer is NOT an integre
                        '1.0.' is NOT an integer is NOT an integre
                        '1..0' is NOT an integer is NOT an integre
                         '1..' is NOT an integer is NOT an integre
                        '0.0.' is NOT an integer is NOT an integre
                        '0..0' is NOT an integer is NOT an integre
                         '0..' is NOT an integer is NOT an integre
                         'one' is NOT an integer is NOT an integre
<object object at 0x103b7d0a0> is NOT an integer is NOT an integre
                     (1, 2, 3) is NOT an integer is NOT an integre
                     [1, 2, 3] is NOT an integer is NOT an integre
                {'one': 'two'} is NOT an integer is NOT an integre

Comments

আমি সম্মত হই যে আমার পরীক্ষার স্যুট ওভারকিল। আমি প্রমাণ করতে চাই যে আমার কোডটি লিখলে এটি কার্যকর হয়। তবে আপনি কি মনে করেন যে আমার আইটেইজার ফাংশনটি ওভারকিল করেছে? অবশ্যই না.

— ব্রুনো ব্রোনসকি

আমি কোনও মন্তব্য ছাড়াই একটি ডাউন ভোট পেয়েছি। মানুষের সাথে কী আছে? আমি বুঝতে পারি যে সহস্রাব্দগুলি এখন "পছন্দগুলি" "পঠন প্রাপ্তি" হিসাবে ব্যবহার করছে। তবে তারা কি এখন "আমি যে পদ্ধতিটি বেছে নিয়েছি" চিহ্নিতকারী হিসাবে ভোটগুলি ব্যবহার করছে? হতে পারে তারা বুঝতে পারে না যে এটি আপনার নিজের খ্যাতি থেকে 2 টি পয়েন্টটি একটি উত্তর ভোট দেওয়ার জন্য বিয়োগ করে । কেবল ভুল তথ্য দেওয়ার কারণে ভোটদানকে উত্সাহিত করার জন্য এসও / এসই তা করেন, সেক্ষেত্রে আমি আশা করি আপনি কোনও মন্তব্য করবেন ।

— ব্রুনো ব্রোনোস্কি

Answer 7

>>> "+7".lstrip("-+").isdigit()
True
>>> "-7".lstrip("-+").isdigit()
True
>>> "7".lstrip("-+").isdigit()
True
>>> "13.4".lstrip("-+").isdigit()
False

সুতরাং আপনার ফাংশন হবে:

def is_int(val):
   return val[1].isdigit() and val.lstrip("-+").isdigit()

Comments

is_int ("2") সূচিপত্র উত্থাপন করে।

— anttikoo

Answer 8

গ্রেগ হিউগিলের পদ্ধতির কয়েকটি উপাদান অনুপস্থিত ছিল: কেবল স্ট্রিংয়ের শুরুর সাথে মিলে যাওয়ার জন্য নেতৃস্থানীয় "^", এবং পূর্বে পুনরায় সংকলন করেছিলেন। তবে এই পদ্ধতির সাহায্যে আপনি চেষ্টা এড়াতে পারবেন:

import re
INT_RE = re.compile(r"^[-]?\d+$")
def RepresentsInt(s):
    return INT_RE.match(str(s)) is not None

আপনি আগ্রহ এড়াতে চাইছেন কেন আমি আগ্রহী: বাদে?

Comments

শৈলীর বিষয়। আমি মনে করি যে "চেষ্টা / বাদে" কেবলমাত্র আসল ত্রুটি ব্যবহার করা উচিত, সাধারণ প্রোগ্রাম প্রবাহের সাথে নয়।

— আদম মতান

@ উদি পাসমন: পাইথন "স্বাভাবিক" প্রোগ্রাম প্রবাহ ব্যতীত / প্রচুর পরিমাণে ব্যবহারের চেষ্টা করে। উদাহরণস্বরূপ, প্রতিটি পুনরাবৃত্তি একটি উত্থাপিত ব্যতিক্রম নিয়ে থামে।

— এস .লট

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

— টমাসএইচ

এস.লট - অজগরকে এটি যুক্তিসঙ্গত প্রবাহ হিসাবে বিবেচনা করা হয়? এটি অন্যান্য ভাষার থেকে কীভাবে আলাদা? সম্ভবত এটি একটি পৃথক প্রশ্ন মূল্যবান।

— আদম মতান

পাইথনের ভারী ব্যবহারের চেষ্টা / বাদে এখানে এসও coveredাকা পড়েছে। '[অজগর] বাদে' অনুসন্ধানের জন্য চেষ্টা করুন

— এস .লোট

Answer 9

আমাকে সর্বদা এটি করতে হবে এবং চেষ্টা / প্যাটার্ন ব্যতীত ব্যবহার করার ক্ষেত্রে আমার কাছে একটি হালকা তবে স্বীকারোক্তিযুক্ত যুক্তিযুক্ত বিদ্বেষ রয়েছে। আমি এটি ব্যবহার:

all([xi in '1234567890' for xi in x])

এটি নেতিবাচক সংখ্যাগুলিকে সামঞ্জস্য করে না, সুতরাং আপনি একটি বিয়োগ চিহ্ন (যদি থাকে) সরিয়ে ফেলতে পারেন এবং তারপরে ফলাফলটি 0-9-এর সংখ্যার সমন্বয়ে রয়েছে কিনা তা পরীক্ষা করে দেখুন:

all([xi in '1234567890' for xi in x.replace('-', '', 1)])

আপনি যদি নিশ্চিত হন না যে ইনপুটটি কোনও স্ট্রিং রয়েছে:

all([xi in '1234567890' for xi in str(x).replace('-', '', 1)])

কমপক্ষে দুটি (প্রান্ত?) কেস রয়েছে যেখানে এটি পৃথক হয়ে যায়:

1. এটি বিভিন্ন বৈজ্ঞানিক এবং / অথবা সূচকীয় স্বরলিপিগুলির জন্য কাজ করে না (উদাঃ 1.2E3, 10 ^ 3, ইত্যাদি) - উভয়ই মিথ্যা ফিরিয়ে দেবে। আমি অন্য উত্তর হয় আপনি এই স্থান মনে করি না, এবং এমনকি পাইথন 3.8, অসঙ্গত মতামত হয়েছে যেহেতু type(1E2)দেয় <class 'float'>যেহেতু type(10^2)দেয় <class 'int'>।
2. একটি খালি স্ট্রিং ইনপুট সত্য দেয়।

সুতরাং এটি প্রতিটি সম্ভাব্য ইনপুটটির জন্য কাজ করবে না , তবে আপনি যদি বৈজ্ঞানিক স্বরলিপি, ঘনিষ্টর নোটেশন এবং খালি স্ট্রিংগুলি বাদ দিতে পারেন তবে এটি একটি ওয়ান-লাইন চেক যা Falseএক্স পূর্ণসংখ্যা নয় এবং Trueযদি x একটি পূর্ণসংখ্যা হয় returns

আমি জানি না এটি অজগর কিনা, তবে এটি একটি লাইন, এবং কোডটি কী করে তা তুলনামূলকভাবে পরিষ্কার।

Comments

চেষ্টা করুন / বাদে কারও লনে হাঁটার মতো মনে হয় (চেষ্টা করুন) এবং তারপরে / যখন তারা লক্ষ্য করে এবং রেগে যায় (ব্যতিক্রম) আপনি ক্ষমা চান (ব্যতিক্রমটি পরিচালনা করুন), তবে আমার all(xi in '1234567890' for xi in x])প্যাটার্নটি লন পেরিয়ে যাওয়ার অনুমতি চাওয়ার মতো বলে মনে হচ্ছে। আমি অনুমতি প্রার্থী হতে শিহরিত হই না, তবে আমরা এখানে আছি।

— এমট্রেন

Answer 10

আমি মনে করি

s.startswith('-') and s[1:].isdigit()

আবার লিখতে ভাল হবে:

s.replace('-', '').isdigit()

কারণ s [1:] এছাড়াও একটি নতুন স্ট্রিং তৈরি করে

তবে এর থেকে আরও ভাল সমাধান

s.lstrip('+-').isdigit()

Comments

অনুমান কি replaceকরে? এছাড়াও, এটি 5-2উদাহরণস্বরূপ ভুলভাবে গ্রহণ করবে ।

— রাই-

একটি সূচিযন্ত্র নিক্ষেপ করবে যদিs='-'

— অ্যান্টি আর্থ

s = '-'; এস.প্লেস ('-', '') .আইডিজিট () -> মিথ্যা

— ভ্লাদিস্লাভ সাভচেঙ্কো

Answer 11

আমি শাওয়াইসের পোস্টটি সত্যিই পছন্দ করেছি, তবে আমি আরও একটি পরীক্ষার কেস যুক্ত করেছি (এবং বিল্ট ইন আইসডিজিট () ফাংশন):

def isInt_loop(v):
    v = str(v).strip()
    # swapping '0123456789' for '9876543210' makes nominal difference (might have because '1' is toward the beginning of the string)
    numbers = '0123456789'
    for i in v:
        if i not in numbers:
            return False
    return True

def isInt_Digit(v):
    v = str(v).strip()
    return v.isdigit()

এবং এটি উল্লেখযোগ্যভাবে ধারাবাহিকভাবে বাকি সময়কে মারধর করে:

timings..
isInt_try:   0.4628
isInt_str:   0.3556
isInt_re:    0.4889
isInt_re2:   0.2726
isInt_loop:   0.1842
isInt_Digit:   0.1577

সাধারণ 2.7 অজগর ব্যবহার করে:

$ python --version
Python 2.7.10

দুটি সংখ্যক পরীক্ষার কেস আমি যুক্ত করেছি (isIl_loop এবং isInt_digit) সঠিক একই পরীক্ষার কেস পাস করে (তারা উভয়ই স্বাক্ষরবিহীন পূর্ণসংখ্যাকেই গ্রহণ করে) তবে আমি ভেবেছিলাম যে স্ট্রিং বাস্তবায়ন (আইসেন্ট_লুপ) সংশোধিত আইডিজিটের বিপরীতে লোকেরা আরও চতুর হতে পারে () ফাংশন, তাই আমি এটিকে অন্তর্ভুক্ত করেছি, যদিও মৃত্যুদন্ডের সময়টিতে সামান্য পার্থক্য রয়েছে। (এবং উভয় পদ্ধতিই সমস্ত কিছুকে প্রচুর পরিমাণে পরাজিত করে তবে অতিরিক্ত জিনিসগুলি পরিচালনা করবেন না: "./+/-")

এছাড়াও, আমি এটি আকর্ষণীয় বলে মনে করেছি যে ২০১২ সালে (বর্তমানে 2018) শাওয়াইস সম্পাদিত একই পরীক্ষায় রেজেক্স (isInt_re2 পদ্ধতি) স্ট্রিং তুলনাটি পরাজিত করেছে। রিজেক্স গ্রন্থাগারগুলি কি উন্নত হয়েছে?

Answer 12

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

def is_int(test):
    import string
    return not (set(test) - set(string.digits))

Comments

set(input_string) == set(string.digits)যদি আমরা লাফালাফি '-+ 'শুরুতে এবং .0, E-1শেষে।

— jfs

Answer 13

এখানে একটি ফাংশন যা ত্রুটি না বাড়িয়ে পার্স করে। এটি Noneব্যর্থতার ক্ষেত্রে সুস্পষ্ট মামলার রিটার্ন হ্যান্ডেল করে (সিপাইটিতে ডিফল্টরূপে 2000 - '/ +' পর্যন্ত লক্ষণগুলি পরিচালনা করে!):

#!/usr/bin/env python

def get_int(number):
    splits = number.split('.')
    if len(splits) > 2:
        # too many splits
        return None
    if len(splits) == 2 and splits[1]:
        # handle decimal part recursively :-)
        if get_int(splits[1]) != 0:
            return None

    int_part = splits[0].lstrip("+")
    if int_part.startswith('-'):
        # handle minus sign recursively :-)
        return get_int(int_part[1:]) * -1
    # successful 'and' returns last truth-y value (cast is always valid)
    return int_part.isdigit() and int(int_part)

কিছু পরীক্ষা:

tests = ["0", "0.0", "0.1", "1", "1.1", "1.0", "-1", "-1.1", "-1.0", "-0", "--0", "---3", '.3', '--3.', "+13", "+-1.00", "--+123", "-0.000"]

for t in tests:
    print "get_int(%s) = %s" % (t, get_int(str(t)))

ফলাফল:

get_int(0) = 0
get_int(0.0) = 0
get_int(0.1) = None
get_int(1) = 1
get_int(1.1) = None
get_int(1.0) = 1
get_int(-1) = -1
get_int(-1.1) = None
get_int(-1.0) = -1
get_int(-0) = 0
get_int(--0) = 0
get_int(---3) = -3
get_int(.3) = None
get_int(--3.) = 3
get_int(+13) = 13
get_int(+-1.00) = -1
get_int(--+123) = 123
get_int(-0.000) = 0

আপনার প্রয়োজনের জন্য আপনি ব্যবহার করতে পারেন:

def int_predicate(number):
     return get_int(number) is not None

Answer 14

আমি নিম্নলিখিত পরামর্শ:

import ast

def is_int(s):
    return isinstance(ast.literal_eval(s), int)

ডক্স থেকে :

একটি এক্সপ্রেশন নোড বা পাইথন আক্ষরিক বা ধারক প্রদর্শনযুক্ত একটি স্ট্রিং নিরাপদে মূল্যায়ন করুন। সরবরাহ করা স্ট্রিং বা নোডে কেবলমাত্র পাইথনের আক্ষরিক কাঠামোগুলি থাকতে পারে: স্ট্রিং, বাইটস, সংখ্যা, টিপলস, তালিকা, ডিক্টস, সেটস, বুলিয়ান এবং কিছুই নয়।

আমার মনে রাখা উচিত যে ValueErrorপাইথন আক্ষরিক গঠিত না এমন কোনও কিছুর বিরুদ্ধে ডাকলে এটি একটি ব্যতিক্রম বাড়িয়ে তুলবে । যেহেতু প্রশ্নটি চেষ্টা ছাড়াই / বাদ দিয়ে সমাধানের জন্য জিজ্ঞাসা করেছে, তার জন্য আমার কাছে একটি কোবায়শি-মারু ধরণের সমাধান রয়েছে:

from ast import literal_eval
from contextlib import suppress

def is_int(s):
    with suppress(ValueError):
        return isinstance(literal_eval(s), int)
    return False

¯ \: _ (ツ): _ / ¯

Answer 15

আমার একটি সম্ভাবনা রয়েছে যা মোটেও int ব্যবহার করে না এবং স্ট্রিং কোনও সংখ্যাকে উপস্থাপন না করে ব্যতিক্রম বাড়াতে হবে না

float(number)==float(number)//1

এটি এমন কোনও ধরণের স্ট্রিংয়ের জন্য কাজ করা উচিত যা ভাসমান গ্রহণ করে, ইতিবাচক, নেতিবাচক, ইঞ্জিনিয়ারিং স্বরলিপি ...

Answer 16

আমি অনুমান করি যে প্রশ্নটি গতির সাথে সম্পর্কিত কারণ চেষ্টা করার সময়টি / ব্যতীত একটি সময় পেনাল্টি রয়েছে:

 পরীক্ষার তথ্য

প্রথমত, আমি 200 টি স্ট্রিং, 100 ব্যর্থ স্ট্রিং এবং 100 সংখ্যাযুক্ত স্ট্রিংয়ের একটি তালিকা তৈরি করেছি।

from random import shuffle
numbers = [u'+1'] * 100
nonumbers = [u'1abc'] * 100
testlist = numbers + nonumbers
shuffle(testlist)
testlist = np.array(testlist)

 নপি সমাধান (কেবল অ্যারে এবং ইউনিকোড নিয়ে কাজ করে)

np.core.defchararray.isnumeric ইউনিকোড স্ট্রিং দিয়েও কাজ করতে পারে np.core.defchararray.isnumeric(u'+12')তবে এটি ফিরে আসে এবং অ্যারে হয়। সুতরাং, যদি আপনার হাজার হাজার রূপান্তর করতে হয় এবং ডেটা বা অ-সংখ্যাযুক্ত ডেটা হারিয়ে থাকে তবে এটি একটি ভাল সমাধান।

import numpy as np
%timeit np.core.defchararray.isnumeric(testlist)
10000 loops, best of 3: 27.9 µs per loop # 200 numbers per loop

চেষ্টা / ব্যতীত

def check_num(s):
  try:
    int(s)
    return True
  except:
    return False

def check_list(l):
  return [check_num(e) for e in l]

%timeit check_list(testlist)
1000 loops, best of 3: 217 µs per loop # 200 numbers per loop

দেখে মনে হচ্ছে নপি সমাধানটি আরও দ্রুত।

Answer 17

আপনি যদি কেবলমাত্র নিম্ন-এস্কিই অঙ্কগুলি গ্রহণ করতে চান তবে তা করার জন্য এখানে পরীক্ষা দেওয়া হচ্ছে:

পাইথন ৩.7++: (u.isdecimal() and u.isascii())

পাইথন <= 3.6: (u.isdecimal() and u == str(int(u)))

অন্যান্য উত্তরগুলি ব্যবহারের পরামর্শ দেয় .isdigit()বা .isdecimal()তবে এই দুটিতে কিছু উচ্চ-ইউনিকোড অক্ষর যেমন '٢'( u'\u0662') অন্তর্ভুক্ত:

u = u'\u0662'     # '٢'
u.isdigit()       # True
u.isdecimal()     # True
u.isascii()       # False (Python 3.7+ only)
u == str(int(u))  # False

Comments

এটি নেতিবাচক মান বা হোয়াইটস্পিড প্যাড মানগুলি হ্যান্ডেল করবে না, উভয়ই ঠিকঠাক দ্বারা পরিচালনা করা হয় int()।

— শ্যাডোর্যাঞ্জার

Answer 18

আহ .. এটি চেষ্টা করুন:

def int_check(a):
    if int(a) == a:
        return True
    else:
        return False

আপনি যদি কোনও সংখ্যাটি না দিয়ে স্ট্রিং না রাখেন তবে এটি কাজ করে।

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

a = 2
a.isdigit()

যদি আপনি a.isdigit () কল করেন তবে এটি সত্য হবে।

Comments

আমি মনে করি আপনার 2নির্ধারিত মানটির চারপাশে উদ্ধৃতিগুলি দরকার a।

— লুক উডওয়ার্ড

কেন এই শীর্ষ উত্তর নেই? এটি প্রশ্নের সঠিক উত্তর দেয়।

— ঘাসফড়িং

-1 প্রশ্ন: " চেষ্টা করুন / ব্যতীত কোনও স্ট্রিং কোনও প্রকারের প্রতিনিধিত্ব করে কিনা তা পরীক্ষা করে দেখুন?"

— @ কারোলাইন আলেক্সিউয়ের