Python में डेटा टाइप कन्वर्ज़न: उदाहरणों सहित मार्गदर्शिका

उदाहरण में, एक integer मान a_int को एक float मान b_float में जोड़ा गया, और परिणाम स्वतः ही float मान c_sum में कन्वर्ट हो गया, बिना आपको कंपाइलर को बताने की आवश्यकता के। यही इम्प्लिसिट डेटा कन्वर्ज़न है।

फिर float मान को integer में कन्वर्ट क्यों नहीं किया गया?

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

यानी float से integer में कन्वर्ज़न नहीं किया जाता क्योंकि तब कंपाइलर को भिन्नांश भाग हटाना पड़ेगा, जिससे जानकारी का नुकसान होगा।

Python में एक्स्प्लिसिट डेटा टाइप कन्वर्ज़न

एक्स्प्लिसिट डेटा टाइप कन्वर्ज़न, जिसे अक्सर टाइप कास्टिंग कहा जाता है, तब होता है जब आप जानबूझकर किसी मान को एक डेटा टाइप से दूसरे में बदलते हैं। यह तरीका आपको कन्वर्ज़न पर प्रत्यक्ष नियंत्रण देता है, क्योंकि आप अपने कोड में लक्ष्य डेटा टाइप को स्पष्ट रूप से निर्दिष्ट करते हैं। जब Python द्वारा दी गई स्वचालित (इम्प्लिसिट) कन्वर्ज़न आपकी आवश्यकताओं को पूरा नहीं करती, तब इसका आमतौर पर उपयोग किया जाता है।

एक्स्प्लिसिट कन्वर्ज़न का सिंटैक्स है:

target_data_type(expression)

उदाहरण के लिए, यदि आप किसी floating-point संख्या को integer में बदलना चाहते हैं, तो आप लिखेंगे:

int(3.14)  # Converts 3.14 to 3

नोट: यद्यपि एक्स्प्लिसिट कन्वर्ज़न बहुत उपयोगी हैं, वे जानकारी के नुकसान का कारण बन सकती हैं। उदाहरण के लिए, किसी floating-point संख्या को integer में बदलने से उसका भिन्नांश भाग हट जाएगा। अपने प्रोग्राम में अनचाहे परिणामों से बचने के लिए इन परिणामों को समझना महत्वपूर्ण है।

आइए कुछ सामान्य एक्स्प्लिसिट डेटा टाइप कन्वर्ज़न देखें।

Python में प्रिमिटिव बनाम नॉन-प्रिमिटिव डेटा संरचनाएँ

प्रिमिटिव डेटा संरचनाएँ डेटा संसाधन के बुनियादी निर्माण खंड हैं और इनमें शुद्ध, सरल डेटा मान होते हैं। Python में चार प्रिमिटिव वेरिएबल टाइप हैं:

• Integers
• Float
• Strings
• Boolean

नॉन-प्रिमिटिव डेटा संरचनाएँ केवल एक मान नहीं, बल्कि विभिन्न प्रारूपों में मानों के संग्रह को संग्रहीत करती हैं। Python में आपके पास निम्नलिखित नॉन-प्रिमिटिव डेटा संरचनाएँ हैं:

• Lists
• Tuples
• Dictionaries
• Sets

इनके बारे में और जानने के लिए DataCamp का Data Structures in Python Tutorial देखें।

प्रिमिटिव डेटा संरचनाओं के कन्वर्ज़न

Python में integer और float कन्वर्ज़न

Integers और floats वे डेटा टाइप हैं जो संख्याओं से संबंधित हैं।

किसी integer को float में कन्वर्ट करने के लिए Python में float() फ़ंक्शन का उपयोग करें। इसी तरह, यदि आप किसी float को integer में कन्वर्ट करना चाहते हैं, तो आप int() फ़ंक्शन का उपयोग कर सकते हैं।

a_int = 3
b_int = 2

# Explicit type conversion from int to float
c_float_sum = float(a_int + b_int)
print(c_float_sum)

5.0

a_float = 3.3
b_float = 2.0

# Explicit type conversion from float to int
c_int_sum = int(a_float + b_float)
print(c_int_sum)

