परिचय
परिभाषा: पाइथन एक उच्च-स्तरीय, सामान्य-उद्देश्यीय प्रोग्रामिंग भाषा है जो अपनी सादगी, पठनीयता और लचीलेपन के लिए जानी जाती है। यह डेटा विश्लेषण, मशीन लर्निंग, वेब डेवलपमेंट, और वैज्ञानिक अनुसंधान जैसे विभिन्न क्षेत्रों में उपयोग होती है। NCERT कक्षा 7 के कंप्यूटर विज्ञान पाठ्यपुस्तक में पाइथन को प्रोग्रामिंग की बुनियादी अवधारणाओं को समझाने के लिए एक उपयुक्त भाषा के रूप में प्रस्तुत किया गया है। उदाहरण: "Hello, World!" प्रिंट करना।
print("Hello, World!")
विशेषताएँ:
- पठनीयता: सरल और समझने में आसान कोड।
- लचीलापन: विंडोज, मैक, लिनक्स पर कार्य करता है।
- विस्तृत लाइब्रेरी: डेटा विज्ञान (Pandas, NumPy), AI (TensorFlow, Scikit-learn), वेब डेवलपमेंट (Django, Flask)।
- निशुल्क और ओपन-सोर्स: कोई लागत नहीं।
उपयोग:
- वेब डेवलपमेंट (Django, Flask)।
- डेटा विश्लेषण (Pandas, NumPy)।
- मशीन लर्निंग (TensorFlow, Scikit-learn)।
- स्वचालन और स्क्रिप्टिंग।
पाइथन टोकन्स
परिभाषा: टोकन्स पाइथन प्रोग्राम की सबसे छोटी इकाइयाँ हैं, जिन्हें पाइथन इंटरप्रेटर समझता है।
2.1. की-वर्ड्स (Keywords)
परिभाषा: विशेष शब्द जिनका पाइथन में विशिष्ट अर्थ होता है। उदाहरण: `if` का उपयोग सम/विषम जाँच में।
उदाहरण: `and`, `or`, `not`, `if`, `else`, `elif`, `for`, `while`, `break`, `continue`, `def`, `class`, `import`, `from`, `True`, `False`, `None`, `return`, `try`, `except`, `finally`।
विशेषताएँ:
- केस-संवेदनशील।
- छोटे अक्षरों में, सिवाय `True`, `False`, `None`।
उदाहरण:
if 5 > 3:
print("5 बड़ा है!")
2.2. आइडेंटिफायर्स (Identifiers)
परिभाषा: चर, फंक्शन्स, क्लासेस के लिए उपयोग किए जाने वाले नाम। उदाहरण: `sum` दो संख्याओं के योग में।
नियम:
- अक्षर (A-Z, a-z), अंक (0-9), अंडरस्कोर (_)।
- पहला अक्षर अंक नहीं।
- की-वर्ड्स नहीं।
- केस-संवेदनशील।
उदाहरण:
- सही: `student_name`, `roll_no`, `_temp`।
- गलत: `2score`, `if`, `my-var`।
उदाहरण:
sum = 10 + 5
print(sum) # आउटपुट: 15
2.3. ऑपरेटर्स (Operators)
परिभाषा: डेटा पर गणना या तुलना के लिए विशेष चिह्न। उदाहरण: `+` दो संख्याओं के योग में।
प्रकार:
- अंकगणितीय: `+`, `-`, `*`, `/`, `//`, `%`, `**`।
- तुलनात्मक: `==`, `!=`, `>`, `<`, `<=`, `>=`।
- तार्किक: `and`, `or`, `not`।
- असाइनमेंट: `=`, `+=`, `-=`, `*=`, `/=`।
- बिटवाइज़: `&`, `|`, `^`, `~`, `<<`, `>>`।
- पहचान: `is`, `is not`।
- सदस्यता: `in`, `not in`।
उदाहरण:
a = 10
b = 5
print(a + b) # आउटपुट: 15
print(a > b) # आउटपुट: True
2.4. डिलिमिटर्स (Delimiters)
परिभाषा: प्रोग्राम की संरचना को व्यवस्थित करने के लिए विशेष चिह्न। उदाहरण: `[]` लिस्ट इंडेक्सिंग में।
उदाहरण: `,`, `:`, `;`, `()`, `[]`, `{}`, `@`, `=`, `->`, `#`।
उपयोग:
- `()`: फंक्शन कॉल, गणितीय अभिव्यक्तियाँ।
- `[]`: लिस्ट या इंडेक्सिंग।
- `{}`: डिक्शनरी या सेट।
- `#`: टिप्पणी।
उदाहरण:
numbers = [1, 2, 3] # [] लिस्ट के लिए
print(numbers[0]) # आउटपुट: 1
2.5. लिटरल्स (Literals)
परिभाषा: निश्चित मान जो प्रोग्राम में सीधे उपयोग किए जाते हैं। उदाहरण: `"नमस्ते"` अभिवादन प्रोग्राम में।
प्रकार:
- न्यूमेरिक:
- Integer: `42`, `-10`.
- Float: `3.14`, `-0.001`.
- Complex: `3+4j`.
- स्ट्रिंग: `"Hello"`, `'Python'`.
- बूलियन: `True`, `False`.
- विशेष: `None`.
- लिस्ट, टपल, डिक्शनरी:
- लिस्ट: `[1, 2, 3]`.
- टपल: `(1, 2, 3)`.
- डिक्शनरी: `{"name": "Amit", "age": 20}`.
उदाहरण:
x = 42 # Integer Literal
y = 3.14 # Float Literal
name = "Python" # String Literal
is_valid = True # Boolean Literal
पांच बुनियादी पाइथन प्रोग्राम्स (मध्यम कठिनाई)
प्रोग्राम 1: दो संख्याओं का योग
विवरण: उपयोगकर्ता से दो संख्याएँ लेकर उनका योग प्रिंट करता है।
# दो संख्याओं का योग
a = float(input("पहली संख्या दर्ज करें: ")) # उपयोगकर्ता से इनपुट
b = float(input("दूसरी संख्या दर्ज करें: "))
sum = a + b # अंकगणितीय ऑपरेटर +
print("योग है:", sum) # आउटपुट
टोकन्स:
- की-वर्ड्स: `print`.
- आइडेंटिफायर्स: `a`, `b`, `sum`.
- ऑपरेटर्स: `+`, `=`.
- डिलिमिटर्स: `(`, `)`, `,`, `:`.
- लिटरल्स: उपयोगकर्ता द्वारा दर्ज संख्याएँ।
आउटपुट:
पहली संख्या दर्ज करें: 5
दूसरी संख्या दर्ज करें: 3
योग है: 8.0
प्रोग्राम 2: एक संख्या का वर्ग
विवरण: उपयोगकर्ता से एक संख्या लेकर उसका वर्ग प्रिंट करता है।
# एक संख्या का वर्ग
num = float(input("एक संख्या दर्ज करें: ")) # इनपुट
square = num ** 2 # घातांक ऑपरेटर **
print(num, "का वर्ग है:", square) # आउटपुट
टोकन्स:
- की-वर्ड्स: `print`.
- आइडेंटिफायर्स: `num`, `square`.
- ऑपरेटर्स: `**`, `=`.
- डिलिमिटर्स: `(`, `)`, `,`, `:`.
- लिटरल्स: उपयोगकर्ता द्वारा दर्ज संख्या।
आउटपुट:
एक संख्या दर्ज करें: 4
4.0 का वर्ग है: 16.0
प्रोग्राम 3: उपयोगकर्ता का अभिवादन
विवरण: उपयोगकर्ता से नाम लेकर अभिवादन संदेश प्रिंट करता है।
# उपयोगकर्ता का अभिवादन
name = input("आपका नाम दर्ज करें: ") # स्ट्रिंग इनपुट
greeting = "नमस्ते, " + name + "!" # स्ट्रिंग कॉन्सटेनेशन
print(greeting) # आउटपुट
टोकन्स:
- की-वर्ड्स: `print`.
- आइडेंटिफायर्स: `name`, `greeting`.
- ऑपरेटर्स: `+`, `=`.
- डिलिमिटर्स: `(`, `)`, `,`, `:`.
- लिटरल्स: `"नमस्ते, "`, `"!"`.
आउटपुट:
आपका नाम दर्ज करें: अमित
नमस्ते, अमित!
प्रोग्राम 4: सम या विषम संख्या की जाँच
विवरण: उपयोगकर्ता से संख्या लेकर बताता है कि वह सम है या विषम।
# सम या विषम संख्या की जाँच
num = int(input("एक संख्या दर्ज करें: ")) # पूर्णांक इनपुट
if num % 2 == 0: # मॉड्यूलस और तुलनात्मक ऑपरेटर
print(num, "एक सम संख्या है।")
else:
print(num, "एक विषम संख्या है।")
टोकन्स:
- की-वर्ड्स: `if`, `else`, `print`.
- आइडेंटिफायर्स: `num`.
- ऑपरेटर्स: `%`, `==`, `=`.
- डिलिमिटर्स: `(`, `)`, `,`, `:`.
- लिटरल्स: `2`, `0`, `"एक सम संख्या है।"`, `"एक विषम संख्या है।"`.
आउटपुट:
एक संख्या दर्ज करें: 7
7 एक विषम संख्या है।
प्रोग्राम 5: 1 से N तक की संख्याओं का योग
विवरण: उपयोगकर्ता से N लेकर 1 से N तक का योग प्रिंट करता है।
# 1 से N तक की संख्याओं का योग
n = int(input("N का मान दर्ज करें: ")) # इनपुट
sum = 0
for i in range(1, n + 1): # लूप और रेंज फंक्शन
sum += i # असाइनमेंट ऑपरेटर +=
print("1 से", n, "तक का योग है:", sum) # आउटपुट
टोकन्स:
- की-वर्ड्स: `for`, `in`, `print`.
- आइडेंटिफायर्स: `n`, `sum`, `i`.
- ऑपरेटर्स: `+`, `+=`, `=`.
- डिलिमिटर्स: `(`, `)`, `,`, `:`.
- लिटरल्स: `0`, `1`, `"1 से"`, `"तक का योग है:"`.
आउटपुट:
N का मान दर्ज करें: 5
1 से 5 तक का योग है: 15