Python में स्ट्रिंग को बाइट्स में कैसे बदलें

स्ट्रिंग्स मानवी-पठनीय पाठ को दर्शाती हैं और कंप्यूटर प्रोग्रामिंग में सबसे बुनियादी और महत्वपूर्ण डेटा प्रकारों में से एक हैं। हालांकि, किसी टेक्स्ट स्ट्रिंग का प्रत्येक अक्षर बाइनरी डेटा के एक या अधिक बाइट्स द्वारा दर्शाया जाता है। इनपुट-आउटपुट ऑपरेशंस और डेटा ट्रांसमिशन जैसी एप्लिकेशन में स्ट्रिंग्स को किसी विशिष्ट एन्कोडिंग का उपयोग करके बाइट्स में बदलना आवश्यक होता है।

यह ट्यूटोरियल Python में स्ट्रिंग्स को बाइट्स में बदलने की तकनीकों पर प्रकाश डालता है। यदि आप उल्टा ऑपरेशन जानना चाहते हैं, तो मेरा ट्यूटोरियल देखें—Python में बाइट्स को स्ट्रिंग्स में कैसे बदलें।

विस्तार में जाने से पहले, जल्दी में रहने वालों के लिए एक छोटा-सा उत्तर देखते हैं।

संक्षिप्त उत्तर: Python में स्ट्रिंग को बाइट्स में कैसे बदलें

Python में बिल्ट-इन .encode() मेथड से किसी स्ट्रिंग को बाइट्स में बदलना सीधा है:

my_string = "Hello, world!"
bytes_representation = my_string.encode(encoding="utf-8")  
# Optional: Specify the desired encoding (UTF-8 is the default)

print(bytes_representation)
# Output: b'Hello, world!'

.encode() मेथड मूल स्ट्रिंग के एन्कोडेड संस्करण का एक नया bytes ऑब्जेक्ट लौटाता है। डिफ़ॉल्ट रूप से यह UTF-8 का उपयोग करता है, लेकिन जरूरत पड़ने पर आप 'ascii' या 'latin-1' जैसी अन्य एन्कोडिंग भी दे सकते हैं।

आइए इस कन्वर्ज़न प्रक्रिया को और विस्तार से समझते हैं।

Python में स्ट्रिंग्स और बाइट्स को समझना

Python के दो मुख्य बिल्ट-इन डेटा प्रकार str और bytes हैं। इन डेटा प्रकारों में कुछ समानताएं हैं, लेकिन कुछ अहम अंतर भी हैं।

str और bytes दोनों इम्यूटेबल सीक्वेंस हैं, यानी बनने के बाद इनके तत्वों को बदला नहीं जा सकता। स्ट्रिंग अक्षरों का एक इम्यूटेबल सीक्वेंस है, जबकि bytes ऑब्जेक्ट 0 से 255 के बीच के पूर्णांकों का इम्यूटेबल सीक्वेंस है। यह रेंज 8 बिट्स (एक बाइट) से व्यक्त की जा सकती है। इसलिए, bytes ऑब्जेक्ट बाइट्स का क्रम होता है।

ASCII कैरेक्टर एन्कोडिंग

पहले ASCII कैरेक्टर्स पर विचार करें। ASCII (American Standard Code for Information Interchange) एक कैरेक्टर एन्कोडिंग है जिसमें केवल 128 कैरेक्टर शामिल हैं। इस कारण कोई भी ASCII कैरेक्टर सात बिट्स से व्यक्त हो सकता है, जो एक बाइट से भी कम है।

हम सामान्य स्ट्रिंग्स के लिए उपयोग होने वाले सिंगल, डबल, या ट्रिपल कोट्स से पहले b लगाकर एक bytes ऑब्जेक्ट बना सकते हैं:

word_as_bytes = b"Python"
print(word_as_bytes)
print(type(word_as_bytes))

b'Python'
<class 'bytes'>

हालांकि कोड Python शब्द को अक्षरों की तरह दिखाता है, bytes ऑब्जेक्ट का प्रत्येक तत्व 0 से 255 के बीच का एक पूर्णांक होता है:

print(word_as_bytes[0])
print(list(word_as_bytes))

80
[80, 121, 116, 104, 111, 110]

