पाइथन मूल बातें — Study Notes

1. परिचय

"पाइथन मूल बातें" (Python Fundamentals) अध्याय में हम पाइथन की आंतरिक संरचना को गहराई से समझते हैं। इसमें डेटा प्रकार, चर, ऑपरेटर, अभिव्यक्ति, निवेश (Input/Output) और टोकन जैसी अवधारणाएँ शामिल हैं। यह अध्याय पिछले अध्याय "पाइथन से शुरुआत" का विस्तार है और आगे के अध्यायों (डेटा हैंडलिंग, नियंत्रण प्रवाह, स्ट्रिंग्स, लिस्ट्स, टपल्स और डिक्शनरी) की नींव रखता है। इस अध्याय की ठोस समझ के बिना कोई भी प्रोग्राम सही नहीं लिखा जा सकता।

2. टोकन (Tokens)

पाइथन प्रोग्राम की सबसे छोटी इकाई को टोकन कहते हैं। टोकन पाँच प्रकार के होते हैं:

1. कीवर्ड (Keywords): आरक्षित शब्द जिनके निश्चित अर्थ होते हैं। जैसे if, else, for, while, def, import, return, True, False, None।
2. आइडेंटिफायर (Identifiers): चर, फ़ंक्शन, कक्षा आदि के नाम। जैसे age, total_marks, _name।
3. लिटरल (Literals): स्थिर मान। जैसे 25, 3.14, "नमस्ते", True, None।
4. ऑपरेटर (Operators): संक्रिया करने वाले प्रतीक। जैसे +, -, *, /, //, %, **, ==, >।
5. विराम चिह्न (Punctuators): विशेष प्रतीक जैसे (, ), [, ], {, }, ,, :, =, ;।

3. चर और नियतांक (Variables and Constants)

चर (Variables)

चर एक नामित मेमोरी स्थान है जिसमें मान संग्रहीत होता है और जिसका मान प्रोग्राम के दौरान बदल सकता है।

count = 10
count = count + 5
print(count)   # 15

नियतांक (Constants)

वे मान जो प्रोग्राम के दौरान नहीं बदलते। पाइथन में विशेष नियतांक नहीं होते, परंपरा के अनुसार सभी बड़े अक्षरों में नाम लिखकर नियतांक बनाए जाते हैं।

PI = 3.14
GRAVITY = 9.8

चर नामकरण के नियम

1. नाम अक्षर (a-z, A-Z) या अंडरस्कोर (_) से शुरू होना चाहिए।
2. अंक से शुरू नहीं हो सकता, परंतु बीच में अंक हो सकते हैं।
3. केवल अक्षर, अंक और अंडरस्कोर रख सकते हैं; स्थान या विशेष प्रतीक नहीं।
4. कीवर्ड नहीं हो सकता।
5. पाइथन में चर नाम केस-सेंसिटिव (Case Sensitive) हैं, अतः Age और age भिन्न हैं।

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

पाइथन में निम्नलिखित मुख्य डेटा प्रकार होते हैं:

• int: पूर्णांक संख्याएँ। जैसे 5, -12, 1000।
• float: दशमलव संख्याएँ। जैसे 3.14, -0.5, 2.0।
• str: वर्णों का अनुक्रम। जैसे "पाइथन", 'A'।
• bool: केवल दो मान True और False।
• list: व्यवस्थित, परिवर्तनीय (Mutable) अनुक्रम। जैसे [1, 2, 3]।
• tuple: व्यवस्थित, अपरिवर्तनीय (Immutable) अनुक्रम। जैसे (1, 2, 3)।
• dict: कुंजी-मान (Key-Value) युग्मों का संग्रह। जैसे {"नाम": "राहुल"}।
• set: अद्वितीय मानों का अव्यवस्थित संग्रह। जैसे {1, 2, 3}।
• NoneType: None मान का प्रकार।

mutable और immutable

• Mutable (परिवर्तनीय): मान बदला जा सकता है। जैसे list, dict, set।
• Immutable (अपरिवर्तनीय): मान नहीं बदला जा सकता। जैसे int, float, str, tuple, bool।

