పైథాన్ స్ట్రింగ్ సంఖ్యా లేదా అక్షరమా అని నిర్ణయిస్తుంది మరియు తనిఖీ చేస్తుంది

స్ట్రింగ్ రకం సంఖ్యా లేదా అక్షరమా అని నిర్ధారించడానికి మరియు తనిఖీ చేయడానికి పైథాన్ అనేక స్ట్రింగ్ పద్ధతులను అందిస్తుంది.

• String Methods — Built-in Types — Python 3.10.4 Documentation

ప్రతి పద్ధతి నమూనా కోడ్‌తో వివరించబడింది.

• స్ట్రింగ్ దశాంశ అంకె కాదా అని నిర్ణయిస్తుంది:str.isdecimal()
• స్ట్రింగ్ ఒక సంఖ్య కాదా అని నిర్ణయించడం:str.isdigit()
• స్ట్రింగ్ అనేది సంఖ్యను సూచించే అక్షరమా కాదా అని నిర్ణయిస్తుంది:str.isnumeric()
• స్ట్రింగ్ అక్షరమా అని నిర్ణయిస్తుంది:str.isalpha()
• స్ట్రింగ్ ఆల్ఫాన్యూమరిక్ కాదా అని నిర్ణయించండి:str.isalnum()
• స్ట్రింగ్‌లు ASCII అక్షరాలు కాదా అని నిర్ణయిస్తుంది:str.isascii()
• ఖాళీ స్ట్రింగ్ యొక్క తీర్పు
• తీగలను సంఖ్యలుగా మార్చవచ్చో లేదో నిర్ణయించండి

isascii() కాకుండా ఇతర పద్ధతుల కోసం, ఖాళీ స్ట్రింగ్, క్రింది చిహ్నాలు మొదలైన వాటిని కలిగి ఉన్న స్ట్రింగ్ తప్పు.

• ,
• .
• -

-1.23, మొదలైనవి, సంఖ్యా విలువగా ఈ విభాగం చివరిలో వివరించబడింది.

అక్షర రకాలను మరింత సరళంగా గుర్తించడానికి మరియు సంబంధిత అక్షరాల రకాలను సంగ్రహించడానికి రెగ్యులర్ వ్యక్తీకరణలను ఉపయోగించవచ్చు.

కింది వాటిని ఎలా గుర్తించాలో మరింత సమాచారం కోసం క్రింది కథనాన్ని చూడండి

• సంఖ్యా స్ట్రింగ్ (str) ను సంఖ్యగా (int, float) ఎలా మార్చాలి
• అప్పర్ మరియు లోయర్ కేస్ ఎలా నిర్ణయించాలి

• సంబంధిత:పైథాన్‌లో సంఖ్యల స్ట్రింగ్‌ను సంఖ్యా విలువలుగా మార్చడం
• సంబంధిత:పైథాన్‌లో కేసును మార్చడానికి స్ట్రింగ్ పద్ధతుల జాబితా

స్ట్రింగ్ దశాంశ అంకె కాదా అని నిర్ణయిస్తుంది:str.isdecimal()

isdecimal()లో, అన్ని అక్షరాలు దశాంశ అంకెలు అయితే అది నిజం, అంటే యూనికోడ్ యొక్క Nd సాధారణ వర్గంలోని అక్షరాలు. ఇది పూర్తి వెడల్పు గల అరబిక్ అంకెలు మొదలైన వాటికి కూడా వర్తిస్తుంది.

• str.isdecimal() — Built-in Types — Python 3.10.4 Documentation

s = '1234567890'
print('s =', s)
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
# s = 1234567890
# isdecimal: True
# isdigit: True
# isnumeric: True

s = '１２３４５６７８９０'
print('s =', s)
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
# s = １２３４５６７８９０
# isdecimal: True
# isdigit: True
# isnumeric: True

అది మైనస్ గుర్తు లేదా పీరియడ్ వంటి చిహ్నాన్ని కలిగి ఉంటే, అది తప్పు. ఉదాహరణకు, మీరు ‘-1.23’ వంటి స్ట్రింగ్ సంఖ్యా విలువ అని నిర్ధారించాలనుకుంటే, మీరు మినహాయింపు నిర్వహణను ఉపయోగించవచ్చు. ఇది ఈ విభాగం చివరలో వివరించబడింది.

s = '-1.23'
print('s =', s)
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
# s = -1.23
# isdecimal: False
# isdigit: False
# isnumeric: False

స్ట్రింగ్ ఒక సంఖ్య కాదా అని నిర్ణయించడం:str.isdigit()

isdigit()లో, isdecimal()లో నిజమైన సంఖ్యలతో పాటు, Numeric_Type అనే యూనికోడ్ ఆస్తి విలువ అంకెలు లేదా దశాంశం ఉన్న సంఖ్యలు కూడా నిజమైనవి.

• str.isdigit() — Built-in Types — Python 3.10.4 Documentation

ఉదాహరణకు, ఒక చతురస్రాన్ని సూచించే సూపర్‌స్క్రిప్ట్ సంఖ్య isdecimal()లో తప్పు అయితే isdigit()లో నిజం

