Python में Bytes को String में कैसे बदलें

Python में कम-ज्ञात बिल्ट-इन सीक्वेंस में से एक bytes है, जो पूर्णांकों का एक अपरिवर्तनीय सीक्वेंस होता है। प्रत्येक पूर्णांक डेटा के एक बाइट का प्रतिनिधित्व करता है। डेटा अक्सर नेटवर्क और प्रोग्रामों के बीच bytes के रूप में प्रेषित होता है। Bytes मानव-पाठ्य नहीं होते, और हमें अक्सर अपने Python प्रोग्रामों में इन्हें strings में बदलने की आवश्यकता पड़ती है।

यह ट्यूटोरियल Python में bytes को strings में बदलने की तकनीकों का अध्ययन करता है। यदि आप इसके उलट ऑपरेशन में रुचि रखते हैं, तो मेरा ट्यूटोरियल देखें: Python में strings को bytes में कैसे बदलें।

जो लोग जल्दी में हैं, उनके लिए एक छोटे उत्तर से शुरू करते हैं।

संक्षिप्त उत्तर: Python में Bytes को String में कैसे बदलें

Python में bytes को strings में बदलने का मुख्य साधन .decode() मेथड है:

data = b"\xc3\xa9clair"
text = data.decode(encoding="utf-8")
print(text)

éclair

.decode() मेथड bytes ऑब्जेक्ट का प्रतिनिधित्व करने वाला एक string लौटाता है। इस उदाहरण में UTF-8 डिकोडिंग का उपयोग किया गया है। UTF-8 डिफ़ॉल्ट एन्कोडिंग है, इसलिए ऊपर के उदाहरण में इसे देना आवश्यक नहीं है, लेकिन हम अन्य एन्कोडिंग्स भी इस्तेमाल कर सकते हैं।

Python में Bytes और Strings को समझना

Python में बिल्ट-इन bytes डेटा स्ट्रक्चर होता है, जो 0 से 255 की रेंज के पूर्णांकों का एक अपरिवर्तनीय सीक्वेंस है। 256 संख्याओं की इस रेंज के भीतर कोई भी पूर्णांक आठ बिट्स (एक बाइट) में दर्शाया जा सकता है। इसलिए, bytes ऑब्जेक्ट का प्रत्येक एलिमेंट एक बाइट का प्रतिनिधित्व करने वाला पूर्णांक होता है।

आइए एक सूची से bytes() कंस्ट्रक्टर का उपयोग करके bytes ऑब्जेक्ट बनाते हैं:

data = bytes([68, 97, 116, 97, 67, 97, 109, 112])
print(type(data))

<class 'bytes'>

यह पूर्णांकों का सीक्वेंस अपरिवर्तनीय है:

data[0] = 100

Traceback (most recent call last):
 ...
   data[0] = 100
   ~~~~^^^
TypeError: 'bytes' object does not support item assignment

जब हम इस सीक्वेंस के भीतर किसी मान को बदलने की कोशिश करते हैं, तो Python TypeError उठाता है। आइए पुष्टि करें कि bytes ऑब्जेक्ट में केवल 0 से 255 की रेंज के पूर्णांक ही हो सकते हैं:

data = bytes([254, 255, 256])

Traceback (most recent call last):
 ...
   data = bytes([254, 255, 256])
          ^^^^^^^^^^^^^^^^^^^^^^
ValueError: bytes must be in range(0, 256)

ValueError बताता है कि बाइट का प्रतिनिधित्व करने वाला पूर्णांक range(0, 256) का सदस्य होना चाहिए। रेंज का अंतिम छोर शामिल नहीं होता, जैसा कि Python में रेंज के साथ प्रचलन है।

हम print() का उपयोग करके bytes ऑब्जेक्ट को प्रदर्शित कर सकते हैं:

data = bytes([68, 97, 116, 97, 67, 97, 109, 112])
print(data)

b'DataCamp'

यह निरूपण पात्रों द्वारा दर्शाए गए bytes ऑब्जेक्ट को दिखाता है। Python उन पूर्णांकों को उनके अनुरूप ASCII अक्षरों के रूप में प्रदर्शित करता है। उद्धरणों में अक्षरों से पहले लगा b प्रीफिक्स दर्शाता है कि यह एक bytes ऑब्जेक्ट है।

हम सीधे bytes लिटरल का उपयोग करके भी bytes ऑब्जेक्ट बना सकते हैं:

data = b"DataCamp"
print(data)
print(data[0])

b'DataCamp'
68

ऑब्जेक्ट पात्रों का उपयोग करके प्रदर्शित होता है, लेकिन इसके एलिमेंट पूर्णांक होते हैं।

हालाँकि, bytes ऑब्जेक्ट तभी मानव-पाठ्य होते हैं जब वे मुद्रणीय ASCII अक्षरों के अनुरूप पूर्णांकों का उपयोग करते हैं। चूँकि ASCII 7-बिट एन्कोडिंग है, इसमें 128 कोड होते हैं, लेकिन इनमें से केवल 95 ASCII अक्षर मुद्रणीय हैं।