5. ऑपरेटर (Operators)

अंकगणितीय ऑपरेटर (Arithmetic Operators)

ऑपरेटर	कार्य	उदाहरण
+	जोड़	10 + 3 = 13
-	घटाव	10 - 3 = 7
*	गुणा	10 * 3 = 30
/	भाग (फ़्लोट)	10 / 3 = 3.333
//	पूर्णांक भाग	10 // 3 = 3
%	शेषफल	10 % 3 = 1
**	घात	2 ** 3 = 8

तुलनात्मक ऑपरेटर (Relational Operators)

==, !=, >, <, >=, <=। इनका परिणाम हमेशा बूलियन (True/False) होता है।

लॉजिकल ऑपरेटर (Logical Operators)

and, or, not। जैसे (5 > 3) and (10 > 5) का मान True है।

असाइनमेंट ऑपरेटर (Assignment Operators)

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

आइडेंटिटी ऑपरेटर (Identity Operators)

is, is not। वस्तुओं की समानता (समान मेमोरी स्थान) की जाँच करते हैं।

मेंबरशिप ऑपरेटर (Membership Operators)

in, not in। यह जाँचते हैं कि मान किसी अनुक्रम (स्ट्रिंग, लिस्ट, टपल) में मौजूद है या नहीं।

print("a" in "python")     # True
print(3 in [1, 2, 3])      # True
print(5 not in [1, 2, 3])  # True

6. ऑपरेटर की प्राथमिकता और साहचर्यता (Precedence and Associativity)

अभिव्यक्ति में किस ऑपरेटर की गणना पहले होगी, यह प्राथमिकता (Precedence) निर्धारित करती है। उच्च प्राथमिकता वाला ऑपरेटर पहले क्रिया करता है।

प्राथमिकता का क्रम (उच्च से निम्न): 1. ** (घात) 2. *, /, //, % 3. +, - 4. तुलनात्मक (==, <, > आदि) 5. not 6. and 7. or

साहचर्यता (Associativity) यह बताती है कि समान प्राथमिकता वाले ऑपरेटर किस दिशा में जुड़ते हैं। अधिकांश ऑपरेटर बाएँ से दाएँ जुड़ते हैं, परंतु ** दाएँ से बाएँ जुड़ता है।

print(2 + 3 * 4)      # 14 (गुणा पहले)
print((2 + 3) * 4)    # 20 (कोष्ठक पहले)
print(2 ** 3 ** 2)    # 512 (दाएँ से बाएँ: 3**2=9, 2**9=512)

7. निवेश और निर्गम (Input and Output)

निवेश (Input)

name = input("नाम दर्ज करें: ")
age = int(input("आयु दर्ज करें: "))
marks = float(input("अंक दर्ज करें: "))

निर्गम (Output)

print("नाम:", name)
print(f"आयु: {age} अंक: {marks}")
print("कुल:", marks, sep=" | ")

8. अभिव्यक्ति और कथन (Expression and Statement)

अभिव्यक्ति (Expression): संकारकों और संकार्यों का संयोजन जो एक मान देता है। जैसे 5 + 3 * 2, x ** 2।

कथन (Statement): निर्देश जो कार्य करता है। जैसे x = 10, print("नमस्ते")। प्रत्येक कथन निष्पादित होता है, जबकि प्रत्येक अभिव्यक्ति का मूल्यांकन (Evaluation) होता है।

मूल्यांकन (Evaluation): अभिव्यक्ति का मान ज्ञात करने की प्रक्रिया। जैसे 3 * 4 का मूल्यांकन करने पर 12 प्राप्त होता है।

अभिव्यक्ति मूल्यांकन के चरण (Steps of Expression Evaluation)