c_float_sum = a_float + b_float
print(c_float_sum)

5
5.3

Float प्रिसिशन समस्याएँ और Decimal मॉड्यूल

Python में floating-point अंकगणित प्रिसिशन समस्याओं का कारण बन सकता है:

print(0.1 + 0.2)  # Output: 0.30000000000000004

इसे टालने के लिए, Decimal मॉड्यूल का उपयोग करें:

from decimal import Decimal

print(Decimal('0.1') + Decimal('0.2'))  # Output: 0.3

Python में real से complex डेटा टाइप कन्वर्ज़न

आप complex(real,imag) का उपयोग करके integers को complex संख्याओं में कन्वर्ट कर सकते हैं। यह दो integers (वास्तविक और काल्पनिक भाग) लेता है और वास्तविक संख्याओं को complex संख्याओं में बदल देता है।

real = 2
imag = 5
print(complex(real, imag))

(2+5j)

Python में strings के साथ डेटा टाइप कन्वर्ज़न

एक string एक या अधिक अक्षरों (अक्षर, संख्याएँ, प्रतीक) का संग्रह होती है। आपको अक्सर strings को संख्याओं में या संख्याओं को strings में बदलने की आवश्यकता पड़ सकती है।

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + total  + "$")

 
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-54bd76b9b4bd> in <module>()
      2 price_cookie = 6
      3 total = price_cake + price_cookie
----> 4 print("The total is: " + total  + "$")


TypeError: Can't convert 'int' object to str implicitly

उपरोक्त उदाहरण एक TypeError देता है, जो बताता है कि कंपाइलर integer मान को इम्प्लिसिट रूप से string में कन्वर्ट नहीं कर सकता।

यहाँ प्रोग्राम को क्या करना चाहिए, यह आपको सहज लग सकता है। हालाँकि, कंपाइलर को हमेशा यकीन नहीं होता, इसलिए यह एक्स्प्लिसिट टाइप कास्टिंग का तंत्र देता है ताकि आप स्पष्ट रूप से बता सकें कि आप क्या चाहते हैं। Python में str() फ़ंक्शन का उपयोग करके आप integer को string में इस तरह कन्वर्ट कर सकते हैं:

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + str(total)  + "$")

The total is: 21$

float को string में बदलते समय भी यही तरीका काम करता है।

Python में आप जहाँ संभव हो, strings को integer और float मानों में भी कन्वर्ट कर सकते हैं। आइए देखें इसका मतलब क्या है:

price_cake = '15'
price_cookie = '6'

# String concatenation
total = price_cake + price_cookie
print("The total is: " + total + "$")

# Explicit type conversion to integer
total = int(price_cake) + int(price_cookie)
print("The total is: " + str(total)  + "$")

The total is: 156$
The total is: 21$

आइए कोड को समझें।

price_cake और price_cookie शुरू में strings हैं। फिर आपको कुल निकालना है, यानी पहले इन्हें उनके संबंधित integer मानों में बदलना होगा। अन्यथा, कंपाइलर मानेगा कि आप जो ऑपरेशन करना चाहते हैं वह संख्यात्मक जोड़ के बजाय string concatenation है। फिर आपको इस मान को अंतिम डिस्प्ले string में डालना है और परिणामस्वरूप शेष संदेश के साथ जोड़ने के लिए total को string में बदलना होगा।

उम्मीद है, यह उदाहरण आपको डेटा टाइप कन्वर्ज़न के महत्व को दिखाता है। यह भले ही बहुत छोटा उदाहरण है, फिर भी आप देख सकते हैं कि यह कितना उपयोगी हो सकता है।

नोट: क्या आपने strings को integers या float में बदलते समय "जहाँ संभव हो" पर ध्यान दिया? इसका कारण यह है कि हमेशा strings को संख्याओं में बदलना और उन पर संख्यात्मक ऑपरेशन करना संभव नहीं होता। कंपाइलर इससे अवगत है और जब आप ऐसा करने की कोशिश करेंगे तो वह आपको त्रुटि देगा। नीचे का उदाहरण देखें:

price_cake = 'fifteen'
price_cookie = 'six'
total = int(price_cake) + int(price_cookie)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-25-80591b8accda> in <module>()
      1 price_cake = 'fifteen'
      2 price_cookie = 'six'
----> 3 total = int(price_cake) + int(price_cookie)


ValueError: invalid literal for int() with base 10: 'fifteen'

सारांश: Python में प्रिमिटिव डेटा टाइप कन्वर्ज़न

नॉन-प्रिमिटिव डेटा संरचनाओं के कन्वर्ज़न

Python में tuples और lists के लिए टाइप कन्वर्ज़न

Integers और floats की तरह, आप lists को tuples में और tuples को lists में भी कन्वर्ट कर सकते हैं।

याद है tuples और lists क्या हैं? Python में Lists और Tuples का उपयोग समान प्रकार के आइटमों के संग्रह को संग्रहीत करने के लिए किया जाता है। tuples और lists के बीच अंतर यह है कि tuples अपरिवर्तनीय (immutable) होते हैं, यानी एक बार परिभाषित होने के बाद आप इनमें कोई मान हटा, जोड़ या संपादित नहीं कर सकते।

आप lists को tuples में क्यों कन्वर्ट करेंगे?

क्योंकि tuples अपरिवर्तनीय डेटा टाइप हैं और आपके बनाए प्रोग्रामों में पर्याप्त अनुकूलन की अनुमति देते हैं।

और आप tuples को lists में क्यों कन्वर्ट करेंगे?

शायद आप प्रारंभिक tuple में परिवर्तन करना चाहते हैं। तब आप उन्हें lists में कन्वर्ट कर सकते हैं, बदलाव करें, और फिर उन्हें वापस tuples में कन्वर्ट कर दें।

Python में, आप tuple() फ़ंक्शन का उपयोग करके दिए गए मान का tuple संस्करण प्राप्त कर सकते हैं, और उसी तरह list() फ़ंक्शन का उपयोग करके tuple को list में कन्वर्ट कर सकते हैं:

a_tuple = ('a', 1) ,('f', 2), ('g', 3)
b_list = [1,2,3,4,5]

print(tuple(b_list))
print(list(a_tuple))

(1, 2, 3, 4, 5)
[('a', 1), ('f', 2), ('g', 3)]

इसी तरह, Python में किसी string को list या tuple में इस प्रकार कन्वर्ट किया जा सकता है:

dessert = 'Cake'

# Convert the characters in a string to individual items in a tuple
print(tuple(dessert))

# Convert a string into a list
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)

('C', 'a', 'k', 'e')
['C', 'a', 'k', 'e', 's']

Python में dictionaries और sets के लिए टाइप कन्वर्ज़न

आप dict() फ़ंक्शन का उपयोग करके किसी tuple को dictionary में और set() का उपयोग करके किसी list को set में कन्वर्ट कर सकते हैं। 

print(dict(a_tuple))
print(set(b_list))

{'a': 1, 'f': 2, 'g': 3}
{1, 2, 3, 4, 5}

अन्य कन्वर्ज़न फ़ंक्शंस की तरह, आपको किसी भी datatype को dictionaries और sets में कन्वर्ट करने के लिए केवल फ़ंक्शन का नाम देना होता है।

संरचित डेटा के लिए dataclasses का उपयोग (Python 3.7+)

dictionaries या tuples के बजाय, dataclasses संरचित डेटा को संभालने का बेहतर तरीका प्रदान करते हैं।

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    in_stock: bool

item = Product("Laptop", 799.99, True)
print(item)  # Output: Product(name='Laptop', price=799.99, in_stock=True)

सारांश: Python में नॉन-प्रिमिटिव डेटा संरचनाओं के कन्वर्ज़न

Unicode, बाइनरी, ऑक्टल और हेक्साडेसिमल इंटीजर Python में

