బైటెర్రే సింటాక్స్ () పద్ధతి
బైటెర్రే ([సమాచార మూలం[,ఎన్కోడింగ్[,లోపాలు]]])ఈ పద్ధతి యొక్క మూడు వాదనలు ఐచ్ఛికం. బైట్ల జాబితాను ప్రారంభించడానికి మొదటి వాదన ఉపయోగించబడుతుంది. మొదటి వాదన స్ట్రింగ్ అయితే, రెండవ ఆర్గ్యుమెంట్ ఎన్కోడింగ్ కోసం ఉపయోగించబడుతుంది. చివరగా, ఎన్కోడింగ్ విఫలమైతే మూడవ వాదన దోషాన్ని ప్రదర్శించడానికి ఉపయోగించబడుతుంది.
బైట్ల సింటాక్స్ () పద్ధతి
బైట్లు ([సమాచార మూలం[,ఎన్కోడింగ్[,లోపాలు]]])యొక్క అన్ని వాదనలు బైట్లు () ఫంక్షన్ ఐచ్ఛికం, వంటిది బైటెర్రే () పద్ధతి ఈ వాదనల విధులు కూడా ఒకటే బైటెర్రే () పద్ధతి, పైన పేర్కొన్నది.
మార్చే పద్ధతి బైటెర్రే కు బైట్లు పైథాన్‌లో ఈ ప్రక్రియను బాగా అర్థం చేసుకోవడానికి కొన్ని సాధారణ ఉదాహరణలను ఉపయోగించి క్రింద చూపబడింది.
ఉదాహరణ 1: జాబితా డేటాను బైటెర్రే నుండి బైట్‌లుగా మార్చండి
బైటెర్రే () ఫంక్షన్‌లో ఒక ఆర్గ్యుమెంట్ మాత్రమే ఉన్నప్పుడు, ఆర్గ్యుమెంట్ విలువ డిక్షనరీ డేటా లేదా వేరియబుల్ అవుతుంది. కింది ఉదాహరణ ఒక డిక్షనరీ ఆబ్జెక్ట్‌ను బైటెర్రే ఆబ్జెక్ట్‌గా ఎలా మార్చవచ్చో మరియు బైట్రే ఆబ్జెక్ట్‌ను బైట్ ఆబ్జెక్ట్‌గా ఎలా మార్చవచ్చో చూపిస్తుంది. తరువాత, ASCII కోడ్‌ల అనువాద పట్టిక విలువలను ప్రదర్శించడానికి మొదటి లూప్ ఉపయోగించబడుతుంది మరియు రెండవది లూప్ సంబంధిత ASCII కోడ్‌ల అక్షరాలను ప్రదర్శించడానికి ఉపయోగించబడుతుంది.
#!/usr/bin/env పైథాన్ 3
# జాబితాను నిర్వచించండి
జాబితా డేటా= [72, 69, 76, 76, 79]
# జాబితాలోని కంటెంట్‌ను ముద్రించండి
ముద్రణ(' nనిఘంటువు విలువలు: n',జాబితా డేటా)
# జాబితాతో బైటెర్రే వస్తువును ప్రారంభించండి
byteArrayObject= బైటెర్రే(జాబితా డేటా)
# బైటెర్రే ఆబ్జెక్ట్ విలువను ముద్రించండి
ముద్రణ(' nబైటెర్రే () పద్ధతి యొక్క అవుట్‌పుట్: n',byteArrayObject)
# బైటెర్రే వస్తువును బైట్ల వస్తువుగా మార్చండి
బైట్ ఆబ్జెక్ట్= బైట్లు(byteArrayObject)
# బైట్ల వస్తువు విలువను ముద్రించండి
ముద్రణ(' nబైట్ల () పద్ధతి యొక్క అవుట్‌పుట్: n',బైట్ ఆబ్జెక్ట్)
ముద్రణ(' nబైట్ల ASCII విలువలు ')
# లూప్‌ని ఉపయోగించి బైట్ల వస్తువును గుర్తించండి
కోసంగంటలులోబైట్ ఆబ్జెక్ట్:
ముద్రణ(గంటలు,'',ముగింపు='')
ముద్రణ(' nబైట్ల స్ట్రింగ్ విలువలు ')
# లూప్‌ని ఉపయోగించి బైట్ల వస్తువును గుర్తించండి
కోసంగంటలులోబైట్ ఆబ్జెక్ట్:
ముద్రణ(chr(గంటలు),'',ముగింపు='')
అవుట్‌పుట్
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. ఇక్కడ, 72, 69, 76, మరియు 79 వరుసగా 'H,' 'E,' 'L,' మరియు 'O,' యొక్క ASCII కోడ్.
ఉదాహరణ 2: స్ట్రింగ్ డేటాను బైటెర్రే నుండి బైట్‌లుగా మార్చండి
కింది ఉదాహరణ స్ట్రింగ్ డేటాలోని బైట్ వస్తువులను బైట్ వస్తువులుగా మార్చడాన్ని చూపుతుంది. ఈ స్క్రిప్ట్ యొక్క బైటెర్రే () పద్ధతిలో రెండు వాదనలు ఉపయోగించబడ్డాయి. మొదటి ఆర్గ్యుమెంట్‌లో స్ట్రింగ్ విలువ ఉంటుంది, రెండో ఆర్గ్యుమెంట్‌లో ఎన్కోడింగ్ స్ట్రింగ్ ఉంటుంది. ఇక్కడ, ‘utf-8’ ఎన్కోడింగ్ బైటెర్రే ఆబ్జెక్ట్‌గా మార్చడానికి ఉపయోగించబడుతుంది. ది డీకోడ్ () బైట్ల వస్తువులను స్ట్రింగ్ డేటాగా మార్చడానికి స్క్రిప్ట్‌లో పద్ధతి ఉపయోగించబడుతుంది. మార్పిడి సమయంలో అదే ఎన్కోడింగ్ ఉపయోగించబడుతుంది.
#!/usr/bin/env పైథాన్ 3# స్ట్రింగ్ విలువను తీసుకోండి
టెక్స్ట్= ఇన్పుట్('ఏదైనా వచనాన్ని నమోదు చేయండి: n')
# స్ట్రింగ్ మరియు ఎన్‌కోడింగ్‌తో బైటెర్రే ఆబ్జెక్ట్‌ను ప్రారంభించండి
byteArrObj= బైటెర్రే(టెక్స్ట్, 'utf-8')
ముద్రణ(' nబైట్‌సారే () పద్ధతి యొక్క అవుట్‌పుట్: n',byteArrObj)
# బైటెర్రేని బైట్‌లుగా మార్చండి
byteObj= బైట్లు(byteArrObj)
ముద్రణ(' nబైట్ల () పద్ధతి యొక్క అవుట్‌పుట్: n',byteObj)
# ఎమ్‌కోడింగ్ ఉపయోగించి బైట్ల విలువను స్ట్రింగ్‌గా మార్చండి
ముద్రణ(' nబైట్ల స్ట్రింగ్ విలువలు ')
ముద్రణ(byteObj.డీకోడ్('utf-8'))
అవుట్‌పుట్
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ఉదాహరణ 3: బైటెర్రే నుండి బైట్‌లకు పూర్ణాంక డేటాను మార్చండి
మునుపటి ఉదాహరణలు నిఘంటువు మరియు స్ట్రింగ్ డేటా ఆధారంగా బైటెర్రే మరియు బైట్ల మార్పిడిని చూపుతాయి. ఈ మూడవ ఉదాహరణ బైట్‌అరే ఇన్పుట్ డేటా ఆధారంగా బైట్‌లుగా మార్చడాన్ని చూపుతుంది. ఇక్కడ, ఇన్పుట్ విలువ పూర్ణాంక విలువగా మార్చబడుతుంది మరియు బైటెర్రే () ఫంక్షన్ ద్వారా ఆర్గ్యుమెంట్‌గా పంపబడుతుంది మరియు బైట్రే వస్తువు ఆ తర్వాత బైట్ల వస్తువుగా మార్చబడుతుంది. పూర్ణాంక సంఖ్య ఆధారంగా శూన్య విలువలు బైటెర్రే మరియు బైట్ల వస్తువు యొక్క అవుట్‌పుట్‌గా చూపబడతాయి. స్క్రిప్ట్ చివర లెన్ () పద్ధతి ద్వారా మొత్తం బైట్ల సంఖ్య లెక్కించబడుతుంది మరియు బైటెర్రే () పద్ధతిలో వాదనగా పంపిన పూర్ణాంక విలువకు సమానంగా ఉంటుంది.
#!/usr/bin/env పైథాన్ 3ప్రయత్నించండి:
# ఏదైనా సంఖ్య విలువను తీసుకోండి
టెక్స్ట్= int(ఇన్పుట్('ఏదైనా సంఖ్యను నమోదు చేయండి:'))
# సంఖ్యతో బైటెర్రే వస్తువును ప్రారంభించండి
byteArrObj= బైటెర్రే(టెక్స్ట్)
ముద్రణ(' nబైట్‌సారే () పద్ధతి యొక్క అవుట్‌పుట్: n',byteArrObj)
# బైటెర్రే వస్తువును బైట్ల వస్తువుగా మార్చండి
byteObj= బైట్లు(byteArrObj)
ముద్రణ(' nబైట్ల () పద్ధతి యొక్క అవుట్‌పుట్: n',byteObj)
# బైట్ల వస్తువు పరిమాణాన్ని ముద్రించండి
ముద్రణ(' nబైట్ల ఆబ్జెక్ట్ యొక్క పొడవు: ',లెన్(byteObj))
తప్ప విలువ లోపం:
ముద్రణ('ఏదైనా సంఖ్యా విలువను నమోదు చేయండి')
అవుట్‌పుట్
స్క్రిప్ట్ రన్ అయిన తర్వాత, కింది అవుట్‌పుట్‌లో 6 ఇన్‌పుట్‌గా తీసుకోబడుతుంది. ఆరు శూన్య విలువలు బైటెర్రే మరియు బైట్ల అవుట్‌పుట్‌గా ప్రదర్శించబడతాయి. శూన్య విలువలు లెక్కించబడినప్పుడు అది 6 ప్రదర్శించబడుతుంది.
ఉదాహరణ 4: అనుబంధాన్ని () ఉపయోగించి బైటెర్రేని సృష్టించండి మరియు బైట్‌లుగా మార్చండి
కింది ఉదాహరణ బైటెరే వస్తువులు అనుబంధ () పద్ధతి ద్వారా ఎలా సృష్టించబడతాయో మరియు బైట్‌లుగా మార్చబడతాయో చూపుతుంది. అరవల్ వేరియబుల్ ఇక్కడ బైటెర్రే ఆబ్జెక్ట్‌గా ప్రకటించబడింది. తరువాత, శ్రేణిలో ఆరు మూలకాలను జోడించడానికి అనుబంధం () పద్ధతిని ఆరు సార్లు అంటారు. అక్షరాల ASCII కోడ్‌లు, ‘P,’ ‘y,’ ‘t,’ ‘h,’ ‘o,’ మరియు ‘n,’ వరుసగా 80, 121, 116, 104, 111 మరియు 1120. ఇవి బైటీరే వస్తువులో జోడించబడ్డాయి. ఈ శ్రేణి వస్తువు తరువాత బైట్ల వస్తువుగా మార్చబడుతుంది.
#!/usr/bin/env పైథాన్ 3# బైటెర్రేని సృష్టించండి మరియు అనుబంధ () పద్ధతిని ఉపయోగించి అంశాన్ని జోడించండి
అరవాల్= బైటెర్రే()
అరవాల్.అనుబంధం(80)
అరవాల్.అనుబంధం(121)
అరవాల్.అనుబంధం(116)
అరవాల్.అనుబంధం(104)
అరవాల్.అనుబంధం(111)
అరవాల్.అనుబంధం(110)
# బైటెర్రే () విలువలను ముద్రించండి
ముద్రణ(' nబైటెర్రే () పద్ధతి యొక్క అవుట్‌పుట్: n',అరవాల్)
# బైటెర్రే వస్తువును బైట్ల వస్తువుగా మార్చండి
బైట్ ఆబ్జెక్ట్= బైట్లు(అరవాల్)
# బైట్ల వస్తువు విలువను ముద్రించండి
ముద్రణ(' nబైట్ల () పద్ధతి యొక్క అవుట్‌పుట్: n',బైట్ ఆబ్జెక్ట్)
అవుట్‌పుట్
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది.
ముగింపు
బైటెర్రే వస్తువులను సృష్టించిన తర్వాత బైటెర్రేని బైట్‌లుగా మార్చడానికి ఈ వ్యాసంలో వివిధ పద్ధతులు చూపబడ్డాయి. ఈ కథనాన్ని చదివిన తర్వాత, మీరు బైటెర్రే మరియు బైట్ల భావనను అర్థం చేసుకున్నారని, బైట్‌రేని బైట్‌లుగా మార్చే మార్గాన్ని తెలుసుకోవాలని మరియు బైట్ల అవుట్‌పుట్‌ను స్ట్రింగ్ మరియు అక్షరాలుగా ప్రదర్శించగలరని నేను ఆశిస్తున్నాను.