మీరు పైథాన్‌లో సంఖ్యల స్ట్రింగ్‌ను సంఖ్యా విలువలుగా మార్చాలనుకుంటే, పూర్ణాంకాలకి మార్చడానికి int()ని మరియు ఫ్లోటింగ్ పాయింట్ నంబర్‌లుగా మార్చడానికి float()ని ఉపయోగించండి.
నమూనా కోడ్‌తో పాటు క్రిందివి ఇక్కడ వివరించబడ్డాయి.
- ప్రాథమిక వినియోగం
- సంఖ్యా స్ట్రింగ్‌లను పూర్ణాంకాలకి మార్చండి:
int() - సంఖ్యల స్ట్రింగ్‌ను ఫ్లోటింగ్ పాయింట్ నంబర్‌లుగా మార్చండి:
float()
- సంఖ్యా స్ట్రింగ్‌లను పూర్ణాంకాలకి మార్చండి:
- ప్రత్యేక వినియోగం
- బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ సంజ్ఞామానంలోని స్ట్రింగ్‌లను సంఖ్యలుగా మారుస్తుంది
- ఘాతాంక సంజ్ఞామానంలోని స్ట్రింగ్‌లను సంఖ్యా విలువలకు మారుస్తుంది
- పూర్తి వెడల్పు గల అరబిక్ సంఖ్యా స్ట్రింగ్‌లను సంఖ్యలుగా మార్చండి
- చైనీస్ అక్షరాల స్ట్రింగ్‌ను సంఖ్యలుగా మార్చండి
సంఖ్యా విలువను స్ట్రింగ్‌గా మార్చడానికి, str()ని ఉపయోగించండి.
మీరు సంఖ్యలు లేదా స్ట్రింగ్‌లను వివిధ ఫార్మాట్‌లకు మార్చాలనుకుంటే, ఫార్మాట్() ఫంక్షన్ లేదా స్ట్రింగ్ మెథడ్ str.format()ని ఉపయోగించండి. అప్పుడు మీరు 0-ఫిల్, బైనరీ, ఆక్టల్, హెక్సాడెసిమల్, ఎక్స్‌పోనెన్షియల్ నొటేషన్ మొదలైన వాటికి మార్చవచ్చు. వివరాల కోసం క్రింది కథనాన్ని చూడండి.
ఇది స్ట్రింగ్‌ల జాబితాను సంఖ్యల జాబితాగా కూడా మార్చగలదు. వివరాల కోసం క్రింది కథనాన్ని చూడండి.
- సంఖ్యా స్ట్రింగ్‌లను పూర్ణాంకాలకి మార్చండి:int()
- సంఖ్యల స్ట్రింగ్‌ను ఫ్లోటింగ్ పాయింట్ నంబర్‌లుగా మార్చండి:float()
- బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ సంజ్ఞామానంలోని స్ట్రింగ్‌లను సంఖ్యలుగా మారుస్తుంది
- ఘాతాంక సంజ్ఞామానంలోని స్ట్రింగ్‌లను సంఖ్యా విలువలకు మారుస్తుంది
- పూర్తి వెడల్పు గల అరబిక్ సంఖ్యా స్ట్రింగ్‌లను సంఖ్యలుగా మార్చండి
- చైనీస్ అక్షరాల స్ట్రింగ్‌ను సంఖ్యలుగా మార్చండి
సంఖ్యా స్ట్రింగ్‌లను పూర్ణాంకాలకి మార్చండి:int()
సంఖ్యల స్ట్రింగ్‌ను పూర్ణాంకాల రకం సంఖ్యలుగా మార్చడానికి మీరు int()ని ఉపయోగించవచ్చు.
print(int('100'))
print(type(int('100')))
# 100
# <class 'int'>
దశాంశ బిందువులతో సహా దశాంశాలు మరియు కామాలతో వేరు చేయబడిన స్ట్రింగ్‌లు ValueErrorకి దారితీస్తాయి.
# print(int('1.23'))
# ValueError: invalid literal for int() with base 10: '1.23'
# print(int('10,000'))
# ValueError: invalid literal for int() with base 10: '10,000'
రీప్లేస్() పద్ధతిని ఉపయోగించి కామాను తీసివేయడం (ఖాళీ స్ట్రింగ్‌తో భర్తీ చేయడం) ద్వారా కామా-డిలిమిటెడ్ స్ట్రింగ్‌లను మార్చవచ్చు.
print(int('10,000'.replace(',', '')))
# 10000
సంఖ్యల స్ట్రింగ్‌ను ఫ్లోటింగ్ పాయింట్ నంబర్‌లుగా మార్చండి:float()
సంఖ్యల స్ట్రింగ్‌ను ఫ్లోటింగ్ పాయింట్ నంబర్ రకానికి మార్చడానికి ఫ్లోట్()ని ఉపయోగించవచ్చు.
print(float('1.23'))
print(type(float('1.23')))
# 1.23
# <class 'float'>
పూర్ణాంకం భాగం విస్మరించబడిన స్ట్రింగ్‌లు పూర్ణాంక భాగాన్ని 0తో పూర్తి చేయడం ద్వారా మార్చబడతాయి.
print(float('.23'))
# 0.23
పూర్ణాంకాల స్ట్రింగ్‌లు కూడా ఫ్లోటింగ్ పాయింట్ నంబర్‌లుగా మార్చబడతాయి.
print(float('100'))
print(type(float('100')))
# 100.0
# <class 'float'>
బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ సంజ్ఞామానంలోని స్ట్రింగ్‌లను సంఖ్యలుగా మారుస్తుంది
ఒక రాడిక్స్‌ను int()కి రెండవ ఆర్గ్యుమెంట్‌గా పేర్కొన్నట్లయితే, స్ట్రింగ్‌ను బైనరీ, ఆక్టల్, హెక్సాడెసిమల్ మొదలైనవాటిగా పరిగణించడం ద్వారా పూర్ణాంకం పూర్ణాంకానికి మార్చవచ్చు.
print(int('100', 2))
print(int('100', 8))
print(int('100', 16))
# 4
# 64
# 256
మునుపటి ఉదాహరణలలో వలె, విస్మరించబడినట్లయితే, సంఖ్య దశాంశ సంఖ్యగా పరిగణించబడుతుంది.
print(int('100', 10))
print(int('100'))
# 100
# 100
రాడిక్స్ 0కి సెట్ చేయబడితే, మార్పిడి స్ట్రింగ్ ప్రిఫిక్స్‌పై ఆధారపడి ఉంటుంది. స్ట్రింగ్ ప్రిఫిక్స్‌ల కోసం దిగువన చూడండి.
0b0B
0o0O
0x0X
print(int('0b100', 0))
print(int('0o100', 0))
print(int('0x100', 0))
# 4
# 64
# 256
ఉపసర్గలు మరియు హెక్స్ అక్షరాలు పెద్ద అక్షరం లేదా చిన్న అక్షరం కావచ్చు.
print(int('FF', 16))
print(int('ff', 16))
# 255
# 255
print(int('0xFF', 0))
print(int('0XFF', 0))
print(int('0xff', 0))
print(int('0Xff', 0))
# 255
# 255
# 255
# 255
బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ సంఖ్యలు మరియు స్ట్రింగ్‌ల పరస్పర మార్పిడిపై సమాచారం కోసం క్రింది కథనాన్ని చూడండి.
- సంబంధిత:పైథాన్‌లో బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ సంఖ్యలు మరియు స్ట్రింగ్‌లను ఒకదానికొకటి మార్చండి
ఘాతాంక సంజ్ఞామానంలోని స్ట్రింగ్‌లను సంఖ్యా విలువలకు మారుస్తుంది
ఎక్స్‌పోనెన్షియల్ సంజ్ఞామానంలోని స్ట్రింగ్‌లను ఫ్లోట్()తో నేరుగా ఫ్లోట్ టైప్‌గా మార్చవచ్చు.
print(float('1.23e-4'))
print(type(float('1.23e-4')))
# 0.000123
# <class 'float'>
print(float('1.23e4'))
print(type(float('1.23e4')))
# 12300.0
# <class 'float'>
చిన్న అక్షరం e కూడా పెద్ద అక్షరం E కావచ్చు.
print(float('1.23E-4'))
# 0.000123
పూర్తి వెడల్పు గల అరబిక్ సంఖ్యా స్ట్రింగ్‌లను సంఖ్యలుగా మార్చండి
పూర్తి-వెడల్పు గల అరబిక్ సంఖ్యలను int() లేదా float() ద్వారా నేరుగా సంఖ్యలుగా మార్చవచ్చు.
print(int('１００'))
print(type(int('１００')))
# 100
# <class 'int'>
print(float('１００'))
print(type(float('１００')))
# 100.0
# <class 'float'>
అయితే, మైనస్ మరియు దశాంశ పీరియడ్‌లు వంటి చిహ్నాలు పూర్తి వెడల్పు అక్షరాలు అయితే, ValueError ఉత్పత్తి చేయబడుతుంది.
# print(float('ー１．２３'))
# ValueError: could not convert string to float: '１．２３'
సంఖ్యలు పూర్తి-వెడల్పు అక్షరాలు అయితే సమస్యలు లేకుండా మార్చబడతాయి, కానీ మైనస్ మరియు దశాంశ పాయింట్లు సగం వెడల్పు అక్షరాలు. రీప్లేస్() పద్ధతిని ఉపయోగించి పూర్తి-వెడల్పు చిహ్నాలను సగం-వెడల్పు గుర్తులతో భర్తీ చేయడం ద్వారా మార్పిడి సాధ్యమవుతుంది.
print(float('-１.２３'))
# -1.23
print(float('ー１．２３'.replace('ー', '-').replace('．', '.')))
# -1.23
చైనీస్ అక్షరాల స్ట్రింగ్‌ను సంఖ్యలుగా మార్చండి
యూనికోడెడేటా మాడ్యూల్‌లోని unicodedata.numeric() ఫంక్షన్‌ని ఒకే యూనికోడ్ చైనీస్ అక్షరాన్ని ఫ్లోటింగ్ పాయింట్ నంబర్ టైప్ నంబర్‌గా మార్చడానికి ఉపయోగించవచ్చు.
ఇది ఒక్క అక్షరం కాకపోతే, లోపం ఏర్పడుతుంది. అలాగే, సంఖ్యేతర అక్షరాలు దోషాన్ని కలిగిస్తాయి.
import unicodedata
print(unicodedata.numeric('五'))
print(type(unicodedata.numeric('五')))
# 5.0
# <class 'float'>
print(unicodedata.numeric('十'))
# 10.0
print(unicodedata.numeric('参'))
# 3.0
print(unicodedata.numeric('億'))
# 100000000.0
# print(unicodedata.numeric('五十'))
# TypeError: numeric() argument 1 must be a unicode character, not str
# print(unicodedata.numeric('漢'))
# ValueError: not a numeric character