• చతురస్రాన్ని సూచించే సూపర్‌స్క్రిప్ట్ సంఖ్య
• ²
• \u00B2}’

s = '10\u00B2'
print('s =', s)
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
# s = 10²
# isdecimal: False
# isdigit: True
# isnumeric: True

స్ట్రింగ్ అనేది సంఖ్యను సూచించే అక్షరమా కాదా అని నిర్ణయిస్తుంది:str.isnumeric()

isnumeric()లో, isdigit()లో నిజమైన సంఖ్యలతో పాటు, యూనికోడ్ ప్రాపర్టీ విలువ Numeric_Type సంఖ్యాపరమైన సంఖ్యలు కూడా నిజమైనవి.

• str.isnumeric() — Built-in Types — Python 3.10.4 Documentation

భిన్నాలు, రోమన్ సంఖ్యలు మరియు చైనీస్ సంఖ్యలు కూడా నిజం.

s = '\u00BD'
print('s =', s)
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
# s = ½
# isdecimal: False
# isdigit: False
# isnumeric: True

s = '\u2166'
print('s =', s)
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
# s = Ⅶ
# isdecimal: False
# isdigit: False
# isnumeric: True

s = '一二三四五六七八九〇'
print('s =', s)
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
# s = 一二三四五六七八九〇
# isdecimal: False
# isdigit: False
# isnumeric: True

s = '壱億参阡萬'
print('s =', s)
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
# s = 壱億参阡萬
# isdecimal: False
# isdigit: False
# isnumeric: True

స్ట్రింగ్ అక్షరమా అని నిర్ణయిస్తుంది:str.isalpha()

isalpha()లో, కింది వాటిలో ఒకదానితో కూడిన యూనికోడ్ సాధారణ కేటగిరీ ఆస్తి నిజం.

• Lm
• Lt
• Lu
• Ll
• Lo

• str.isalpha() — Built-in Types — Python 3.10.4 Documentation

వర్ణమాల, చైనీస్ అక్షరాలు మొదలైనవి నిజమైనవి.

s = 'abc'
print('s =', s)
print('isalpha:', s.isalpha())
# s = abc
# isalpha: True

s = '漢字'
print('s =', s)
print('isalpha:', s.isalpha())
# s = 漢字
# isalpha: True

అరబిక్ సంఖ్యలు తప్పు, కానీ చైనీస్ సంఖ్యలు నిజం ఎందుకంటే అవి కూడా చైనీస్ అక్షరాలు; అయినప్పటికీ, చైనీస్ సంఖ్యలలో సున్నాలు తప్పు.

s = '1234567890'
print('s =', s)
print('isalpha:', s.isalpha())
# s = 1234567890
# isalpha: False

s = '１２３４５６７８９０'
print('s =', s)
print('isalpha:', s.isalpha())
# s = １２３４５６７８９０
# isalpha: False

s = '一二三四五六七八九'
print('s =', s)
print('isalpha:', s.isalpha())
# s = 一二三四五六七八九
# isalpha: True

s = '壱億参阡萬'
print('s =', s)
print('isalpha:', s.isalpha())
# s = 壱億参阡萬
# isalpha: True

s = '〇'
print('s =', s)
print('isalpha:', s.isalpha())
# s = 〇
# isalpha: False

రోమన్ సంఖ్యలు తప్పు.

s = '\u2166'
print('s =', s)
print('isalpha:', s.isalpha())
# s = Ⅶ
# isalpha: False

స్ట్రింగ్ ఆల్ఫాన్యూమరిక్ కాదా అని నిర్ణయించండి:str.isalnum()

isalnum()లో, ఇప్పటివరకు జాబితా చేయబడిన క్రింది పద్ధతుల్లో ప్రతి అక్షరం నిజమైతే అది నిజం.

• isdecimal()
• isdigit()
• isnumeric()
• isalpha()

• str.isalnum() — Built-in Types — Python 3.10.4 Documentation

ప్రతి అక్షరం ఒక్కొక్కటిగా మూల్యాంకనం చేయబడుతుంది, కాబట్టి అక్షరాలు మరియు సంఖ్యలను కలిగి ఉన్న స్ట్రింగ్ అన్ని ఇతర పద్ధతులలో తప్పుగా ఉన్నప్పటికీ isalnum()లో నిజం అవుతుంది.

s = 'abc123'
print('s =', s)
print('isalnum:', s.isalnum())
print('isalpha:', s.isalpha())
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
# s = abc123
# isalnum: True
# isalpha: False
# isdecimal: False
# isdigit: False
# isnumeric: False

స్ట్రింగ్‌లు ASCII అక్షరాలు కాదా అని నిర్ణయిస్తుంది:str.isascii()

పైథాన్ 3.7 isascii()ని జోడించింది. స్ట్రింగ్‌లోని అన్ని అక్షరాలు ASCII అక్షరాలు అయితే ఇది నిజం అని తిరిగి వస్తుంది.

• str.isascii() — Built-in Types — Python 3.10.4 Documentation
• ASCII – Wikipedia

