पाइथन डेटा हैंडलिंग — Study Notes

1. परिचय

डेटा हैंडलिंग प्रोग्रामिंग का वह भाग है जिसमें हम डेटा को संग्रहीत करने, व्यवस्थित करने और संसाधित करने के तरीकों का अध्ययन करते हैं। पाइथन में डेटा हैंडलिंग का अर्थ विभिन्न डेटा प्रकारों (int, float, str, bool), उनके संचालन, रूपांतरण और एक्सप्रेशन को समझना है। इस अध्याय में हम पाइथन के मूल डेटा प्रकारों, ऑपरेटरों, एक्सप्रेशनों और म्यूटेबल (Mutable) तथा इम्यूटेबल (Immutable) वस्तुओं के बीच अंतर का विस्तृत अध्ययन करेंगे। डेटा हैंडलिंग की समझ प्रोग्राम के सही परिणाम देने के लिए अनिवार्य है, क्योंकि गलत डेटा प्रकार के साथ गणना करने पर त्रुटियाँ उत्पन्न होती हैं।

2. पाइथन के मूल डेटा प्रकार

पाइथन में डेटा प्रकारों को मुख्यतः चार श्रेणियों में रखा जा सकता है: संख्यात्मक (Numeric), अनुक्रम (Sequence), मैपिंग (Mapping) और सेट (Set)। इस अध्याय में हम मूलभूत प्रकारों पर ध्यान केंद्रित करेंगे।

संख्यात्मक डेटा प्रकार

• int (पूर्णांक): संपूर्ण संख्याएँ जिनमें कोई दशमलव बिंदु नहीं होता। उदाहरण: 10, -25, 0। पाइथन में पूर्णांकों की लंबाई पर कोई सीमा नहीं होती।
• float (दशमलव): दशमलव बिंदु वाली संख्याएँ। उदाहरण: 3.14, -2.5, 0.001। इन्हें वैज्ञानिक अंकन (Scientific Notation) में भी लिखा जा सकता है, जैसे 2.5e3 = 2500.0।
• complex: a + bj के रूप में, जहाँ b काल्पनिक भाग है। उदाहरण: 3 + 4j।

अनुक्रम (Sequence) प्रकार

• str (स्ट्रिंग): अक्षरों की क्रमबद्ध श्रृंखला। यह अपरिवर्तनीय (Immutable) होती है।
• list: परिवर्तनीय (Mutable) क्रमबद्ध संग्रह।
• tuple: अपरिवर्तनीय क्रमबद्ध संग्रह।

मैपिंग प्रकार

• dict (शब्दकोश): कुंजी-मान (Key-Value) युग्मों का संग्रह।

सेट और बूलियन

• set: अद्वितीय तत्वों का अक्रमबद्ध संग्रह।
• bool: True या False दो मान होते हैं। तकनीकी रूप से True = 1 और False = 0 माना जाता है।

x = 10
y = 3.14
z = "hello"
b = True
print(type(x), type(y), type(z), type(b))

3. म्यूटेबल और इम्यूटेबल वस्तुएँ

पाइथन की वस्तुओं को उनकी परिवर्तन क्षमता के आधार पर दो वर्गों में बाँटा गया है:

इम्यूटेबल (Immutable) - अपरिवर्तनीय

जिन वस्तुओं का मान निर्माण के बाद नहीं बदला जा सकता, उन्हें इम्यूटेबल कहते हैं। इनमें शामिल हैं: int, float, complex, bool, str, tuple, frozenset। जब हम किसी इम्यूटेबल वस्तु को बदलने का प्रयास करते हैं, तो नई वस्तु बनती है।

म्यूटेबल (Mutable) - परिवर्तनीय

जिन वस्तुओं का मान निर्माण के बाद बदला जा सकता है, उन्हें म्यूटेबल कहते हैं। इनमें शामिल हैं: list, dict, set। इनके तत्वों को बिना नई वस्तु बनाए संशोधित किया जा सकता है।