0 से 127 के बीच वे पूर्णांक जिनके पास मुद्रणीय ASCII अक्षर नहीं है और 128 से 255 के बीच के पूर्णांक, हेक्साडेसिमल संख्याओं के रूप में प्रदर्शित किए जाते हैं:

data = bytes([0, 68, 97, 116, 97, 67, 97, 109, 112, 200])
print(data)

b'\x00DataCamp\xc8'

अब सूची में पहला पूर्णांक 0 है, जो ASCII में मुद्रणीय अक्षर नहीं है। bytes ऑब्जेक्ट इस पूर्णांक को \x00 के रूप में दिखाता है, जो 0 का हेक्साडेसिमल निरूपण है। अंतिम पूर्णांक 200 है, जो ASCII रेंज से बाहर है लेकिन bytes में उपयोग किए जाने योग्य पूर्णांकों की रेंज के भीतर है। Python इस पूर्णांक को \xc8 के रूप में प्रदर्शित करता है, जो हेक्साडेसिमल में 200 है।

bytes और strings डेटा स्ट्रक्चर कुछ समानताएँ साझा करते हैं। दोनों अपरिवर्तनीय सीक्वेंस हैं, लेकिन bytes में पूर्णांक होते हैं, जबकि strings में अक्षर होते हैं:

data = bytes([68, 97, 116, 97, 67, 97, 109, 112])
print(data[0])

​text = "DataCamp"
print(text[0])

68
D

Bytes का उपयोग नेटवर्क्स और विभिन्न इंटरफेसों के बीच डेटा स्थानांतरित करने के लिए किया जाता है। इस लेख का अगला भाग bytes को strings में बदलने के तरीके खोजता है।

Bytes को Strings में बदलना: .decode() मेथड

Python में कोई bytes ऑब्जेक्ट तभी मानव-पाठ्य होता है जब इसमें पठनीय ASCII अक्षर हों। अधिकांश अनुप्रयोगों में ये अक्षर पर्याप्त नहीं होते। हम .decode() मेथड का उपयोग करके किसी bytes ऑब्जेक्ट को string में बदल सकते हैं:

data = bytes([68, 97, 116, 97, 67, 97, 109, 112])
text = data.decode()

print(text)
print(type(text))

DataCamp
<class 'str'>

हालाँकि, bytes और strings के बीच रूपांतरण के लिए अलग-अलग एन्कोडिंग होती हैं। ऊपर दिए गए उदाहरण में पूर्णांक मुद्रणीय ASCII अक्षरों का प्रतिनिधित्व करते हैं। लेकिन जब .decode() को बिना आर्ग्युमेंट के कॉल किया जाता है, तो डिफ़ॉल्ट एन्कोडिंग UTF-8 होती है, ASCII नहीं। UTF-8, Unicode अक्षरों के लिए सबसे व्यापक रूप से उपयोग की जाने वाली एन्कोडिंग है।

पहले 128 UTF-8 कोड ASCII कोड से मेल खाते हैं, इसलिए ऊपर के उदाहरण में bytes ऑब्जेक्ट data string "DataCamp" में डिकोड हो जाता है।

हालाँकि, Unicode में लगभग 1,50,000 अक्षर हैं। UTF-8 सभी गैर-ASCII Unicode अक्षरों को दो या अधिक bytes का उपयोग करके एन्कोड करता है।

आइए एक नया bytes ऑब्जेक्ट बनाकर उसे डिकोड करें:

data = bytes([195, 169])
print(data)

text = data.decode()
print(text)

b'\xc3\xa9'
é

bytes ऑब्जेक्ट में दो बाइट्स हैं: पूर्णांक 195 और 169। Python इन बाइट्स का हेक्साडेसिमल निरूपण दिखाता है। हालाँकि, .decode() UTF-8 एन्कोडिंग का उपयोग करके bytes ऑब्जेक्ट को डिकोड कर एक string लौटाता है। बाइट्स का जोड़ा b'\xc3\xa9' तीव्र उच्चारण वाले e अक्षर, é, का प्रतिनिधित्व करता है।

.decode() मेथड एन्कोडिंग निर्दिष्ट करने के लिए एक वैकल्पिक आर्ग्युमेंट लेता है:

text = data.decode("utf-8")
print(text)

é

UTF-8 डिफ़ॉल्ट एन्कोडिंग है, लेकिन अन्य एन्कोडिंग्स का भी उपयोग किया जा सकता है। हम string मेथड .encode() का उपयोग करके विभिन्न एन्कोडिंग्स के साथ किसी string को bytes ऑब्जेक्ट में भी बदल सकते हैं:

text = "éclair"
data = text.encode("utf-8")
print(data)

data = text.encode("utf-16")
print(data)

b'\xc3\xa9clair'
b'\xff\xfe\xe9\x00c\x00l\x00a\x00i\x00r\x00'