संख्या प्रणालियाँ उन प्रतीकों या अक्षरों की संख्या को दर्शाती हैं जो किसी भी संख्यात्मक मान का प्रतिनिधित्व करते हैं। रोज़मर्रा में आप जिस संख्या प्रणाली का उपयोग करते हैं उसे दशमलव (decimal) कहते हैं। दशमलव प्रणाली में आप दस विभिन्न प्रतीकों का उपयोग करते हैं: 0, 1, 2, 3, 4, 5, 6, 7, 8 और 9। इन दस प्रतीकों के साथ आप किसी भी मात्रा का प्रतिनिधित्व कर सकते हैं। Unicode, बाइनरी, हेक्साडेसिमल और ऑक्टल अलग-अलग संख्या प्रणालियों को संदर्भित करते हैं।

जब आपके प्रतीक समाप्त हो जाते हैं तो आप अगले अंक स्थान पर जाते हैं। दशमलव प्रणाली में, 9 से एक अधिक को दर्शाने के लिए आप 10 का उपयोग करते हैं, जिसका अर्थ है एक दहाई और इकाई में शून्य। हालाँकि, अन्य संख्या प्रणालियों में यह अलग होता है। उदाहरण के लिए, बाइनरी प्रणाली में जो केवल दो प्रतीकों 0 और 1 का उपयोग करती है, प्रतीक समाप्त होने पर आपको अगले अंक स्थान पर जाना पड़ता है। तो आप बाइनरी में इस तरह गिनेंगे: 0, 1, 10, 11, 100, 101, आदि।

आइए अगली धाराओं में कुछ संख्या प्रणालियों को और विस्तार से देखें।

Python में बाइनरी को दशमलव में कन्वर्ट करना

बाइनरी इंटीजर बेस दो के साथ दर्शाए गए नंबर होते हैं। यानी बाइनरी संख्या प्रणाली में केवल दो प्रतीकों 0 और 1 का उपयोग किया जाता है। जब आप बाइनरी में शून्य से ऊपर गिनते हैं, तो आप जल्दी ही प्रतीकों से बाहर हो जाते हैं: 0, 1, ???

आगे और कोई प्रतीक नहीं बचता। आप 2 पर नहीं जाते क्योंकि बाइनरी में 2 होता ही नहीं। इसके बजाय, आप 1 और 0 का विशेष संयोजन उपयोग करते हैं। बाइनरी प्रणाली में 1000, दशमलव में 8 के बराबर है। बाइनरी में आप दो की घातों का उपयोग करते हैं, यानी 8 मूलतः: (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0)) = 8। 1 और 0 की स्थिति यह परिभाषित करती है कि 2 को किस घात तक उठाना है।

इसे स्पष्ट करने के लिए एक अधिक जटिल उदाहरण देखें:

Binary Number = 1001111
Decimal value = (1*(2^6)) + (0*(2^5)) + (0*(2^4)) + (1*(2^3)) + (1*(2^2)) + (1*(2^1)) + (1*(2^0))
              = 79

Python में, आप bin() फ़ंक्शन का उपयोग करके किसी दशमलव मान को उसके संबंधित बाइनरी मान में कन्वर्ट कर सकते हैं।

इसी तरह, int() फ़ंक्शन का उपयोग बाइनरी को उसके दशमलव मान में कन्वर्ट करने के लिए किया जा सकता है। int() फ़ंक्शन का दूसरा आर्ग्युमेंट कन्वर्ट की जाने वाली संख्या का बेस लेता है, जो बाइनरी संख्याओं के मामले में 2 है।

a = 79

# Base 2(binary)
bin_a = bin(a)
print(bin_a)
print(int(bin_a, 2)) #Base 2(binary)

0b1001111
79

Python में ऑक्टल को दशमलव में कन्वर्ट करना

ऑक्टल एक और संख्या प्रणाली है जिसमें पारंपरिक दशमलव प्रणाली की तुलना में कम प्रतीक होते हैं। यह बेस आठ है, यानी आठ प्रतीकों का उपयोग सभी मात्राओं का प्रतिनिधित्व करने के लिए किया जाता है। ये हैं 0, 1, 2, 3, 4, 5, 6, और 7। 7 के बाद 10 आता है क्योंकि 8 मौजूद नहीं होता।