సంఖ్యలు మరియు అక్షరాలతో పాటు, + మరియు – వంటి చిహ్నాలు కూడా నిజమైనవి.

s = 'abc123+-,.&'
print('s =', s)
print('isascii:', s.isascii())
print('isalnum:', s.isalnum())
# s = abc123+-,.&
# isascii: True
# isalnum: False

ASCII కాని హిరగానా మరియు ఇతర అక్షరాలు తప్పు.

s = 'あいうえお'
print('s =', s)
print('isascii:', s.isascii())
print('isalnum:', s.isalnum())
# s = あいうえお
# isascii: False
# isalnum: True

మనం తర్వాత చూడబోతున్నట్లుగా, ఇతర పద్ధతుల వలె కాకుండా, isascii() ఖాళీ స్ట్రింగ్‌కు కూడా నిజమైనదిగా చూపుతుంది.

ఖాళీ స్ట్రింగ్ యొక్క తీర్పు

ఖాళీ స్ట్రింగ్ isascii()కి నిజం మరియు ఇతర పద్ధతులకు తప్పు.

s = ''
print('s =', s)
print('isalnum:', s.isalnum())
print('isalpha:', s.isalpha())
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
print('isascii:', s.isascii())
# s = 
# isalnum: False
# isalpha: False
# isdecimal: False
# isdigit: False
# isnumeric: False
# isascii: True

ఇది ఖాళీ స్ట్రింగ్ కాదా అని నిర్ధారించడానికి bool()ని ఉపయోగించండి. రిటర్న్ విలువ ఖాళీ స్ట్రింగ్‌కు తప్పు మరియు లేకపోతే ఒప్పు.

print(bool(''))
# False

print(bool('abc123'))
# True

తీగలను సంఖ్యలుగా మార్చవచ్చో లేదో నిర్ణయించండి

ప్రతికూల లేదా పాక్షిక విలువ స్ట్రింగ్‌లు పీరియడ్‌లు లేదా మైనస్ సంకేతాలను కలిగి ఉంటాయి. కాబట్టి, isascii() మినహా అన్ని పద్ధతులకు ఫలితం తప్పు.

isascii()కి సరైనది అయినప్పటికీ, స్ట్రింగ్‌ను సంఖ్యా విలువగా మార్చవచ్చో లేదో నిర్ణయించడానికి ఇది తగినది కాదు, ఎందుకంటే అది ఇతర చిహ్నాలు లేదా అక్షరమాల అక్షరాలను కలిగి ఉన్నప్పటికీ అది నిజం.

s = '-1.23'
print('s =', s)
print('isalnum:', s.isalnum())
print('isalpha:', s.isalpha())
print('isdecimal:', s.isdecimal())
print('isdigit:', s.isdigit())
print('isnumeric:', s.isnumeric())
print('isascii:', s.isascii())
# s = -1.23
# isalnum: False
# isalpha: False
# isdecimal: False
# isdigit: False
# isnumeric: False
# isascii: True

ఫ్లోట్()తో స్ట్రింగ్‌లను ఫ్లోటింగ్ పాయింట్ నంబర్‌లుగా మార్చవచ్చు. మార్చలేని స్ట్రింగ్‌ల కోసం ఎర్రర్ ఏర్పడింది.

• సంబంధిత:నంబర్ స్ట్రింగ్ స్ట్రింగ్‌ను నంబర్ పూర్ణాంకానికి మార్చండి, పైథాన్‌లో ఫ్లోట్ చేయండి

print(float('-1.23'))
# -1.23

print(type(float('-1.23')))
# <class 'float'>

# print(float('abc'))
# ValueError: could not convert string to float: 'abc'

మినహాయింపు నిర్వహణతో, స్ట్రింగ్‌ను ఫ్లోట్()తో మార్చగలిగినప్పుడు ట్రూని అందించే ఫంక్షన్‌ని నిర్వచించవచ్చు.

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

print(is_num('123'))
# True

print(is_num('-1.23'))
# True

print(is_num('+1.23e10'))
# True

print(is_num('abc'))
# False

print(is_num('10,000,000'))
# False

కామాతో వేరు చేయబడిన సంఖ్య కూడా నిజమని మీరు నిర్ధారించాలనుకుంటే, కామాను తీసివేయడానికి రీప్లేస్()ని ఉపయోగించండి (దీనిని ఖాళీ స్ట్రింగ్‌తో భర్తీ చేయండి).

def is_num_delimiter(s):
    try:
        float(s.replace(',', ''))
    except ValueError:
        return False
    else:
        return True

print(is_num_delimiter('10,000,000'))
# True

మీరు వైట్‌స్పేస్ డీలిమిటేషన్‌కు మద్దతు ఇవ్వాలనుకుంటే, మీరు రీప్లేస్()ని మరింత ఉపయోగించవచ్చు.

def is_num_delimiter2(s):
    try:
        float(s.replace(',', '').replace(' ', ''))
    except ValueError:
        return False
    else:
        return True

print(is_num_delimiter2('10,000,000'))
# True

print(is_num_delimiter2('10 000 000'))
# True