एक ही string अलग-अलग कैरेक्टर एन्कोडिंग के आधार पर अलग-अलग bytes ऑब्जेक्ट्स में बदलती है।

एन्कोडिंग त्रुटियाँ

कैरेक्टर एन्कोडिंग का चुनाव bytes और strings के बीच रूपांतरण में अलग एन्कोडिंग इस्तेमाल होने पर त्रुटियाँ पैदा कर सकता है। आइए string "éclair" के उदाहरण का उपयोग करें, जिसे UTF-8 एन्कोडिंग से bytes में बदला गया है:

text = "éclair"
data = text.encode("utf-8")
print(data)

b'\xc3\xa9clair'

यह bytes का क्रम UTF-8 एन्कोडिंग का उपयोग करके अक्षरों का प्रतिनिधित्व करता है। यदि हम गलत एन्कोडिंग का उपयोग करें, तो .decode() मेथड त्रुटि उठाता है:

text = data.decode("ascii")
print(text)

Traceback (most recent call last):
 ...
   text = data.decode("ascii")
          ^^^^^^^^^^^^^^^^^^^^
UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 0: ordinal not in range(128)

हालाँकि, हम किसी भी त्रुटि को संभालने के लिए वैकल्पिक errors आर्ग्युमेंट शामिल कर सकते हैं। errors पैरामीटर का डिफ़ॉल्ट मान "strict" है, जो अमान्य अक्षरों के लिए त्रुटि उठाता है।

.decode() मेथड को errors="ignore" के साथ कॉल किया जा सकता है, ताकि सभी अमान्य अक्षरों को अनदेखा किया जा सके:

text = data.decode("ascii", errors="ignore")
print(text)

clair

मूल string का पहला अक्षर é है, जो ASCII अक्षर नहीं है। इसलिए, .decode() पहला अक्षर हटाकर string लौटाता है।

एक और विकल्प है errors="replace" के साथ .decode() को कॉल करना, जो अमान्य bytes को से बदल देता है:

text = data.decode("ascii", errors="replace")
print(text)

clair

यह आउटपुट दिखाता है कि string से अक्षर गायब हैं। त्रुटि संभालने की रणनीति का चुनाव अनुप्रयोग पर निर्भर करता है।

str() के साथ Bytes को Strings में बदलना

.decode() मेथड bytes को strings में बदलने का मुख्य मार्ग है। हालाँकि, str() कंस्ट्रक्टर का सीधे उपयोग करना भी संभव है। किसी bytes ऑब्जेक्ट पर str() कंस्ट्रक्टर का उपयोग कच्चे bytes का string निरूपण बनाएगा:

data = b'\xc3\xa9clair'
text = str(data)

print(text)
print(type(text))

b'\xc3\xa9clair'
<class 'str'>

हालाँकि, str() कंस्ट्रक्टर एक encoding आर्ग्युमेंट भी स्वीकार करता है, जिसका उपयोग हम किसी विशिष्ट एन्कोडिंग के आधार पर string बनाने के लिए कर सकते हैं:

text = str(data, encoding='utf-8')
print(text)

éclair

codecs.decode() के साथ Bytes को Strings में बदलना

Python की स्टैंडर्ड लाइब्रेरी में codecs मॉड्यूल डेटा को एन्कोड और डिकोड करने के लिए इंटरफ़ेस प्रदान करता है। यह मॉड्यूल एक .decode() फ़ंक्शन भी प्रदान करता है, जिसका उपयोग Python bytes को strings में बदलने के लिए किया जा सकता है:

import codecs

​data = b'\xc3\xa9clair'
text = codecs.decode(data, encoding='utf-8')
print(text)

éclair

ये वैकल्पिक रूपांतरण तकनीकें bytes प्रकार की मेथड नहीं हैं, बल्कि ऐसी फ़ंक्शंस हैं जिनमें bytes ऑब्जेक्ट को आर्ग्युमेंट के रूप में पास करना पड़ता है।

निष्कर्ष

डेटा अक्सर bytes के रूप में स्थानांतरित किया जाता है, और कई Python अनुप्रयोगों को bytes और strings के बीच रूपांतरण की आवश्यकता होती है। bytes ऑब्जेक्ट bytes का एक अपरिवर्तनीय सीक्वेंस है, जिसे कई कैरेक्टर एन्कोडिंग में से किसी एक का उपयोग कर string में बदला जा सकता है।

Python bytes को string में बदलने का मुख्य मार्ग .decode() मेथड है, जो उपयोगकर्ताओं को एन्कोडिंग और त्रुटि-प्रबंधन रणनीति चुनने की अनुमति देता है।

आप निम्नलिखित ट्यूटोरियल्स और कोर्सेज के साथ अपनी Python सीख जारी रख सकते हैं:

• Python Fundamentals
• Python Logical Operators: A Hands-on Introduction
• Python Cache: Two Simple Methods