जिस तरह आपने बाइनरी में किसी संख्या के मान को निर्धारित करने के लिए दो की घातों का उपयोग किया, उसी तरह यहाँ आप 8 की घातों का उपयोग करेंगे क्योंकि यह बेस आठ है।

बाइनरी प्रणाली में, 10 ऑक्टल में 8 के बराबर होता है। इसे तोड़कर देखें: (1(8^1)) + (0(8^0)) = 8।

एक अधिक जटिल उदाहरण:

Octal Number = 117
Decimal value = (1*(8^2)) + (1*(8^1)) + (7*(8^0))
              = 79

Python में, आप oct() फ़ंक्शन का उपयोग करके किसी दशमलव मान को उसके संबंधित ऑक्टल मान में कन्वर्ट कर सकते हैं। वैकल्पिक रूप से, आप int() फ़ंक्शन और सही बेस (ऑक्टल के लिए 8) का उपयोग भी कर सकते हैं।

a = 79

# Base 8(octal)
oct_a = oct(a)
print(oct_a)
print(int(oct_a, 8))

0o117
79

Python में हेक्साडेसिमल को दशमलव में कन्वर्ट करना

हेक्साडेसिमल बेस 16 संख्या प्रणाली है। बाइनरी और ऑक्टल के विपरीत, यह दशमलव प्रणाली की संख्याओं से आगे छह अतिरिक्त प्रतीकों का उपयोग करती है।

लेकिन 9 के बाद क्या आता है?

जब सामान्य संख्यात्मक मानों से आगे अतिरिक्त प्रतीकों की आवश्यकता होती है, तो अक्षरों का उपयोग किया जाएगा। इसलिए हेक्साडेसिमल में प्रतीकों की पूरी सूची है 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E और F।

पहले वाले ही उदाहरण का उपयोग करते हुए:

Hexadecimal Number = 4F
Decimal value = (4*(16^1)) + (F*(16^0))
              = 79

Python में, आप hex() फ़ंक्शन का उपयोग करके किसी दशमलव मान को उसके संबंधित हेक्साडेसिमल मान में, या हेक्साडेसिमल के लिए बेस 16 के साथ int() फ़ंक्शन का उपयोग कर सकते हैं।

a = 79

# Base 16(hexadecimal)
hex_a = hex(a)
print(hex_a)
print(int(hex_a, 16))

0x4f
79

Unicode को अक्षर में कन्वर्ट करना

Python का chr() unicode integers को string में कन्वर्ट करता है। Unicode विविध भाषाओं के लिखित पाठों को प्रदर्शित करने के लिए सार्वभौमिक रूप से स्वीकृत कैरेक्टर कोडिंग है।

हमने “DATACAMP” प्रदर्शित करने के लिए chr() फ़ंक्शन को विभिन्न Unicode integers दिए हैं। आप ord() का उपयोग करके किसी एकल अक्षर को Unicode integer में भी कन्वर्ट कर सकते हैं। 

print(
    chr(68),
    chr(65),
    chr(84),
    chr(65),
    chr(67),
    chr(65),
    chr(77),
    chr(80),
)

D A T A C A M P

सारांश: Python में संख्या प्रणालियों के कन्वर्ज़न

आपने कर दिखाया!

बधाई! आपने Python में डेटा टाइप कन्वर्ज़न के बारे में सीखा, मुख्यतः बिल्ट-इन मेथड्स का उपयोग करते हुए। यह आपको विभिन्न डेटा टाइप्स के साथ काम करने में अधिक लचीलापन देगा और आपके प्रोग्राम लिखते समय मदद करेगा।

हमारा एक उत्कृष्ट कोर्स है Intermediate Python for Data Science पर, जहाँ आप matplotlib का उपयोग करके अपने डेटा को प्लॉट करना, और dictionaries तथा प्रसिद्ध pandas DataFrame के साथ काम करना सीखेंगे। आप यह भी देखेंगे कि लूप्स के साथ अपने प्रोग्राम के फ्लो को कैसे नियंत्रित किया जा सकता है। कोर्स के अंत में एक केस स्टडी भी है जहाँ आप जो कुछ सीखा है उसे लागू कर सकते हैं और अपने ज्ञान को अभ्यास में ला सकते हैं!