पायथन चलाने के दो तरीके: इंटरैक्टिव और स्क्रिप्ट मोड
इंटरैक्टिव मोड: >>> के बाद एक कथन लिखें, पायथन तुरंत उत्तर देता है। छोटी चीज़ें जाँचने के लिए अच्छा। कुछ सहेजा नहीं जाता।
स्क्रिप्ट मोड: कई पंक्तियाँ .py वाली फ़ाइल में लिखें, सहेजें और चलाएँ (IDLE में F5)। असली प्रोग्रामों के लिए; बार-बार चला सकते हैं।
प्रोग्राम की संरचना और इंडेंटेशन
पायथन प्रोग्राम कथनों की सूची है, जो ऊपर से नीचे चलते हैं। टिप्पणी # से शुरू होती है; पायथन उसे छोड़ देता है, पर इंसानों को कोड समझने में मदद मिलती है।
जो पंक्ति कोलन : पर ख़त्म हो (जैसे if, for, while) वह एक ब्लॉक शुरू करती है। ब्लॉक की हर पंक्ति बराबर दूरी, आमतौर पर 4 स्पेस, दाएँ खिसकी होनी चाहिए। इसे इंडेंटेशन कहते हैं। पायथन कोष्ठक की जगह इसी का उपयोग करता है। गलत इंडेंटेशन पर IndentationError आता है।
if marks >= 33:
print("Pass")
else:
print("Try again")
पहचानकर्ता, कीवर्ड, स्थिरांक और वेरिएबल
कीवर्ड आरक्षित शब्द हैं जिनका अर्थ तय है: if, else, elif, for, while, True, False, None, and, or, not, in, is, def, import आदि। इन्हें नाम नहीं बना सकते।
पहचानकर्ता (identifier) वह नाम है जो आप वेरिएबल या फ़ंक्शन को देते हैं। नियम: केवल अक्षर, अंक और _; अंक से शुरू नहीं; कोई स्पेस या चिह्न नहीं; कीवर्ड नहीं; छोटे-बड़े अक्षर अलग (Marks और marks अलग)। सही: total_marks, _x, mark2। गलत: 2mark, total marks, if।
वेरिएबल वह नाम है जो मेमोरी में किसी मान की ओर इशारा करता है: age = 16। पायथन मान से प्रकार खुद समझ लेता है; घोषणा नहीं करनी पड़ती। = का अर्थ है "इस नाम को इस मान से बाँधो", "बराबर" नहीं।
स्थिरांक वह मान है जो बदलना नहीं चाहिए। पायथन में असली स्थिरांक नहीं होते; परंपरा से नाम बड़े अक्षरों में लिखते हैं: PI = 3.14। सीधे लिखे मान (10, "hi", 3.5) लिटरल कहलाते हैं।
डेटा प्रकार
- संख्याएँ:
int(पूर्णांक: 7, −3),float(दशमलव: 7.5),complex(3+4j)। - bool:
TrueयाFalse। - str (स्ट्रिंग): उद्धरण चिह्नों में टेक्स्ट,
"Ravi"। - list: क्रमबद्ध, बदलने योग्य,
[1, 2, 3]। - tuple: क्रमबद्ध, न बदलने योग्य,
(1, 2, 3)। - dict: कुंजी-मान जोड़े,
{"roll": 5}। - None: "कोई मान नहीं"।
प्रकार देखने के लिए type(x)।
परिवर्तनशील (mutable) और अपरिवर्तनशील (immutable) प्रकार
परिवर्तनशील: उसी वस्तु को वहीं बदल सकते हैं। list, dict (और set)।
अपरिवर्तनशील: वहीं नहीं बदल सकते। int, float, bool, str, tuple। "बदलने" पर पायथन नया मान बनाता है और नाम की पर्ची खिसका देता है। उदाहरण: s = "cat"; s[0] = "b" पर TypeError, पर L = [1,2]; L[0] = 9 चलता है।
ऑपरेटर और प्राथमिकता
- अंकगणितीय:
+ - * /(हमेशा float),//(फ़्लोर भाग),%(शेषफल),**(घात)। - संबंधात्मक:
== != < > <= >=, True/False देते हैं। - तार्किक:
not, and, or। - असाइनमेंट:
= += -= *= /= //= %= **=। - पहचान (identity):
is, is not(एक ही वस्तु?)। - सदस्यता (membership):
in, not in("a" in "cat"→ True)।
व्यंजक (expression) मानों, वेरिएबल और ऑपरेटरों का ऐसा मेल है जो एक मान देता है, जैसे 2 + 3 * 4।
प्राथमिकता (ऊँची से नीची)
()**(दाएँ से बाएँ)- एकल
+x -x * / // %+ -- संबंधात्मक
== != < > <= >=,is,in notandor
एक ही स्तर: बाएँ से दाएँ (** को छोड़कर)।
इनपुट और आउटपुट
input("संदेश") संदेश दिखाता है, उपयोगकर्ता का इंतज़ार करता है और हमेशा स्ट्रिंग लौटाता है।
print(a, b, sep=" ", end="\n") मान दिखाता है। sep मानों के बीच, end आख़िर में लगता है।
name = input("नाम: ")
print("नमस्ते", name, sep=", ", end="!\n")
प्रकार रूपांतरण (type conversion)
स्पष्ट (explicit), आप करवाते हैं: int("25") → 25, float("2.5") → 2.5, str(10) → "10", int(7.9) → 7 (दशमलव कट जाता है)। int("abc") पर ValueError।
अंतर्निहित (implicit), पायथन खुद करता है: 3 + 2.0 → 5.0 (int, float बन जाता है ताकि डेटा न खोए)।
input() स्ट्रिंग देता है, इसलिए गणित के लिए age = int(input("उम्र: ")) लिखें।
डिबगिंग: तीन तरह की त्रुटियाँ
- सिंटैक्स त्रुटि: व्याकरण के नियम टूटे। पायथन शुरू ही नहीं होगा। उदाहरण:
print("hi"(कोष्ठक छूटा), कोलन छूटा, गलत इंडेंटेशन। - रनटाइम त्रुटि (exception): व्याकरण ठीक है पर चलते समय कुछ विफल होता है। उदाहरण:
10 / 0(ZeroDivisionError),int("abc")(ValueError), बिना बनाया नाम (NameError)। - तार्किक त्रुटि: प्रोग्राम चलता है पर उत्तर गलत देता है। उदाहरण:
(a + b) / 2की जगहa + b / 2। ढूँढना सबसे कठिन, क्योंकि कोई संदेश नहीं आता।
डिबगिंग यानी त्रुटियाँ ढूँढना और ठीक करना: त्रुटि संदेश और पंक्ति संख्या पढ़ें, बीच में मान print करें, और छोटे जाने-पहचाने इनपुट से जाँचें।
करके देखें: चलाने से पहले अनुमान
पायथन खोलें (IDLE या कोई ऑनलाइन पायथन)। Enter दबाने से पहले हर एक का अनुमान लिखें: 7 // 2, 7 % 2, 2 ** 3 ** 2, "5" + "2", int("5") + 2, 10 / 5। फिर चलाएँ। हर गलत अनुमान पर 3D का कदम 6 खोलें और वही व्यंजक हल होते देखें।
मुख्य सूत्र और परिभाषाएँ
- a // b = a ÷ b का फ़्लोर; a % b = शेषफल; a == (a // b) * b + a % b
- / हमेशा float देता है: 10 / 5 = 2.0
- प्राथमिकता: () > ** > एकल > * / // % > + - > संबंधात्मक > not > and > or
- input() str देता है; int(), float() से बदलें
हल किए गए उदाहरण
1. 2 + 3 * 4 ** 2 का मान निकालें।
पहले **: 4 ** 2 = 16। फिर 3 * 16 = 48। फिर 2 + 48 = 50।
2. 17 // 5 और 17 % 5 निकालें।
17 ÷ 5 = 3, शेष 2। तो 17 // 5 = 3 और 17 % 5 = 2। जाँच: 3 × 5 + 2 = 17।
3. 2 ** 3 ** 2 निकालें।
** दाएँ से बाएँ: 3 ** 2 = 9, फिर 2 ** 9 = 512 (64 नहीं)।
4. क्या छपेगा? x = 5; x += 3; x *= 2; print(x)
x = 5 → 8 → 16। 16 छपेगा।
5. not 5 > 3 and 2 == 2 निकालें।
पहले तुलना: 5 > 3 = True, 2 == 2 = True। फिर not True = False। फिर False and True = False।
6. a = input("दें: ") और उपयोगकर्ता 4 टाइप करता है। a * 3 क्या है?
a स्ट्रिंग "4" है, इसलिए a * 3 = "444" (स्ट्रिंग दोहराई गई)। 12 के लिए int(a) * 3 लिखें।
7. त्रुटि का प्रकार बताएँ: m1 = 80, m2 = 60 के लिए avg = m1 + m2 / 2।
प्रोग्राम चलता है और 80 + 30 = 110 देता है, जो गलत है। यह तार्किक त्रुटि है। सुधार: avg = (m1 + m2) / 2 = 70.0।
आम गलतियाँ
- भूल जाना कि input() स्ट्रिंग देता है, तो "4" + "5" = "45"।
- 2 ** 3 ** 2 = 64 समझना। घात दाएँ से बाएँ: 512।
- तुलना (==) की जगह असाइन (=) लिखना।
- टैब और स्पेस मिलाना या कोलन के बाद इंडेंट करना भूलना।