కింది విషయాలు, నమూనా కోడ్‌తో పాటు, పైథాన్‌లో స్ట్రింగ్‌ల (str) జాబితాలను (శ్రేణులు) మరియు సంఖ్యల జాబితాలను (int, ఫ్లోట్) ఒకదానికొకటి ఎలా మార్చాలో వివరిస్తాయి.
- సంఖ్యల జాబితాను స్ట్రింగ్‌ల జాబితాగా మార్చండి
- సంఖ్యను దశాంశ స్ట్రింగ్‌గా మార్చండి
- సంఖ్యా విలువలను బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ స్ట్రింగ్‌లుగా మారుస్తుంది
- ఘాతాంక సంజ్ఞామానంలో సంఖ్యా విలువను స్ట్రింగ్‌గా మారుస్తుంది
- స్ట్రింగ్‌ల జాబితాను సంఖ్యల జాబితాగా మార్చండి
- దశాంశ స్ట్రింగ్‌ను సంఖ్యకు మార్చండి
- బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ స్ట్రింగ్‌లను సంఖ్యలుగా మారుస్తుంది
- ఘాతాంక సంజ్ఞామానంలోని స్ట్రింగ్‌లను సంఖ్యా విలువలకు మారుస్తుంది
- సంఖ్యలుగా మార్చగలిగే స్ట్రింగ్‌లను మాత్రమే మార్చండి
జాబితా నుండి కొత్త జాబితాను రూపొందిస్తున్నప్పుడు, లూప్‌ల కంటే జాబితా కాంప్రహెన్షన్‌లు వ్రాయడం సులభం. ఈ కథనంలోని నమూనా కోడ్ కూడా జాబితా గ్రహణాలను ఉపయోగిస్తుంది. జాబితా గ్రహణాల వివరాల కోసం, క్రింది కథనాన్ని చూడండి.
జాబితాలు వివిధ రకాల డేటాను నిల్వ చేయగలవని మరియు శ్రేణుల నుండి ఖచ్చితంగా భిన్నంగా ఉంటాయని గమనించండి. కింది సందర్భాలలో అర్రే (ప్రామాణిక లైబ్రరీ) లేదా NumPyని ఉపయోగించండి.
- నేను మెమరీ పరిమాణం మరియు మెమరీ చిరునామాలు అవసరమయ్యే ప్రక్రియలను నిర్వహించాలనుకుంటున్నాను.
- పెద్ద డేటా సెట్లు మొదలైన వాటి సంఖ్యాపరమైన ప్రాసెసింగ్ కోసం శ్రేణులను నిర్వహించాలనుకుంటున్నారు.
సంఖ్యల జాబితాను స్ట్రింగ్‌ల జాబితాగా మార్చండి
సంఖ్యను దశాంశ స్ట్రింగ్‌గా మార్చండి
సంఖ్య నుండి స్ట్రింగ్‌కు మార్చడానికి str()ని ఉపయోగించండి.
పైథాన్‌లో, సంఖ్యలను ఎక్స్‌పోనెన్షియల్, హెక్సాడెసిమల్ మరియు బైనరీ (హెక్సాడెసిమల్ మరియు బైనరీ సంజ్ఞామానం) సహా వివిధ ఫార్మాట్‌లలో వ్యక్తీకరించవచ్చు. str() మార్పిడి సాధారణ దశాంశ సంజ్ఞామానంలో స్ట్రింగ్‌కు దారి తీస్తుంది.
అంకెల సంఖ్యపై ఆధారపడి, ఘాతాంక సంజ్ఞామానం స్వయంచాలకంగా ఉపయోగించబడుతుంది.
l_n = [-0.5, 0, 1.0, 100, 1.2e-2, 0xff, 0b11]
l_n_str = [str(n) for n in l_n]
print(l_n_str)
# ['-0.5', '0', '1.0', '100', '0.012', '255', '3']
సంఖ్యా విలువలను బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ స్ట్రింగ్‌లుగా మారుస్తుంది
బైనరీ, ఆక్టల్ లేదా హెక్సాడెసిమల్ (బైనరీ సంజ్ఞామానం, అష్టాంశ సంజ్ఞామానం లేదా హెక్సాడెసిమల్ సంజ్ఞామానం) స్ట్రింగ్‌లకు మార్చడానికి, క్రింది పద్ధతులు అందుబాటులో ఉన్నాయి.
bin()oct()hex()format()str.format()
ఫార్మాట్() ఫంక్షన్‌తో, సున్నాలను పూరించడం మరియు అంకెలను సర్దుబాటు చేయడం సాధ్యపడుతుంది.
l_i = [0, 64, 128, 192, 256]
l_i_hex1 = [hex(i) for i in l_i]
print(l_i_hex1)
# ['0x0', '0x40', '0x80', '0xc0', '0x100']
l_i_hex2 = [format(i, '04x') for i in l_i]
print(l_i_hex2)
# ['0000', '0040', '0080', '00c0', '0100']
l_i_hex3 = [format(i, '#06x') for i in l_i]
print(l_i_hex3)
# ['0x0000', '0x0040', '0x0080', '0x00c0', '0x0100']
ఘాతాంక సంజ్ఞామానంలో సంఖ్యా విలువను స్ట్రింగ్‌గా మారుస్తుంది
పైన పేర్కొన్నట్లుగా, అంకెల సంఖ్యను బట్టి కొన్ని సందర్భాలు స్వయంచాలకంగా ఘాతాంక సంజ్ఞామానంలో ఉండవచ్చు. అయినప్పటికీ, ఘాతాంక సంజ్ఞామానంలో ఎల్లప్పుడూ స్ట్రింగ్‌గా మార్చడానికి, కింది వాటిలో ఒకదాన్ని ఉపయోగించండి
format()str.format()
ఫార్మాట్() ఫంక్షన్ మరియు స్ట్రింగ్ మెథడ్ str.format() గురించి మరింత సమాచారం కోసం క్రింది కథనాన్ని చూడండి.
మాంటిస్సా భాగం యొక్క అంకెల సంఖ్యను పేర్కొనవచ్చు. పెద్ద అక్షరం Eని ఆర్గ్యుమెంట్‌గా ఉపయోగించినట్లయితే, అవుట్‌పుట్ స్ట్రింగ్ కూడా పెద్ద అక్షరం E.
l_f = [0.0001, 123.456, 123400000]
l_f_e1 = [format(f, 'e') for f in l_f]
print(l_f_e1)
# ['1.000000e-04', '1.234560e+02', '1.234000e+08']
l_f_e2 = [format(f, '.3E') for f in l_f]
print(l_f_e2)
# ['1.000E-04', '1.235E+02', '1.234E+08']
స్ట్రింగ్‌ల జాబితాను సంఖ్యల జాబితాగా మార్చండి
దశాంశ స్ట్రింగ్‌ను సంఖ్యకు మార్చండి
స్ట్రింగ్ నుండి సంఖ్యకు మార్చడానికి int() లేదా float() ఉపయోగించండి.
int() అనేది పూర్ణాంకంగా మార్చడం, మరియు float() అనేది ఫ్లోటింగ్ పాయింట్ నంబర్‌గా మార్చడం.
ఫ్లోట్()లో, విస్మరించబడిన పూర్ణాంకాల భాగానికి సంబంధించిన స్ట్రింగ్‌లు పూర్ణాంక భాగానికి 0తో అనుబంధించబడతాయి.
l_si = ['-10', '0', '100']
l_si_i = [int(s) for s in l_si]
print(l_si_i)
# [-10, 0, 100]
l_sf = ['.123', '1.23', '123']
l_sf_f = [float(s) for s in l_sf]
print(l_sf_f)
# [0.123, 1.23, 123.0]
బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ స్ట్రింగ్‌లను సంఖ్యలుగా మారుస్తుంది
int() యొక్క రెండవ ఆర్గ్యుమెంట్ రాడిక్స్ కావచ్చు: బైనరీకి 2, అష్టాంశానికి 8 మరియు హెక్సాడెసిమల్‌కు 16, స్ట్రింగ్‌ను సంఖ్యగా మారుస్తుంది.
0 పేర్కొనబడితే, కింది ప్రతి ఒక్కటి పూర్ణాంకానికి మార్చబడుతుంది.
0b- బైనరీ అంకెలు
0o- ఆక్టల్
0x- హెక్సాడెసిమల్
- సంబంధిత:పైథాన్‌లో బైనరీ, ఆక్టల్ మరియు హెక్సాడెసిమల్ సంఖ్యలు మరియు స్ట్రింగ్‌లను ఒకదానికొకటి మార్చండి
l_sb = ['0011', '0101', '1111']
l_sb_i = [int(s, 2) for s in l_sb]
print(l_sb_i)
# [3, 5, 15]
l_sbox = ['100', '0b100', '0o77', '0xff']
l_sbox_i = [int(s, 0) for s in l_sbox]
print(l_sbox_i)
# [100, 4, 63, 255]
ఘాతాంక సంజ్ఞామానంలోని స్ట్రింగ్‌లను సంఖ్యా విలువలకు మారుస్తుంది
ఎక్స్‌పోనెన్షియల్ నొటేషన్‌లోని స్ట్రింగ్‌లను ప్రత్యేక స్పెసిఫికేషన్ అవసరం లేకుండా నేరుగా ఫ్లోట్()తో మార్చవచ్చు.
l_se = ['1.23e3', '0.123e-1', '123']
l_se_f = [float(s) for s in l_se]
print(l_se_f)
# [1230.0, 0.0123, 123.0]
సంఖ్యలుగా మార్చగలిగే స్ట్రింగ్‌లను మాత్రమే మార్చండి
సంఖ్యగా మార్చలేని స్ట్రింగ్‌ను int() లేదా float()కి మార్చడం వలన ValueError ఏర్పడుతుంది.
ఎర్రర్‌పై తప్పుని అందించే కొత్త ఫంక్షన్ నిర్వచించబడితే, మార్చగలిగే మూలకాలు మాత్రమే సంఖ్యలుగా మార్చబడతాయి మరియు జాబితా యొక్క మూలకాలుగా మారతాయి.
def is_int(s):
try:
int(s)
except ValueError:
return False
else:
return True
def is_float(s):
try:
float(s)
except ValueError:
return False
else:
return True
l_multi = ['-100', '100', '1.23', '1.23e2', 'one']
l_multi_i = [int(s) for s in l_multi if is_int(s)]
print(l_multi_i)
# [-100, 100]
l_multi_f = [float(s) for s in l_multi if is_float(s)]
print(l_multi_f)
# [-100.0, 100.0, 1.23, 123.0]