किसी भी अभिव्यक्ति का मूल्यांकन करते समय निम्न क्रम अपनाया जाता है: 1. सर्वप्रथम कोष्ठकों (Parentheses) के अंदर की अभिव्यक्ति का मूल्यांकन होता है। 2. फिर घात (*) संकारक क्रिया करता है, जो दाएँ से बाएँ जुड़ता है। 3. उसके बाद गुणा, भाग, पूर्णांक भाग और शेषफल (, /, //, %) का मूल्यांकन बाएँ से दाएँ होता है। 4. अंत में जोड़ और घटाव (+, -) की गणना होती है।

x = 2 + 3 * 4 ** 2 - 10 / 2
# चरण 1: 4 ** 2 = 16
# चरण 2: 3 * 16 = 48, 10 / 2 = 5.0
# चरण 3: 2 + 48 - 5.0 = 45.0
print(x)   # 45.0

इस उदाहरण से स्पष्ट है कि प्राथमिकता के क्रम को ध्यान में रखे बिना लिखा गया कोड गलत परिणाम दे सकता है। स्पष्टता के लिए अनिश्चित स्थितियों में कोष्ठकों का उपयोग करना सर्वोत्तम है, क्योंकि कोष्ठक की प्राथमिकता सर्वोच्च होती है और वे अभिव्यक्ति को अधिक पठनीय बनाते हैं।

9. प्रैक्टिकल उदाहरण (Practical Examples)

उदाहरण 1: स्वैपिंग (मानों का अदला-बदली)

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

उदाहरण 2: क्षेत्रफल ज्ञात करना

r = float(input("त्रिज्या दर्ज करें: "))
area = 3.14 * r ** 2
print("वृत्त का क्षेत्रफल:", area)

उदाहरण 3: साधारण ब्याज

p = float(input("मूलधन: "))
t = float(input("समय: "))
r = float(input("दर: "))
si = (p * t * r) / 100
print("साधारण ब्याज:", si)

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

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

प्रकार	परिवर्तनीयता	उदाहरण
int	Immutable	42
float	Immutable	3.14
str	Immutable	"कक्षा"
bool	Immutable	True
list	Mutable	[1, 2, 3]
tuple	Immutable	(1, 2, 3)
dict	Mutable	{"a": 1}
set	Mutable	{1, 2}

तालिका 2: ऑपरेटरों की प्राथमिकता (उच्च से निम्न)

प्राथमिकता	ऑपरेटर
1	**
2	*, /, //, %
3	+, -
4	==, !=, <, >, <=, >=
5	not
6	and
7	or

तालिका 3: चर नामकरण - मान्य और अमान्य

मान्य नाम	अमान्य नाम	कारण (अमान्य)
age	1age	अंक से शुरू
_name	class	कीवर्ड
total_marks	total marks	स्थान
rollNo	roll-no	विशेष प्रतीक

माइंड मैप

graph TD
    A["पाइथन मूल बातें"] --> B["टोकन"]
    A --> C["डेटा प्रकार"]
    A --> D["ऑपरेटर"]
    A --> E["निवेश/निर्गम"]
    B --> F["कीवर्ड, आइडेंटिफायर, लिटरल, ऑपरेटर, विराम"]
    C --> G["int, float, str, bool"]
    C --> H["list, tuple, dict, set"]
    D --> I["अंकगणितीय, तुलनात्मक, लॉजिकल"]
    D --> J["असाइनमेंट, आइडेंटिटी, मेंबरशिप"]
    E --> K["input() और print()"]

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

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

1. input() को बिना int()/float() में बदले गणित में उपयोग करना; इससे TypeError आती है।
2. ** और * का भ्रम; 2 ** 3 घात है (8) जबकि 2 * 3 गुणा है (6)।
3. / और // का भ्रम; / हमेशा फ़्लोट देता है जबकि // पूर्णांक देता है।
4. चर नाम को कीवर्ड बनाना या अंक से शुरू करना, जिससे SyntaxError आती है।
5. प्राथमिकता को अनदेखा करना, जैसे 2 + 3 * 4 को 20 मान लेना; सही उत्तर 14 है।
6. स्ट्रिंग और संख्या को + से जोड़ना, जैसे "उम्र: " + age; इसके लिए f-string या str() का उपयोग करें।
7. tuple को mutable मान लेना, जबकि tuple और str दोनों immutable हैं।

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

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

निष्कर्ष

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