s = "hello"
t = s.upper()
print(s, t)

L = [1, 2, 3]
L.append(4)
print(L)

स्ट्रिंग अपरिवर्तनीय है, इसलिए upper() नई स्ट्रिंग बनाता है, जबकि लिस्ट परिवर्तनीय है, इसलिए append() उसी लिस्ट को बदल देता है।

4. स्ट्रिंग (String) हैंडलिंग

स्ट्रिंग एकल उद्धरण '...', दोहरे उद्धरण "..." या तिहरे उद्धरण '''...''' में लिखी जाती है। स्ट्रिंग पर निम्नलिखित संचालन संभव हैं:

स्ट्रिंग संयोजन और दोहराव

a = "पाइ" + "थन"
b = "AB" * 3
print(a, b)

स्ट्रिंग अनुक्रमण (Indexing) और स्लाइसिंग (Slicing)

स्ट्रिंग का प्रत्येक अक्षर एक सूचकांक (Index) रखता है जो 0 से प्रारंभ होता है। ऋणात्मक सूचकांक अंत से गिनती करता है।

s = "Python"
print(s[0])
print(s[-1])
print(s[0:4])
print(s[::-1])

• s[0] = 'P' (पहला अक्षर)
• s[-1] = 'n' (अंतिम अक्षर)
• s[0:4] = 'Pyth' (0 से 3 तक)
• s[::-1] = 'nohtyP' (उल्टा)

स्ट्रिंग फ़ंक्शन और मेथड

• len() - लंबाई
• upper() / lower() - ऊपरी/निचला केस
• capitalize() - पहला अक्षर बड़ा
• count(sub) - उप-स्ट्रिंग की संख्या
• find(sub) - पहली स्थिति
• strip() - सिरे से स्थान हटाना
• split() - स्ट्रिंग को सूची में विभाजित करना
• join() - सूची को स्ट्रिंग में जोड़ना

s = "  Hello World  "
print(len(s))
print(s.strip())
print(s.lower())
print("Hello World".split())

5. एक्सप्रेशन और ऑपरेटर

एक्सप्रेशन वेरिएबल, मान और ऑपरेटरों का संयोजन है जो एक मान का मूल्यांकन करता है। जैसे a + b * 2। ऑपरेटरों की प्राथमिकता एक्सप्रेशन के परिणाम को निर्धारित करती है। यदि किसी एक्सप्रेशन में समान प्राथमिकता के ऑपरेटर हों, तो सहयोगिता (Associativity) लागू होती है - अधिकांश ऑपरेटर बाएँ से दाएँ मूल्यांकन करते हैं, जबकि ** दाएँ से बाएँ।

result = 10 + 20 * 3
print(result)
result2 = (10 + 20) * 3
print(result2)

पहला परिणाम 70 होगा (20*3 पहले) और दूसरा 90 (कोष्ठक पहले)।

असाइनमेंट और स्वैपिंग

पाइथन में अनेक असाइनमेंट एक साथ कर सकते हैं और बिना तीसरे वेरिएबल के स्वैप कर सकते हैं।

a, b = 5, 10
a, b = b, a
print(a, b)

6. डेटा प्रकार रूपांतरण (Type Conversion)

इम्प्लिसिट रूपांतरण (Implicit)

पाइथन कुछ स्थितियों में स्वयं डेटा प्रकार बदलता है, जैसे int और float का जोड़ float देता है।

x = 5
y = 2.5
print(x + y)
print(type(x + y))

परिणाम 7.5 (float) होगा क्योंकि पाइथन ने इम्प्लिसिट रूप से int को float में बदल दिया।

एक्सप्लिसिट रूपांतरण (Explicit) - टाइप कास्टिंग

int(), float(), str(), bool(), list(), tuple(), set() फ़ंक्शनों द्वारा स्पष्ट रूपांतरण।

a = "42"
b = int(a)
c = float(a)
print(b, c)

n = 3.99
print(int(n))

int(3.99) का परिणाम 3 होगा (दशमलव भाग हट जाता है)। ध्यान दें कि स्ट्रिंग को पूर्णांक में बदलने के लिए स्ट्रिंग में वैध संख्या होनी चाहिए, अन्यथा ValueError उत्पन्न होगा।

7. ऑपरेटर विशेष मामले

स्ट्रिंग और संख्या का संयोजन

"10" + 5 एक TypeError उत्पन्न करेगा, क्योंकि स्ट्रिंग और पूर्णांक को + से जोड़ा नहीं जा सकता। सही विधि:

a = "10"
b = 5
print(int(a) + b)
print(a + str(b))

विभाजन के नियम

• / हमेशा float परिणाम देता है, चाहे ऑपरेंड पूर्णांक हों।
• // पूर्णांक भाग देता है।
• शून्य से भाग करने पर ZeroDivisionError आता है।

print(10 / 2)
print(10 // 2)

दोनों का आउटपुट 5.0 और 5 होगा।

8. गणितीय मॉड्यूल

पाइथन के math मॉड्यूल में अनेक गणितीय फ़ंक्शन होते हैं।

import math
print(math.sqrt(16))
print(math.pow(2, 3))
print(math.fabs(-5))
print(math.floor(3.7))
print(math.ceil(3.2))
print(math.factorial(5))
print(math.pi)
print(math.gcd(12, 18))

• sqrt(16) = 4.0
• pow(2, 3) = 8.0
• floor(3.7) = 3, ceil(3.2) = 4
• factorial(5) = 120
• gcd(12, 18) = 6

9. डेटा हैंडलिंग में त्रुटियाँ

• TypeError: गलत प्रकार के ऑपरेशन पर, जैसे "10" + 5।
• ValueError: वैध प्रकार परंतु अवैध मान, जैसे int("abc")।
• ZeroDivisionError: शून्य से भाग करने पर।
• NameError: अपरिभाषित वेरिएबल का उपयोग करने पर।
• IndexError: सूची/स्ट्रिंग की सीमा से बाहर के सूचकांक पर।

graph TD
    A["डेटा हैंडलिंग"] --> B["संख्यात्मक: int, float"]
    A --> C["स्ट्रिंग: str"]
    A --> D["बूलियन: bool"]
    B --> E["ऑपरेटर और एक्सप्रेशन"]
    C --> F["इंडेक्सिंग, स्लाइसिंग, मेथड"]
    A --> G["टाइप कास्टिंग"]
    A --> H["म्यूटेबल: list, dict, set"]
    A --> I["इम्यूटेबल: int, str, tuple"]
    G --> J["int(), float(), str()"]
    E --> K["प्राथमिकता और सहयोगिता"]

त्वरित पुनरावृत्ति तालिकाएँ

डेटा प्रकार	परिवर्तनीयता	उदाहरण
int	इम्यूटेबल	10
float	इम्यूटेबल	3.14
str	इम्यूटेबल	"hello"
bool	इम्यूटेबल	True
list	म्यूटेबल	[1, 2]
tuple	इम्यूटेबल	(1, 2)
dict	म्यूटेबल	{"a": 1}

स्ट्रिंग मेथड	कार्य	उदाहरण
len(s)	लंबाई	len("abc") = 3
s.upper()	बड़े अक्षर	"ab".upper() = "AB"
s.lower()	छोटे अक्षर	"AB".lower() = "ab"
s.count(x)	गिनती	"aba".count("a") = 2
s.find(x)	स्थिति	"abc".find("b") = 1
s.strip()	स्थान हटाना	" a ".strip() = "a"
s.split()	विभाजन	"a b".split() = ["a","b"]

टाइप कास्टिंग	उदाहरण	परिणाम
int("42")	स्ट्रिंग→पूर्णांक	42
float(5)	पूर्णांक→दशमलव	5.0
str(100)	संख्या→स्ट्रिंग	"100"
int(3.9)	दशमलव→पूर्णांक	3

माइंड मैप

flowchart TD
    A["पाइथन डेटा हैंडलिंग"] --> B["मूल डेटा प्रकार"]
    A --> C["स्ट्रिंग हैंडलिंग"]
    A --> D["एक्सप्रेशन"]
    A --> E["रूपांतरण"]
    A --> F["म्यूटेबल/इम्यूटेबल"]
    B --> G["int, float, str, bool"]
    C --> H["स्लाइसिंग, मेथड"]
    D --> I["ऑपरेटर प्राथमिकता"]
    E --> J["इम्प्लिसिट और एक्सप्लिसिट"]
    F --> K["list म्यूटेबल, str इम्यूटेबल"]
    A --> L["math मॉड्यूल"]

महत्वपूर्ण आरेख (SVG)

सामान्य गलतियाँ

1. "10" + 5 लिखना: स्ट्रिंग और संख्या को + से जोड़ने पर TypeError आता है; पहले int() से बदलें।
2. स्लाइसिंग में अंतिम सूचकांक समझना: s[0:4] में सूचकांक 4 शामिल नहीं होता, केवल 0 से 3 तक।
3. int("abc") करना: अवैध स्ट्रिंग को संख्या में बदलने पर ValueError आता है।
4. float को int में बदलने पर पूर्णांकन का भ्रम: int(3.9) = 3 (round नहीं करता, केवल दशमलव हटाता है)।
5. स्ट्रिंग को म्यूटेबल समझना: स्ट्रिंग इम्यूटेबल है; s[0] = 'x' लिखने पर त्रुटि आती है।
6. / और // के अंतर को भूलना: 10/2 = 5.0 (float) जबकि 10//2 = 5 (int)।
7. math मॉड्यूल को import किए बिना उपयोग करना: math.sqrt() से पहले import math अनिवार्य है।

परीक्षा युक्तियाँ

1. इम्यूटेबल और म्यूटेबल प्रकारों की सूची दोनों अलग-अलग याद करें; यह आम प्रश्न है।
2. int(3.9) का मान 3 है - "round" के साथ भ्रम न करें।
3. स्लाइसिंग नियम "end exclusive" (अंतिम सूचकांक शामिल नहीं) याद रखें।
4. math मॉड्यूल के प्रमुख फ़ंक्शन (sqrt, floor, ceil, factorial, gcd) के उदाहरण याद रखें।
5. टाइप कास्टिंग के प्रश्नों में स्ट्रिंग में वैध संख्या होनी चाहिए, अन्यथा ValueError।
6. 10/2 का परिणाम 5.0 लिखें, 5 नहीं; यह छोटा अंतर परीक्षा में मायने रखता है।

निष्कर्ष

डेटा हैंडलिंग पाइथन प्रोग्रामिंग का आधारभूत स्तंभ है। डेटा प्रकारों की प्रकृति (म्यूटेबल/इम्यूटेबल), स्ट्रिंग संचालन, टाइप कास्टिंग और एक्सप्रेशन मूल्यांकन की सही समझ किसी भी प्रोग्राम की सटीकता सुनिश्चित करती है। अगले अध्याय में हम इन्हीं डेटा प्रकारों पर निर्णय (if-else) और पुनरावृत्ति (loop) संरचनाएँ लागू करेंगे। छात्रों को सलाह है कि प्रत्येक डेटा प्रकार के लिए छोटे-छोटे प्रोग्राम लिखें और प्रत्येक ऑपरेटर के परिणाम की पुष्टि पाइथन शेल में करें। यह अभ्यास परीक्षा के प्रोग्रामिंग प्रश्नों को हल करने में अत्यंत सहायक होगा।