పైథాన్‌లో ఒక సంఖ్య పూర్ణాంకం లేదా దశాంశమా అని నిర్ణయించండి.
కింది సందర్భాలు నమూనా కోడ్‌లతో వివరించబడ్డాయి.
- సంఖ్య పూర్ణాంకం లేదా ఫ్లోటింగ్ పాయింట్ ఫ్లోట్ కాదా అని నిర్ణయిస్తుంది:
isinstance() - ఫ్లోట్ రకం సంఖ్య పూర్ణాంకం (0 దశాంశ స్థానాలు) కాదా అని నిర్ణయిస్తుంది:
float.is_integer() - సంఖ్య స్ట్రింగ్ పూర్ణాంకం కాదా అని నిర్ణయిస్తుంది
దశాంశ సంఖ్య యొక్క పూర్ణాంకం మరియు దశాంశ విలువలను పొందడానికి, క్రింది కథనాన్ని చూడండి.
స్ట్రింగ్ అనేది పూర్ణాంకం లేదా దశాంశమా అనేదాని కంటే సంఖ్యా (చైనీస్ సంఖ్యలు మొదలైనవాటితో సహా) కాదా అని నిర్ణయించే సమాచారం కోసం క్రింది కథనాన్ని చూడండి.
సంఖ్య పూర్ణాంకం లేదా ఫ్లోటింగ్ పాయింట్ రకాన్ని నిర్ధారిస్తుంది:isinstance()
అంతర్నిర్మిత ఫంక్షన్ రకం()తో వస్తువు యొక్క రకాన్ని పొందవచ్చు.
i = 100
f = 1.23
print(type(i))
print(type(f))
# <class 'int'>
# <class 'float'>
isinstance(object, type)
ఈ అంతర్నిర్మిత ఫంక్షన్ ఒక వస్తువు నిర్దిష్ట రకానికి చెందినదో కాదో నిర్ధారించడానికి ఉపయోగించవచ్చు. సంఖ్య పూర్ణాంకం లేదా ఫ్లోటింగ్ పాయింట్ రకం కాదా అని నిర్ణయించడానికి ఇది ఉపయోగించబడుతుంది.
print(isinstance(i, int))
# True
print(isinstance(i, float))
# False
print(isinstance(f, int))
# False
print(isinstance(f, float))
# True
ఈ సందర్భంలో, ఇది రకాన్ని మాత్రమే నిర్ణయిస్తుంది, కనుక ఇది ఫ్లోట్ రకం విలువ పూర్ణాంకం (0 దశాంశ బిందువుతో) కాదా అని నిర్ధారించదు.
f_i = 100.0
print(type(f_i))
# <class 'float'>
print(isinstance(f_i, int))
# False
print(isinstance(f_i, float))
# True
ఫ్లోట్ రకం సంఖ్య పూర్ణాంకం (0 దశాంశ స్థానాలు) కాదా అని నిర్ణయిస్తుంది:float.is_integer()
is_integer() పద్ధతి ఫ్లోట్ రకం కోసం అందించబడింది, ఇది విలువ పూర్ణాంకం అయితే నిజం మరియు లేకపోతే తప్పు అని చూపుతుంది.
f = 1.23
print(f.is_integer())
# False
f_i = 100.0
print(f_i.is_integer())
# True
ఉదాహరణకు, ఒక పూర్ణాంకం సంఖ్యకు ఒప్పు అనే ఫంక్షన్‌ని ఈ క్రింది విధంగా నిర్వచించవచ్చు, మరోవైపు, స్ట్రింగ్ రకం తప్పుగా ఉంటుంది.
def is_integer_num(n):
if isinstance(n, int):
return True
if isinstance(n, float):
return n.is_integer()
return False
print(is_integer_num(100))
# True
print(is_integer_num(1.23))
# False
print(is_integer_num(100.0))
# True
print(is_integer_num('100'))
# False
సంఖ్య స్ట్రింగ్ పూర్ణాంకం కాదా అని నిర్ణయిస్తుంది
పూర్ణాంకాల అంకెల స్ట్రింగ్ కూడా పూర్ణాంకం అని మీరు గుర్తించాలనుకుంటే, కింది విధులు సాధ్యమే.
ఫ్లోట్()తో ఫ్లోట్ టైప్‌గా మార్చగలిగే విలువల కోసం, ఫ్లోట్‌గా మార్చిన తర్వాత is_integer() పద్ధతి వర్తించబడుతుంది మరియు ఫలితం తిరిగి వస్తుంది.
def is_integer(n):
try:
float(n)
except ValueError:
return False
else:
return float(n).is_integer()
print(is_integer(100))
# True
print(is_integer(100.0))
# True
print(is_integer(1.23))
# False
print(is_integer('100'))
# True
print(is_integer('100.0'))
# True
print(is_integer('1.23'))
# False
print(is_integer('string'))
# False
తీగలను సంఖ్యలుగా మార్చడంపై వివరాల కోసం క్రింది కథనాన్ని చూడండి.
స్ట్రింగ్ అనేది సంఖ్యా (చైనీస్ సంఖ్యలు మొదలైనవాటితో సహా) కాదా అని నిర్ణయించే వివరాల కోసం క్రింది కథనాన్ని చూడండి.
