హెక్సాడెసిమల్ 16 యొక్క ఆధారాన్ని కలిగి ఉంది మరియు 0x ఉపసర్గను ఉపయోగించి హెక్సాడెసిమల్ ఫార్మాట్‌లో స్ట్రింగ్‌ని ప్రాతినిధ్యం వహిస్తాము.
మేము ఈ క్రింది పద్ధతులను ఉపయోగించి స్ట్రింగ్‌ను హెక్సాడెసిమల్‌గా మార్చవచ్చు:
- హెక్స్ (ఎన్) పద్ధతిని ఉపయోగించడం
- ఎన్కోడ్ () పద్ధతిని ఉపయోగించడం
- Literal_eval () పద్ధతిని ఉపయోగించడం
విధానం 1: హెక్స్ () ఉపయోగించి
మేము హెక్స్ () పద్ధతిని ఉపయోగించి స్ట్రింగ్‌ను హెక్సాడెసిమల్‌గా మార్చవచ్చు. హెక్స్ () పద్ధతి పూర్ణాంక రూపంలో పారామీటర్‌ని అంగీకరిస్తుంది, అందుకోసం ముందుగా స్ట్రింగ్‌ని పూర్ణాంకానికి మార్చాలి, ఆపై ఆ విలువను హెక్స్ () పద్ధతికి దిగువ చూపిన విధంగా పాస్ చేయాలి:
ఉదాహరణ: string_to_hex.py
| 1 2 3 4 5 6 7 8 9 10 పదకొండు 12 13 14 పదిహేను 16 17 18 19 ఇరవై ఇరవై ఒకటి | # string_to_hex.py p = '245FC' # str ని int () కి బేస్ 16 int గా మార్చడానికి పాస్ చేయండి బేస్ 16INT= int(p, 16) # మార్చబడిన స్ట్రింగ్‌ను బేస్ 16 హెక్సాడెసిమల్ int విలువకు ముద్రించండి ముద్రణ('విలువ',బేస్ 16INT) ముద్రణ('విలువ',రకం(బేస్ 16INT)) హెక్స్_ విలువ= హెక్స్(బేస్ 16INT) ముద్రణ(హెక్స్_ విలువ) # విలువ రకాన్ని నొక్కడం ముద్రణ(రకం(హెక్స్_ విలువ)) |
అవుట్‌పుట్:
| 1 2 3 4 5 6 7 | విలువ148988 విలువ<తరగతి 'int'> 0x245fc <తరగతి 'str'> |
లైన్ 3: మేము డెమో కోసం స్ట్రింగ్‌ను సృష్టించాము.
లైన్ 6: మేము ఆ స్ట్రింగ్‌ను int () పద్ధతికి బేస్ 16 తో పాస్ చేస్తాము. ఇప్పుడు, ఈ int () పద్ధతి స్ట్రింగ్‌ను హెక్సాడెసిమల్ పూర్ణాంక విలువకు మారుస్తుంది.
లైన్ 9: స్ట్రింగ్‌ను పూర్ణాంక హెక్సాడెసిమల్‌గా మార్చిన తర్వాత మనకు లభించే విలువను మేము ప్రింట్ చేస్తాము.
లైన్ 10: స్ట్రింగ్ ఇప్పుడు పూర్ణాంక రూపంలో ఉందని నిర్ధారించడానికి మేము విలువ రకాన్ని కూడా ముద్రించాము.
పంక్తి 12: అంతర్నిర్మిత హెక్స్ (ఎన్) పద్ధతి పూర్ణాంక విలువను అంగీకరిస్తుందని, పూర్ణాంకాన్ని హెక్సాడెసిమల్ స్ట్రింగ్‌గా మారుస్తుందని మాకు తెలుసు. అందుకే మేము స్ట్రింగ్‌ను హెక్స్ () పద్ధతిలో పాస్ చేయడానికి పూర్ణాంకానికి మార్చాలి. మేము ఆ బేస్ 16INT విలువను హెక్స్ () పద్ధతికి పంపించాము మరియు హెక్సా_వాల్యూ, స్ట్రింగ్ హెక్సాడెసిమల్ పొందాము.
13 వ పంక్తి: మేము మార్చబడిన హెక్సాడెసిమల్ విలువను ప్రింట్ చేస్తాము.
లైన్ 16: మేము మార్చబడిన హెక్సాడెసిమల్ విలువ రకాన్ని ప్రింట్ చేస్తాము, ఇది అవుట్‌పుట్‌లో ఇది స్ట్రింగ్ రకం అని చూపిస్తుంది.
కాబట్టి, ఇప్పుడు మేము స్ట్రింగ్‌ను హెక్సాడెసిమల్ విలువగా మార్చాము.
విధానం 2: ఎన్కోడ్ () ఉపయోగించి స్ట్రింగ్‌ను హెక్సాడెసిమల్‌గా మార్చండి
మేము సాధారణ స్ట్రింగ్‌ను హెక్సాడెసిమల్ అక్షరం లేని హెక్సాడెసిమల్ స్ట్రింగ్‌గా కూడా మార్చవచ్చు. దాని కోసం, మేము పద్ధతి ఎన్కోడ్ () ను ఉపయోగించి స్ట్రింగ్‌ను బైట్‌గా మార్చాలి, ఆపై దిగువ చూపిన విధంగా స్ట్రింగ్‌ను హెక్సాడెసిమల్‌గా మార్చవచ్చు:
| 1 2 3 4 5 6 7 8 9 10 పదకొండు 12 13 14 పదిహేను 16 17 18 19 ఇరవై ఇరవై ఒకటి 22 2. 3 24 25 | # string_to_hex_utf8.py # స్ట్రింగ్‌ను బైట్‌లుగా మార్చండి p= 'linuxhint'.ఎన్కోడ్('utf-8') # మార్చబడిన స్ట్రింగ్‌ను బైట్‌లుగా ముద్రించండి ముద్రణ(p) # స్ట్రింగ్ బైట్‌లను హెక్సాడెసిమల్ స్ట్రింగ్‌గా మార్చండి hex_str= p.హెక్స్() # మార్చబడిన హెక్సాడెసిమల్ విలువ రకాన్ని ముద్రించండి ముద్రణ(రకం(hex_str)) |
అవుట్‌పుట్:
| 1 2 3 | బి'linuxhint' <తరగతి 'str'> |
లైన్ 4 నుండి 7: మేము హెక్సాడెసిమల్ పాత్ర లేని స్ట్రింగ్‌ను సృష్టించాము. ఆపై ఎన్కోడ్ () పద్ధతిని ఉపయోగించి ఆ తీగలను బైట్‌లుగా మార్చండి. ఆపై, మేము ఆ బైట్‌లను ప్రింట్ చేస్తాము, దీనిని మనం అవుట్‌పుట్ లైన్ నంబర్ 1 లో చూడవచ్చు.
లైన్ 10 నుండి 13: మేము డాట్ ఆపరేటర్‌ను ఉపయోగించి హెక్స్ () పద్ధతిని పిలుస్తాము, ఇప్పుడు బైట్‌లు మనకు అవసరమైన హెక్సాడెసిమల్ స్ట్రింగ్ విలువగా మార్చబడతాయి. ఫలిత స్ట్రింగ్ రకాన్ని నిర్ధారించడానికి, మేము కేవలం లైన్ నంబర్ 13 ను ముద్రించాము మరియు అవుట్‌పుట్ అది స్ట్రింగ్ హెక్సాడెసిమల్ రకంలో ఉన్నట్లు చూపుతుంది.
పద్ధతి 3. ast.literal_eval () పద్ధతిని ఉపయోగించడం
ఆస్ట్ లైబ్రరీ పద్ధతి Literal_eval ని ఉపయోగించి స్ట్రింగ్‌ను పూర్ణాంకానికి కూడా మార్చగలము. ఈ పద్ధతి స్ట్రింగ్‌ను హెక్సాడెసిమల్ స్ట్రింగ్‌గా మార్చడానికి హెక్స్ () పద్ధతిని ఉపయోగించడానికి స్ట్రింగ్‌ను పూర్ణాంకానికి మారుస్తుంది. కానీ ఈ పద్ధతి 0x ఉపసర్గ అక్షరాలను మాత్రమే అంగీకరిస్తుంది.
| 1 2 3 4 5 6 7 8 9 10 పదకొండు 12 13 14 పదిహేను 16 17 18 19 ఇరవై ఇరవై ఒకటి 22 2. 3 24 25 26 27 28 29 30 31 32 33 | # string_to_hex_utf8.py నుండిశాఖదిగుమతిసాహిత్య_సంబంధము p = '0xAAA' # స్ట్రింగ్‌ను పూర్ణాంకానికి మార్చండి కన్వర్ట్_స్టార్=సాహిత్య_సంబంధము(p) # కన్వర్ట్_స్టెర్ విలువ మరియు రకాన్ని ముద్రించండి ముద్రణ(కన్వర్ట్_స్టార్) ముద్రణ('రకం', రకం(కన్వర్ట్_స్టార్)) # కన్వర్ట్_స్ట్రర్‌ను హెక్స్ () పద్ధతికి పాస్ చేయండి హెక్స్_ విలువ= హెక్స్(కన్వర్ట్_స్టార్) ముద్రణ(హెక్స్_ విలువ) # విలువ రకాన్ని నొక్కడం ముద్రణ(రకం(హెక్స్_ విలువ)) |
అవుట్‌పుట్:
| 1 2 3 4 5 6 7 | 2730 రకం <తరగతి 'int'> 0xaaa <తరగతి 'str'> |
లైన్ 2 నుండి 10: మేము astral లైబ్రరీ నుండి Literal_eval () పద్ధతిని దిగుమతి చేసుకుంటాము. అప్పుడు మేము 0x ఉపసర్గతో స్ట్రింగ్‌ని సృష్టిస్తాము. అప్పుడు మేము ఆ స్ట్రింగ్‌ను Literal_eval () పద్ధతికి పంపి, దాన్ని పూర్ణాంకానికి మార్చాము. అవుట్‌పుట్ పూర్ణాంక రూపంలో ఉందని నిర్ధారించడానికి, మేము దానిని లైన్ నంబర్ 9 లో ప్రింట్ చేస్తాము. అవుట్‌పుట్ రకాన్ని కూడా మేము ప్రింట్ చేస్తాము, అది పూర్ణాంకం అని చూపిస్తుంది.
లైన్ 13 నుండి 17: పూర్ణాంకాన్ని హెక్సాడెసిమల్ స్ట్రింగ్‌గా మార్చే పూర్ణాంక విలువను అంగీకరించే అంతర్నిర్మిత హెక్స్ (ఎన్) పద్ధతి మాకు తెలుసు. అందుకే మేము స్ట్రింగ్‌ను హెక్స్ () పద్ధతిలో పాస్ చేయడానికి పూర్ణాంకానికి మార్చాలి. మేము ఆ convert_str (పూర్ణాంకం) విలువను హెక్స్ () పద్ధతికి పంపించాము మరియు హెక్స్_వాల్యూ, స్ట్రింగ్ హెక్సాడెసిమల్ పొందాము. మేము మార్చబడిన హెక్సాడెసిమల్ విలువను ప్రింట్ చేస్తాము. మేము మార్చబడిన హెక్సాడెసిమల్ విలువ యొక్క రకాన్ని కూడా ప్రింట్ చేస్తాము, ఇది స్ట్రింగ్ హెక్సాడెసిమల్ రకం అని చూపిస్తుంది.
లోపం మినహాయింపు (TypeError):
స్ట్రింగ్‌ను హెక్సాడెసిమల్ స్ట్రింగ్‌గా మార్చేటప్పుడు కొన్నిసార్లు మనకు లోపాలు వస్తాయి. దాని వెనుక కారణం హెక్స్ () పద్ధతి మాత్రమే పూర్ణాంక విలువను పరామితిగా అంగీకరిస్తుంది.
| 1 2 3 4 5 6 7 | స్ట్రింగ్_హెక్స్= '0xFF' hex_output= హెక్స్(స్ట్రింగ్_హెక్స్) ముద్రణ(hex_output) |
అవుట్‌పుట్:
| 1 | టైప్ ఎరర్:'str' వస్తువుఅర్థం చేసుకోలేముగాఒక పూర్ణాంకం |
ముగింపు:
కాబట్టి, స్ట్రింగ్‌ను హెక్సాడెసిమల్ చిన్న అక్షర స్ట్రింగ్‌గా మార్చడానికి మేము వివిధ పద్ధతులను చూశాము. హెక్స్ () పద్ధతి చాలా సులభమైన ఉపయోగం కారణంగా బాగా ప్రాచుర్యం పొందింది. కానీ కొన్నిసార్లు, మేము 0x ఉపసర్గను ఉపయోగించకుండా స్ట్రింగ్‌ని మార్చాలనుకుంటున్నాము, కాబట్టి ఆ సందర్భంలో, మనం ఇప్పటికే వ్యాసంలో చూసినట్లుగా, బైట్‌ల ఎన్కోడ్ () పద్ధతిని ఉపయోగించవచ్చు.
ఈ వ్యాసం యొక్క కోడ్ క్రింది గితుబ్ లింక్‌లో అందుబాటులో ఉంది: