पाइथन रिवीजन टूर - I — अध्ययन नोट्स

1. परिचय

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

पाइथन एक सरल, उच्च-स्तरीय, व्याख्यायित (interpreted) और ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा है। इसे गुइडो वैन रोसुम ने 1991 में विकसित किया था। पाइथन में इंडेंटेशन (indentation) का विशेष महत्व है - कोड ब्लॉक की पहचान रिक्ति से होती है।

2. पाइथन टोकन (Tokens)

टोकन पाइथन कोड की सबसे छोटी इकाइयाँ हैं। इन्हें मुख्यतः पाँच श्रेणियों में बाँटा जाता है:

1. कीवर्ड (Keywords): आरक्षित शब्द जिनका निश्चित अर्थ होता है। जैसे - if, else, while, for, def, return, import, class, try, except। इन्हें वेरिएबल के नाम के रूप में उपयोग नहीं कर सकते।
2. पहचानकर्ता (Identifiers): वेरिएबल, फलन या क्लास के नाम। जैसे - student_name, marks1, total। पहचानकर्ता का पहला वर्ण अक्षर या _ होना चाहिए।
3. शाब्दिक (Literals): डेटा के स्थिर मान। जैसे - 100, 3.14, "नमस्ते", True।
4. ऑपरेटर (Operators): गणनाओं के चिह्न। जैसे - +, -, *, /, ==, and।
5. विरामचिह्न/पृथक्कारक (Punctuators): (, ), [, ], {, }, ,, : आदि।

# टोकन का उदाहरण
marks = 95 + 5   # marks, =, 95, +, 5 सभी टोकन हैं

3. वेरिएबल और असाइनमेंट (Variables and Assignment)

वेरिएबल मेमोरी में डेटा संग्रहीत करने का नामित स्थान है। पाइथन में वेरिएबल को घोषित करने की आवश्यकता नहीं होती - असाइनमेंट करते ही वेरिएबल बन जाता है।

name = "अनु"        # स्ट्रिंग वेरिएबल
age = 17             # पूर्णांक
percentage = 91.5    # फ्लोट
is_passed = True     # बूलियन

# एक साथ कई असाइनमेंट
a, b, c = 10, 20, 30

# एक ही मान कई वेरिएबलों को
x = y = z = 0

डेटा प्रकार (Data Types):

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

4. ऑपरेटर (Operators)

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

+, -, *, / (फ्लोट विभाजन), // (पूर्णांक विभाजन), % (मॉड्यूलो), ** (घातांक)।

print(10 // 3)    # 3 (पूर्णांक विभाजन)
print(10 / 3)     # 3.333...
print(10 % 3)     # 1 (शेषफल)
print(2 ** 4)     # 16 (घातांक)

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

==, !=, >, <, >=, <= - ये हमेशा बूलियन मान लौटाते हैं।

4.3 तार्किक ऑपरेटर

and, or, not - शर्तों को जोड़ने के लिए।

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

=, +=, -=, *=, /=, //=, %=, **=।

total = 10
total += 5    # total = 15
total *= 2    # total = 30

4.5 आइडेंटिटी और सदस्यता ऑपरेटर

• आइडेंटिटी: is, is not - ऑब्जेक्ट की पहचान की तुलना।
• सदस्यता: in, not in - तत्व की उपस्थिति की जाँच।

fruits = ["सेब", "आम"]
print("सेब" in fruits)      # True
print("केला" not in fruits)  # True

ऑपरेटर की प्राथमिकता:

कोष्ठक > घातांक (**) > गुणा-भाग-मॉड्यूलो > जोड़-घटाव > तुलना > तार्किक

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

5.1 print()

print() स्क्रीन पर आउटपुट प्रदर्शित करता है। sep और end तर्कों से प्रारूप नियंत्रित किया जा सकता है:

print("हैलो", "पाइथन")         # हैलो पाइथन
print("हैलो", "पाइथन", sep="-")  # हैलो-पाइथन
print("लाइन 1", end=" ")        # नई लाइन के बजाय स्पेस
print("लाइन 2")

5.2 input()

input() उपयोगकर्ता से इनपुट लेता है। डिफ़ॉल्ट रूप से यह स्ट्रिंग लौटाता है, इसलिए संख्या के लिए रूपांतरण आवश्यक है:

name = input("नाम दर्ज करें: ")      # स्ट्रिंग
age = int(input("आयु दर्ज करें: "))  # int में बदलना
marks = float(input("अंक: "))        # float में बदलना

6. फ्लो ऑफ कंट्रोल (Flow of Control)

6.1 निर्णयात्मक स्टेटमेंट (if-elif-else)

marks = int(input("अंक दर्ज करें: "))
if marks >= 90:
    grade = 'A'
elif marks >= 75:
    grade = 'B'
elif marks >= 60:
    grade = 'C'
else:
    grade = 'D'
print("ग्रेड:", grade)

6.2 लूप (Loops)

for लूप - क्रमबद्ध पुनरावृत्ति के लिए:

for i in range(1, 6):
    print(i, end=" ")   # 1 2 3 4 5

for char in "पाइथन":
    print(char)

while लूप - शर्त आधारित पुनरावृत्ति के लिए:

n = 5
total = 0
while n > 0:
    total += n
    n -= 1
print("योग:", total)   # 15

6.3 break, continue, pass

• break: लूप को तुरंत समाप्त करता है।
• continue: वर्तमान पुनरावृत्ति को छोड़कर अगली पर जाता है।
• pass: कोई कार्य नहीं करता, केवल स्थान भरता है।

for i in range(10):
    if i == 3:
        continue
    if i == 7:
        break
    print(i, end=" ")   # 0 1 2 4 5 6

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

स्ट्रिंग वर्णों की क्रमबद्ध श्रृंखला है। स्ट्रिंग में इंडेक्सिंग 0 से प्रारंभ होती है और ऋणात्मक इंडेक्स अंत से गिनते हैं।

s = "नमस्ते"
print(s[0])       # न
print(s[-1])      # ते
print(s[1:4])     # स्लाइसिंग
print(len(s))     # 6

स्ट्रिंग विधियाँ:

upper(), lower(), capitalize(), count(), find(), replace(), split(), join(), strip(), isdigit(), isalpha() आदि।

text = "  Python  "
print(text.strip())        # रिक्ति हटाना
print(text.upper())        # PYTHON
words = "a,b,c".split(",")
print(words)               # ['a', 'b', 'c']

8. नंबर सिस्टम (Number Systems)

पाइथन में संख्याएँ विभिन्न आधारों में लिखी जा सकती हैं: - दशमलव (Decimal): आधार 10 - बाइनरी (Binary): आधार 2, उपसर्ग 0b (जैसे 0b1010) - ऑक्टल (Octal): आधार 8, उपसर्ग 0o - हेक्साडेसिमल (Hexadecimal): आधार 16, उपसर्ग 0x

print(bin(10))    # 0b1010
print(hex(255))   # 0xff
print(int("101", 2))  # 5

9. स्ट्रिंग प्रारूपण (String Formatting)

किसी स्ट्रिंग में चरों के मान सम्मिलित करने के लिए प्रारूपण की सुविधाएँ उपयोग होती हैं। पाइथन में प्रारूपण के कई तरीके हैं:

9.1 f-string (आधुनिक विधि)

name = "अनु"
marks = 92.5
print(f"{name} को {marks} अंक मिले।")
# आउटपुट: अनु को 92.5 अंक मिले।

9.2 format() विधि

print("{} को {} अंक मिले।".format(name, marks))
print("{0} और {1}".format("पहला", "दूसरा"))

9.3 % प्रारूपण (पुरानी विधि)

print("%s को %0.1f अंक मिले।" % (name, marks))

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

10. स्ट्रिंग की अन्य महत्वपूर्ण विधियाँ

स्ट्रिंग विधियों के कुछ और महत्वपूर्ण उदाहरण:

text = "पाइथन प्रोग्रामिंग"

print(text.count("प"))          # वर्ण की आवृत्ति
print(text.find("प्र"))         # पहला अनुक्रमांक
print(text.replace("प्र", "सॉफ्ट"))  # भाग बदलना
print("123".isdigit())          # True - सभी अंक?
print("abc".isalpha())          # True - सभी अक्षर?
print(" ".join(["ए", "बी"]))    # "ए बी"
print(text.startswith("पाइ"))   # True
print(text.endswith("ग"))       # True

isdigit() और isalpha() इनपुट सत्यापन (validation) में उपयोगी होते हैं। join() सूची के तत्वों को जोड़कर स्ट्रिंग बनाता है, और split() इसका उल्टा करता है। इन विधियों का सही उपयोग जानना कोड-आउटपुट प्रश्नों के लिए आवश्यक है।

11. तुलना ऑपरेटर और बूलियन अभिव्यक्तियाँ

तुलना ऑपरेटर (==, !=, >, <, >=, <=) हमेशा बूलियन मान (True या False) लौटाते हैं। इन्हें तार्किक ऑपरेटरों के साथ जोड़कर जटिल शर्तें बनाई जा सकती हैं:

age = 17
marks = 92

if age >= 16 and marks >= 75:
    print("योग्य")          # योग्य

if age < 16 or marks < 33:
    print("अनुत्तीर्ण")     # नहीं चलेगा

if not age > 18:
    print("अवयस्क")         # अवयस्क

बूलियन अभिव्यक्तियों का क्रमबद्ध मूल्यांकन प्रोग्राम के तर्क को निर्धारित करता है। and में दोनों सत्य, or में एक सत्य, और not शर्त को उल्टा करता है। इनके साथ अभ्यास से निर्णय स्टेटमेंट वाले प्रश्न आसानी से हल होते हैं।

12. नंबर सिस्टम और रूपांतरण (Number Systems and Conversion)

पाइथन में बाइनरी, ऑक्टल और हेक्साडेसिमल संख्याओं के साथ कार्य करने के लिए अंतर्निहित फलन उपलब्ध हैं:

print(bin(25))      # 0b11001 - बाइनरी
print(oct(25))      # 0o31    - ऑक्टल
print(hex(25))      # 0x19    - हेक्साडेसिमल

# विभिन्न आधारों से दशमलव में
print(int("11001", 2))   # 25
print(int("31", 8))      # 25
print(int("19", 16))     # 25

कंप्यूटर स्मृति में सभी डेटा बाइनरी रूप में संग्रहीत होता है। दशमलव संख्या 25 को बाइनरी में बदलने के लिए उसे बार-बार 2 से भाग दिया जाता है और शेषफलों को उल्टे क्रम में लिखा जाता है। इस प्रकार 25 ÷ 2 से शेषफल 1, फिर 12 ÷ 2 से 0, 6 ÷ 2 से 0, 3 ÷ 2 से 1, और 1 ÷ 2 से 1 प्राप्त होता है, जिससे बाइनरी मान 11001 बनता है। नंबर सिस्टम की यह समझ कंप्यूटर विज्ञान की नींव है और परीक्षा के लघु उत्तरीय प्रश्नों में अक्सर पूछी जाती है।

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

डेटा प्रकार

ऑपरेटरों की श्रेणियाँ

माइंड मैप

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

आरेख 1: if-elif-else का प्रवाह

आरेख 2: for लूप की कार्यविधि

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

1. range की सीमा गलत समझना: range(1, 6) अंतिम मान 5 देता है, 6 नहीं। अंतिम मान सम्मिलित नहीं होता।
2. input() के साथ रूपांतरण भूलना: input() स्ट्रिंग लौटाता है; संख्या-गणना से पहले int()/float() करना अनिवार्य है।
3. / और // में अंतर न समझना: / फ्लोट परिणाम देता है (10/3 = 3.33), // पूर्णांक (10//3 = 3)।
4. स्ट्रिंग और संख्या का जोड़: "5" + 5 त्रुटि देता है (TypeError); पहले रूपांतरण करें।
5. इंडेंटेशन की गलती: पाइथन में कोड ब्लॉक की पहचान इंडेंटेशन से होती है; गलत रिक्ति से सिंटैक्स एरर आता है।
6. तार्किक ऑपरेटर का गलत उपयोग: and/or के स्थान पर &&/|| लिखना पाइथन में अमान्य है।
7. स्ट्रिंग अपरिवर्तनशीलता: स्ट्रिंग अपरिवर्तनशील है - s[0] = 'x' से त्रुटि आती है; नई स्ट्रिंग बनाना होता है।

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

1. सभी ऑपरेटरों और उनकी प्राथमिकता का क्रम याद रखें; वस्तुनिष्ठ प्रश्नों में प्राथमिकता आधारित मान पूछे जाते हैं।
2. कोड का आउटपुट लिखने के प्रश्नों के लिए प्रत्येक स्टेटमेंट का मान-दर-मान विश्लेषण करें।
3. print(10 // 3, 10 % 3, 10 / 3) जैसे मिश्रित प्रश्नों का अभ्यास करें।
4. स्ट्रिंग स्लाइसिंग (s[1:4], s[-1]) के उदाहरण हल करें।
5. range() के विभिन्न रूपों (range(5), range(2, 10), range(2, 10, 2)) का अभ्यास करें।
6. input और प्रकार रूपांतरण से जुड़े छोटे कार्यक्रम लिखें।

निष्कर्ष

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