word_as_bytes का पहला तत्व पूर्णांक 80 है, जो अपरकेस P का ASCII कोड है:

print(chr(80))

P

word_as_bytes को लिस्ट में कास्ट करने पर, लिस्ट में प्रत्येक बाइट का प्रतिनिधित्व करने वाले पूर्णांक मिलते हैं। ये पूर्णांक शब्द Python के अक्षरों के ASCII कोड हैं।

हालांकि, ASCII कैरेक्टर सेट सीमित है।

UTF-8 कैरेक्टर एन्कोडिंग

सबसे सामान्य कैरेक्टर एन्कोडिंग UTF-8 है, जो 8-बिट Unicode एन्कोडिंग है। 128 ASCII कैरेक्टर्स UTF-8 में भी उन्हीं पूर्णांकों से दर्शाए जाते हैं, लेकिन अन्य कैरेक्टर्स को प्रत्येक अक्षर के लिए दो या अधिक बाइट्स से भी दर्शाया जा सकता है।

आइए गैर-ASCII कैरेक्टर्स का उपयोग करके एक bytes ऑब्जेक्ट बनाते हैं। इसके लिए हमें bytes() कंस्ट्रक्टर का उपयोग करना होगा:

word_as_bytes = bytes("café", "utf-8")
print(word_as_bytes)

b'caf\xc3\xa9'

bytes ऑब्जेक्ट में café के पहले तीन अक्षर सीधे दिखते हैं। लेकिन एक्सेंट वाला é ASCII कैरेक्टर नहीं है, और यह दो बाइट्स से दर्शाया जाता है, जो \xc3 और \xa9 के रूप में दिखते हैं। ये बाइट्स हेक्साडेसिमल संख्याएँ c3 और a9 हैं, जो क्रमशः पूर्णांक 195 और 169 हैं। ये दो बाइट्स मिलकर UTF-8 में é को दर्शाते हैं:

print(len(word_as_bytes))
print(list(word_as_bytes))

5
[99, 97, 102, 195, 169]

पाँच-तत्वों वाला bytes ऑब्जेक्ट चार-अक्षरों की स्ट्रिंग को दर्शाता है।

स्ट्रिंग को बाइट्स में बदलना: encode() मेथड

पहले हमने bytes() कंस्ट्रक्टर से टेक्स्ट स्ट्रिंग को bytes ऑब्जेक्ट में बदला था। Python स्ट्रिंग्स को बाइट्स में बदलने का अधिक सामान्य तरीका स्ट्रिंग का .encode() मेथड है, जो एन्कोडिंग और एरर हैंडलिंग पर नियंत्रण देता है। यह मेथड स्ट्रिंग का प्रतिनिधित्व करने वाला bytes ऑब्जेक्ट लौटाता है:

word_as_bytes = "Hello Python!".encode()
​print(word_as_bytes)
print(type(word_as_bytes))

b'Hello Python!'
<class 'bytes'>

.encode() मेथड का डिफ़ॉल्ट एन्कोडिंग UTF-8 है। UTF-8 सबसे व्यापक रूप से प्रयुक्त एन्कोडिंग फॉर्मेट है और यह ASCII की तुलना में कहीं व्यापक रेंज के कैरेक्टर्स को सपोर्ट करता है। UTF-8 प्रत्येक कैरेक्टर को एक, दो, तीन या चार-बाइट यूनिट्स के सीक्वेंस से दर्शाता है।

हम .encode() को किसी वैकल्पिक एन्कोडिंग के आर्ग्युमेंट के साथ भी कॉल कर सकते हैं:

word_as_bytes = "Hello Python!".encode("utf-16")
print(word_as_bytes)

b'\xff\xfeH\x00e\x00l\x00l\x00o\x00 \x00P\x00y\x00t\x00h\x00o\x00n\x00!\x00'

यहाँ bytes ऑब्जेक्ट अलग दिखता है क्योंकि यह उसी टेक्स्ट स्ट्रिंग का UTF-16 एन्कोडिंग दर्शाता है।

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

क्योंकि सभी एन्कोडिंग्स में सभी कैरेक्टर्स शामिल नहीं होते, किसी स्ट्रिंग को bytes ऑब्जेक्ट में एन्कोड करते समय त्रुटियाँ आ सकती हैं।

