पाइथन (Python) - मूल अवधारणाएँ — अध्ययन नोट्स

1. परिचय

पाइथन (Python) एक उच्च-स्तरीय, सामान्य-उद्देश्य वाली प्रोग्रामिंग भाषा है जिसे गिडो वैन रोसुम ने 1991 में विकसित किया था। यह एक व्याख्यात्मक (Interpreted) भाषा है, जिसका अर्थ है कि इसका कोड बिना संकलन (Compilation) के सीधे लाइन-दर-लाइन निष्पादित होता है। पाइथन अपनी सरल और पठनीय वाक्यरचना (Syntax) के कारण दुनिया भर में बेहद लोकप्रिय है। इसे अक्सर 'सबसे आसान प्रोग्रामिंग भाषा' कहा जाता है, क्योंकि इसका कोड अंग्रेजी के समान दिखता है। पाइथन का उपयोग वेब विकास, डेटा विज्ञान, कृत्रिम बुद्धिमत्ता, सॉफ्टवेयर विकास, ऑटोमेशन और कई अन्य क्षेत्रों में होता है। कक्षा 10 के पाठ्यक्रम में पाइथन की मूलभूत अवधारणाओं का परिचय दिया जाता है, जो आगे के अध्ययन की नींव तैयार करता है।

2. पाइथन की विशेषताएँ (Features of Python)

• सरल और पठनीय (Simple and Readable): कोड को समझना और लिखना आसान है।
• इंटरप्रिटेड (Interpreted): कोड बिना संकलन के निष्पादित होता है।
• ऑब्जेक्ट-ओरिएंटेड: वस्तु-आधारित प्रोग्रामिंग का समर्थन करती है।
• डायनामिक टाइपिंग: चर का डेटा प्रकार घोषित करना आवश्यक नहीं।
• पोर्टेबल (Portable): एक सिस्टम पर लिखा कोड दूसरे पर भी चल सकता है।
• ओपन-सोर्स: निःशुल्क उपयोग और वितरण।
• विस्तृत लाइब्रेरी: अनेक अंतर्निहित मॉड्यूल और फंक्शन।
• स्वचालित मेमोरी प्रबंधन: मेमोरी को स्वतः प्रबंधित करती है।
• केस सेंसिटिव: बड़े और छोटे अक्षरों में अंतर करती है।

3. पाइथन में टोकन (Tokens in Python)

पाइथन प्रोग्राम के सबसे छोटे व्यक्तिगत घटक टोकन कहलाते हैं। टोकन के प्रकार:

• कीवर्ड (Keywords): आरक्षित शब्द जिनका विशेष अर्थ होता है, जैसे if, else, for, while, def, return, import, True, False, None।
• पहचानकर्ता (Identifiers): चर, फंक्शन, क्लास आदि के नाम। नियम: अक्षर या अंडरस्कोर से शुरू होना चाहिए, संख्या से नहीं; स्थान (space) नहीं हो सकता।
• ऑपरेटर (Operators): गणना के चिह्न, जैसे +, -, *, /, %, ==, >।
• लिटरल (Literals): स्थिर मान, जैसे 25, 3.14, "नमस्ते", True।
• पंक्चुएटर (Punctuators): चिह्न जैसे ( ) { } [ ] , : ;
• टिप्पणियाँ (Comments): # से शुरू होती हैं, निष्पादन में भाग नहीं लेतीं।

4. चर और डेटा प्रकार (Variables and Data Types)

पाइथन में चर को बिना प्रकार घोषित किए सीधे मान असाइन किया जाता है:

नाम = "राहुल"
आयु = 15
अंक = 85.5
विद्यार्थी = True

प्रमुख डेटा प्रकार:

• int: पूर्णांक, जैसे 25, -10
• float: दशमलव संख्या, जैसे 3.14, 85.5
• str: स्ट्रिंग (टेक्स्ट), जैसे "हैलो"
• bool: बूलियन, जैसे True, False
• list: सूची, जैसे [1, 2, 3]
• tuple: टपल, जैसे (1, 2, 3) (अपरिवर्तनीय)
• dict: शब्दकोश, जैसे {"नाम": "राहुल"}
• set: समुच्चय, जैसे {1, 2, 3}

डेटा प्रकार जानने के लिए type() फंक्शन का उपयोग होता है।

5. ऑपरेटर (Operators)

5.1 अंकगणितीय ऑपरेटर

• + जोड़, - घटाव, * गुणा, / भाग (दशमलव), // पूर्णांक भाग, % शेषफल, ** घातांक।

उदाहरण:

10 / 3 = 3.33
10 // 3 = 3
10 % 3 = 1
2 ** 3 = 8

5.2 तुलना ऑपरेटर

==, !=, >, <, >=, <= — परिणाम True या False होता है।

5.3 लॉजिकल ऑपरेटर

• and (दोनों सत्य), or (कोई एक सत्य), not (उल्टा)।

5.4 असाइनमेंट ऑपरेटर

=, +=, -=, *=, /= — जैसे x += 5 का अर्थ है x = x + 5।

5.5 सदस्यता ऑपरेटर (Membership)

• in और not in — किसी मान की उपस्थिति की जाँच के लिए।

6. इनपुट और आउटपुट (Input and Output)

6.1 print() फंक्शन (आउटपुट)

print("नमस्कार!")
print(नाम, आयु)  # कई मान

• स्ट्रिंग को उद्धरण चिह्नों में लिखा जाता है।
• कई मानों को कॉमा से अलग किया जाता है।

6.2 input() फंक्शन (इनपुट)

नाम = input("अपना नाम दर्ज करें: ")

• input() हमेशा स्ट्रिंग लौटाता है।
• संख्या चाहिए हो तो int() या float() से परिवर्तन करना पड़ता है:

आयु = int(input("आयु दर्ज करें: "))

7. सशर्त कथन (Conditional Statements)

7.1 if-else

if आयु >= 18:
    print("वयस्क")
else:
    print("नाबालिग")

7.2 if-elif-else

if अंक >= 90:
    ग्रेड = "A"
elif अंक >= 75:
    ग्रेड = "B"
else:
    ग्रेड = "C"

7.3 नेस्टेड if

if के अंदर दूसरा if भी लिखा जा सकता है। ध्यान दें कि पाइथन में इंडेंटेशन (Indentation) अत्यंत महत्वपूर्ण है, जो कोड के ब्लॉक को निर्धारित करता है।

8. लूप्स (Loops)

8.1 for लूप

सूची या श्रेणी में क्रम से चलने के लिए:

for i in range(1, 6):
    print(i)

• range(1, 6) = 1, 2, 3, 4, 5 (अंतिम मान शामिल नहीं)।
• range(5) = 0 से 4 तक।

8.2 while लूप

शर्त सत्य रहने तक चलता है:

i = 1
while i <= 5:
    print(i)
    i = i + 1

8.3 लूप नियंत्रण

• break: लूप को तुरंत समाप्त करता है।
• continue: वर्तमान चक्र छोड़कर अगले चक्र पर जाता है।
• else: लूप सामान्य रूप से समाप्त होने पर चलता है।

9. स्ट्रिंग्स (Strings)

स्ट्रिंग वर्णों का क्रम है:

नाम = "राहुल"
print(नाम[0])     # र
print(नाम[0:3])   # राह (स्लाइसिंग)
print(len(नाम))   # लंबाई

• इंडेक्सिंग 0 से शुरू होती है।
• स्लाइसिंग से स्ट्रिंग का हिस्सा निकाला जाता है।
• + स्ट्रिंग को जोड़ता है (कॉन्कैटनेशन) और * दोहराता है।
• len() स्ट्रिंग की लंबाई देता है।
• .upper() और .lower() केस बदलते हैं।

10. सूचियाँ (Lists)

सूची एक क्रमबद्ध, परिवर्तनीय संग्रह है:

फल = ["सेब", "आम", "केला"]
print(फल[0])        # सेब
फल.append("संतरा")  # अंत में जोड़ना
फल.remove("आम")     # हटाना
फल.sort()           # क्रमबद्ध करना
print(len(फल))      # लंबाई

• सूची की इंडेक्सिंग 0 से शुरू होती है।
• सूची परिवर्तनीय (Mutable) है।
• .append(), .insert(), .remove(), .sort() जैसी विधियाँ उपलब्ध हैं।

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

तालिका 1: डेटा प्रकार

तालिका 2: ऑपरेटर

तालिका 3: लूप नियंत्रण

माइंड मैप

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

इंडेक्सिंग और स्लाइसिंग

for लूप का कार्य

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

1. इंडेंटेशन (Indentation) का पालन न करना; पाइथन में ब्लॉक चार-स्थान के इंडेंट से तय होते हैं।
2. range(1, 6) को 1 से 6 तक समझना; अंतिम मान 6 शामिल नहीं होता, परिणाम 1 से 5 होता है।
3. input() से आने वाला मान स्ट्रिंग होता है; संख्याओं की गणना से पहले int()/float() से बदलना भूलना।
4. सूची की इंडेक्सिंग 1 से शुरू मानना; यह 0 से शुरू होती है।
5. = और == में भ्रम; = असाइन करता है और == तुलना करता है।
6. // और / में भ्रम; 10 / 3 = 3.33 जबकि 10 // 3 = 3।
7. टिप्पणी के लिए # का उपयोग न करना या सिंगल कोट/डबल कोट का मिलान न करना।
8. कीवर्ड को चर का नाम देना (जैसे if = 5), जो त्रुटि देता है।

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

1. ऑपरेटरों के परिणाम (जैसे 10 % 3, 2 ** 3) की गणना के प्रश्न अभ्यास करें।
2. आउटपुट आधारित प्रश्नों के लिए छोटे प्रोग्राम (for/while लूप) मानसिक रूप से चलाने का अभ्यास करें।
3. डेटा प्रकारों के उदाहरण और परिवर्तनीयता (mutable/immutable) याद रखें।
4. इनपुट-आउटपुट प्रोग्राम लिखने का अभ्यास करें, जैसे नाम और आयु लेकर संदेश दिखाना।
5. स्ट्रिंग इंडेक्सिंग और स्लाइसिंग के परिणाम जानें।
6. पहचानकर्ता के नियम (नाम अक्षर/अंडरस्कोर से शुरू, स्थान नहीं) रटें।
7. ब्रेक, कंटीन्यू और एल्स के साथ लूप के व्यवहार को समझें।

निष्कर्ष

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