स्ट्रिंग "Café • £2.20" पर विचार करें, जिसमें तीन गैर-ASCII कैरेक्टर्स हैं। हम इसे डिफ़ॉल्ट UTF-8 एन्कोडिंग से एन्कोड कर सकते हैं:

word_as_bytes = "Café • £2.20".encode()
print(word_as_bytes)

b'Caf\xc3\xa9 \xe2\x80\xa2 \xc2\xa32.20'

गैर-ASCII कैरेक्टर्स अपने हेक्साडेसिमल एस्केप सीक्वेंस से दर्शाए जाते हैं। लेकिन यदि उसी स्ट्रिंग को ASCII से एन्कोड करें, तो .encode() त्रुटि उठाएगा क्योंकि कई कैरेक्टर्स ASCII एन्कोडिंग में मौजूद ही नहीं हैं:

word_as_bytes = "Café • £2.20".encode("ascii")
print(word_as_bytes)

Traceback (most recent call last):
...
word_as_bytes = "Café • £2.20".encode("ascii")
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
UnicodeEncodeError: 'ascii' codec can't encode character '\xe9' in position 3: ordinal not in range(128)

.encode() स्ट्रिंग मेथड का एक पैरामीटर errors होता है, जिसकी डिफ़ॉल्ट वैल्यू "strict" है। "strict" आर्ग्युमेंट .encode() को बाध्य करता है कि जब कोई कैरेक्टर एन्कोड न हो सके तो UnicodeEncodeError उठाया जाए।

हालाँकि, त्रुटि हैंडलिंग के अन्य विकल्प भी हैं। एक विकल्प है "ignore" आर्ग्युमेंट का उपयोग कर त्रुटियों को अनदेखा करना:

word_as_bytes = "Café • £2.20".encode("ascii", errors="ignore")
print(word_as_bytes)

b'Caf 2.20'

इस विकल्प में कोई त्रुटि नहीं उठती। इसके बजाय, .encode() एक bytes ऑब्जेक्ट लौटाता है, और एक्सेंट वाला é, बुलेट पॉइंट और पाउंड साइन हटा दिए जाते हैं।

एक और विकल्प यह है कि जिन कैरेक्टर्स को एन्कोड नहीं किया जा सकता, उन्हें किसी और चीज़ से बदल दिया जाए। कई रिप्लेसमेंट विकल्प हैं। उनमें से एक है errors="replace" आर्ग्युमेंट:

word_as_bytes = "Café • £2.20".encode("ascii", errors="replace")
print(word_as_bytes)

b'Caf? ? ?2.20'

इस उदाहरण में एन्कोड न हो पाने वाले तीनों गैर-ASCII कैरेक्टर्स प्रश्नवाचक चिह्न से बदल दिए जाते हैं। यानी हर गायब कैरेक्टर को एक अन्य एकल कैरेक्टर से प्लेसहोल्डर के रूप में बदला जाता है।

हम गायब कैरेक्टर्स को अधिक सूचनात्मक टेक्स्ट से भी बदल सकते हैं:

word_as_bytes = "Café • £2.20".encode("ascii", errors="backslashreplace")
print(word_as_bytes)

b'Caf\\xe9 \\u2022 \\xa32.20'

errors="backslashreplace" के साथ .encode() कॉल करने पर, एन्कोड न हो सकने वाले कैरेक्टर्स को उनके हेक्साडेसिमल एस्केप सीक्वेंस से बदल दिया जाता है। हेक्साडेसिमल संख्या e9 एक्सेंट वाले é को दर्शाती है। बुलेट पॉइंट Unicode कैरेक्टर u2022 है, और हेक्साडेसिमल संख्या a3 पाउंड साइन को दर्शाती है।

हम "xmlcharrefreplace" का उपयोग करके भी गायब कैरेक्टर्स को उनके XML कोड से बदल सकते हैं:

word_as_bytes = "Café • £2.20".encode("ascii", errors="xmlcharrefreplace")
print(word_as_bytes)

b'Café • £2.20'

एक और विकल्प है errors="namereplace" का उपयोग करके अमान्य कैरेक्टर्स को उनके औपचारिक नाम से बदलना:

word_as_bytes = "Café • £2.20".encode("ascii", errors="namereplace")
print(word_as_bytes)

b'Caf\\N{LATIN SMALL LETTER E WITH ACUTE} \\N{BULLET} \\N{POUND SIGN}2.20'

अलग-अलग परिस्थितियों में अलग त्रुटि हैंडलिंग की जरूरत हो सकती है, और .encode() स्ट्रिंग मेथड उन कैरेक्टर्स को संभालने के कई विकल्प देता है जिन्हें एन्कोड नहीं किया जा सकता।

डेटा साइंस में स्ट्रिंग-टू-बाइट कन्वर्ज़न के उपयोग

स्ट्रिंग-टू-बाइट कन्वर्ज़न एक बुनियादी ऑपरेशन है जिसका उपयोग डेटा साइंस के कई क्षेत्रों में होता है:

• नेचुरल लैंग्वेज प्रोसेसिंग (NLP): सेंटिमेंट एनालिसिस, टॉपिक मॉडलिंग, या मशीन ट्रांसलेशन जैसे कार्यों के लिए टेक्स्ट डेटा के साथ काम करते समय, हम अक्सर टेक्स्ट को शब्दों या सबवर्ड्स में टोकनाइज़ करके प्री-प्रोसेस करते हैं। यह टोकनाइज़ेशन प्रक्रिया अक्सर कुशल प्रतिनिधित्व और मैनिपुलेशन के लिए स्ट्रिंग्स को बाइट सीक्वेंस में बदलने को शामिल करती है।
• डेटा क्लीनिंग और प्रीप्रोसेसिंग: बाइट-स्तरीय ऑपरेशंस टेक्स्ट डेटा की सफाई में उपयोगी हो सकते हैं, जैसे अमान्य कैरेक्टर्स हटाना या विशिष्ट बाइट पैटर्न के आधार पर टेक्स्ट को सामान्य करना।
• फीचर इंजीनियरिंग: कुछ मामलों में, टेक्स्ट डेटा से बाइट-स्तरीय फीचर्स (जैसे, बाइट n-ग्राम) निकाले जा सकते हैं और उन्हें मशीन लर्निंग मॉडल्स के इनपुट फीचर्स के रूप में उपयोग किया जा सकता है।
• वेब स्क्रैपिंग और डेटा एक्सट्रैक्शन: वेबसाइटों से डेटा स्क्रैप करते समय, हमें अक्सर HTML या अन्य टेक्स्ट-आधारित कंटेंट मिलता है, जिसे प्रासंगिक जानकारी निकालने के लिए बाइट स्तर पर पार्स और प्रोसेस करने की जरूरत पड़ सकती है।
• डेटा कंप्रेशन: कुछ डेटा कंप्रेशन एल्गोरिदम बाइट सीक्वेंस पर काम करते हैं, इसलिए कंप्रेशन तकनीकें लागू करने से पहले स्ट्रिंग्स को बाइट्स में बदलना आवश्यक कदम हो सकता है।

इन उपयोगों को समझने से हमें वे परिस्थितियाँ पहचानने में मदद मिलती है जहाँ स्ट्रिंग्स को बाइट्स में बदलना उपयोगी हो सकता है।

निष्कर्ष

स्ट्रिंग्स मानवी-पठनीय अक्षरों के सीक्वेंस होते हैं। ये अक्षर बाइनरी डेटा के बाइट्स के रूप में एन्कोड किए जाते हैं, जिन्हें एक bytes ऑब्जेक्ट में संग्रहीत किया जा सकता है। bytes ऑब्जेक्ट पूर्णांकों का एक सीक्वेंस होता है, और प्रत्येक पूर्णांक एक बाइट का प्रतिनिधित्व करता है।

एप्लिकेशन में स्ट्रिंग्स को bytes ऑब्जेक्ट्स में बदलना आवश्यक होता है, जिसे हम या तो bytes() कंस्ट्रक्टर या स्ट्रिंग के .encode() मेथड से कर सकते हैं। स्ट्रिंग्स और बाइट्स के बीच कन्वर्ज़न में महारत अधिक लचीले डेटा मैनिपुलेशन को संभव बनाती है।

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

• Introduction to Python Course
• Python Programming
• Python Fundamentals