इस chapter में हम Programming की मूल अवधारणाओं को समझेंगे जैसे – Model of Computation, Algorithms, Flowcharts, Programming Languages, Compilation, Testing, Debugging और Documentation। ये सभी किसी भी beginner programmer के लिए foundation बनाते हैं।
Computation का अर्थ है किसी समस्या को step-by-step हल करना। Model of Computation वह सैद्धांतिक ढांचा (theoretical framework) है जो बताता है कि कोई कंप्यूटर या प्रोग्राम डेटा को कैसे process करता है। Python जैसी programming languages इन्हीं computational models के practical रूप हैं।
Alan Turing द्वारा विकसित यह computation का theoretical model है। इसमें:
x = 2
y = 3
z = x + y
print(z) # Output: 5
Finite Automata एक simple computation model है जो limited memory के साथ काम करता है। यह input symbols को पढ़ता है और final state तक पहुँचता है।
s = "10101"
if "101" in s:
print("Pattern found!")
else:
print("Pattern not found!")
# Output: Pattern found!
RAM Model computation का practical रूप है — जैसे Python में instructions sequentially execute होती हैं और memory को random access किया जा सकता है।
arr = [10, 20, 30, 40]
arr[2] = arr[2] + 5
print(arr) # Output: [10, 20, 35, 40]
num = int(input("Enter a number: "))
square = num * num
print("Square is:", square)
किसी भी प्रोग्राम का आधार उसका Algorithm होता है। Algorithm एक step-by-step process है जो किसी समस्या को हल करने का तरीका बताता है। यह computer program का logical blueprint होता है — जिसे Python या किसी भी language में implement किया जा सकता है।
if-else logic)।loops का प्रयोग)।
a = 10
b = 5
sum = a + b
print("Sum =", sum)
# Output: Sum = 15
num = int(input("Enter a number: "))
if num % 2 == 0:
print("Even number")
else:
print("Odd number")
n = int(input("Enter n: "))
i = 1
while i <= n:
print(i)
i += 1
Algorithm को आम तौर पर दो तरीकों से लिखा जाता है:
n = int(input("Enter a number: "))
fact = 1
for i in range(1, n + 1):
fact = fact * i
print("Factorial =", fact)
किसी algorithm की performance को Time Complexity और Space Complexity से मापा जाता है।
O(n) का अर्थ है कि algorithm का समय input size के साथ linear रूप से बढ़ता है।
Algorithm हमारे रोजमर्रा के कामों में भी होता है:
Flowchart किसी algorithm या program का graphical representation होता है। यह symbols और arrows का उपयोग करके logic का step-by-step flow दिखाता है। Flowcharts programming logic को समझने और debug करने में बेहद मददगार होते हैं — और Python जैसे प्रोग्राम में इन्हीं steps को code के रूप में लिखा जाता है।
| Symbol | Name | Purpose |
|---|---|---|
| 🔹 Oval | Start / Stop | Program की शुरुआत और अंत दर्शाने के लिए। |
| ⬜ Rectangle | Process | Computation या processing step दिखाने के लिए। |
| 🔺 Diamond | Decision | Condition check या branching दिखाने के लिए। |
| 🟦 Parallelogram | Input / Output | Data read या print करने के लिए। |
| ➡️ Arrow | Flow Lines | Execution flow का direction बताने के लिए। |
| 🔘 Circle | Connector | Flowchart के दो भागों को जोड़ने के लिए। |
नीचे एक simple flowchart logic और उसका Python equivalent दिया गया है:
a = int(input("Enter first number: "))
b = int(input("Enter second number: "))
sum = a + b
print("Sum =", sum)
a = int(input("Enter first number: "))
b = int(input("Enter second number: "))
if a > b:
print("A is greater")
else:
print("B is greater")
if-else statement द्वारा दर्शाया गया है।
n = int(input("Enter number: "))
fact = 1
i = 1
while i <= n:
fact = fact * i
i += 1
print("Factorial =", fact)
while loop को flowchart के loop/iteration part के रूप में देखा जा सकता है।
Programming Language वह माध्यम (medium) है जिसके द्वारा हम computer को निर्देश (instructions) देते हैं। जैसे मनुष्य एक-दूसरे से संवाद करने के लिए भाषाओं का उपयोग करते हैं, वैसे ही कंप्यूटर से बात करने के लिए हमें programming languages की आवश्यकता होती है। Python, C, Java, और JavaScript सभी high-level programming languages के उदाहरण हैं।
यह सबसे नीचले स्तर (lowest level) की भाषा है। इसमें instructions केवल 0 और 1 के रूप में लिखे जाते हैं। यह सीधे hardware द्वारा समझी जाती है।
Machine language की readability बढ़ाने के लिए mnemonics (short words) का उपयोग किया गया —
जैसे MOV, ADD, SUB आदि।
Assembly language को machine code में convert करने के लिए Assembler की जरूरत होती है।
MOV A, 05H
MOV B, 06H
ADD A, B
High-level languages मनुष्यों के लिए समझने योग्य होती हैं। इनका syntax English जैसा होता है, और compiler/interpreter द्वारा translate किया जाता है। Python, C, C++, Java, BASIC आदि इसी category में आते हैं।
a = 5
b = 10
sum = a + b
print("Sum =", sum)
ये languages और भी high-level होती हैं — जैसे SQL, MATLAB, R, आदि। इनका उद्देश्य programming effort को कम करना और काम को सरल बनाना है।
SELECT name, age FROM students WHERE age > 18;
ये logic-based और AI-oriented languages हैं। इनका प्रयोग Machine Learning, Artificial Intelligence और Expert Systems में होता है। उदाहरण: Prolog, Mercury, और Python के कुछ AI frameworks।
Compiler और Interpreter दोनों का काम high-level code को machine code में translate करना होता है, लेकिन इनके working methods अलग होते हैं।
| Feature | Compiler | Interpreter |
|---|---|---|
| Translation | पूरे program को एक बार में translate करता है। | एक-एक line को translate और execute करता है। |
| Execution Speed | Fast (pre-compiled) | Slow (line-by-line) |
| Error Detection | सभी errors compile time पर दिखते हैं। | पहली error पर execution रुक जाता है। |
| Example Languages | C, C++ | Python, JavaScript |
print("Hello, World!")
.py file)।
print("Hello"
# Missing parenthesis → Syntax Error
जब हम किसी programming language (जैसे Python या C) में program लिखते हैं, तो वह Source Code कहलाता है। यह code सीधे computer द्वारा समझा नहीं जा सकता, इसलिए इसे Machine Code में translate करने की आवश्यकता होती है। इसी translation की पूरी प्रक्रिया को Compilation Process कहा जाता है।
Compilation process कई stages में पूरी होती है। नीचे हर stage को simple explanation और Python reference के साथ समझाया गया है 👇
Compiler source code को पढ़ता है और उसे छोटे-छोटे tokens (keywords, identifiers, operators, literals, etc.) में बाँट देता है। इस stage पर comments और whitespaces को हटा दिया जाता है।
a = 5
b = 10
print(a + b)
['a', '=', '5', 'b', '=', '10', 'print', '(', 'a', '+', 'b', ')']
→ यही lexical analysis कहलाता है।
इस चरण में compiler यह चेक करता है कि code का structure language के grammar rules के अनुसार है या नहीं। जैसे — parentheses, indentation, keywords की position आदि।
print("Hello"
# Missing parenthesis → SyntaxError: unexpected EOF while parsing
अब compiler meaning (semantics) check करता है — जैसे data type mismatch, undeclared variables, invalid operations आदि।
x = "Hello"
y = 5
print(x + y) # ❌ TypeError: can only concatenate str (not "int") to str
इस stage में compiler source code को एक intermediate code में बदलता है
(जो platform-independent होता है)।
Python में यह step internally होता है —
Python interpreter .py file को .pyc (bytecode) में बदल देता है।
python myprogram.py
myprogram.pyc file बनाता है (in __pycache__ folder)।
यह bytecode “intermediate code” है।
Compiler यहाँ program के performance को बेहतर बनाने की कोशिश करता है — जैसे unnecessary calculations को हटाना, repeated operations को optimize करना, आदि।
x = (10 * 5) + (10 * 5)
x = 2 * (10 * 5)
अब compiler intermediate code को machine code (object code) में बदलता है। यह binary format में होता है, जिसे CPU execute कर सकता है।
अंतिम चरण में compiler अलग-अलग object files और libraries को link करता है ताकि एक final executable file बन सके। फिर loader उस executable को memory में load करता है और program चलना शुरू होता है।
| Stage | Description |
|---|---|
| Lexical Analysis | Code को tokens में तोड़ना |
| Syntax Analysis | Grammar और structure की जाँच |
| Semantic Analysis | Meaning और type consistency check करना |
| Intermediate Code | Platform-independent bytecode बनाना |
| Optimization | Code performance सुधारना |
| Code Generation | Final machine code तैयार करना |
| Linking & Loading | Executable को memory में लोड कर चलाना |
Python technically interpreted language है, लेकिन internally यह भी एक compilation step perform करता है। जब आप Python code चलाते हैं:
.pyc) में compile करता है।
Source Code (.py)
↓
Bytecode (.pyc)
↓
Python Virtual Machine (PVM)
↓
Output
जब हम कोई program लिखते हैं, तो उसमें कभी-कभी errors (bugs) आ जाते हैं। इन errors को ढूँढने और सुधारने की प्रक्रिया को Testing and Debugging कहते हैं। यह software development का सबसे महत्वपूर्ण चरण है क्योंकि यह सुनिश्चित करता है कि program सही तरीके से काम करे।
Python या किसी भी programming language में errors को मुख्यतः तीन श्रेणियों में बाँटा जाता है:
# Missing closing parenthesis
print("Hello World"
SyntaxError: unexpected EOF while parsing
# Logic गलत है — factorial गलत निकलेगा
n = 5
fact = 0
for i in range(1, n + 1):
fact = fact + i
print(fact)
# Division by zero error
x = 10
y = 0
print(x / y)
ZeroDivisionError: division by zero
Testing का मुख्य उद्देश्य है यह सुनिश्चित करना कि software सभी situations में सही output दे। यह केवल errors खोजने के लिए नहीं बल्कि correctness, completeness और quality सुनिश्चित करने के लिए भी होती है।
def add(a, b):
return a + b
# Testing the function
assert add(2, 3) == 5
assert add(-1, 1) == 0
print("All tests passed!")
Debugging का अर्थ है program में errors को ढूँढना और उन्हें ठीक करना। यह testing के बाद की प्रक्रिया है।
pdb module।
def multiply(a, b):
print("Debug:", a, b) # Debugging info
return a * b
result = multiply(3, 4)
print("Result =", result)
import pdb
def divide(a, b):
pdb.set_trace() # Debugger starts here
return a / b
print(divide(10, 2))
| Feature | Testing | Debugging |
|---|---|---|
| Purpose | Errors खोजने के लिए | Errors ठीक करने के लिए |
| Who performs | Tester या QA | Programmer / Developer |
| When | Development के बाद | Testing के दौरान या बाद में |
| Tool | Testing frameworks (pytest, unittest) | Debugger tools (pdb, IDE debugger) |
Python में runtime errors को handle करने के लिए try-except block का प्रयोग किया जाता है। इससे program crash होने से बचता है।
try:
x = int(input("Enter number: "))
y = int(input("Enter divisor: "))
print("Result =", x / y)
except ZeroDivisionError:
print("Cannot divide by zero!")
except ValueError:
print("Invalid input! Please enter a number.")
finally:
print("Program finished.")
Cannot divide by zero!
Finally block हमेशा execute होता है — चाहे error आए या नहीं।
pytest और unittest जैसे frameworks का उपयोग करें।
try-except, assert, और pdb tools debugging में मदद करते हैं।किसी भी software project की सफलता सिर्फ उसके code पर नहीं, बल्कि उसकी Documentation पर भी निर्भर करती है। Documentation वह प्रक्रिया है जिसमें हम program या system के बारे में आवश्यक जानकारी लिखते हैं ताकि कोई भी व्यक्ति उसे आसानी से समझ सके, maintain कर सके या आगे develop कर सके।
Python में internal documentation के दो प्रमुख तरीके हैं:
Comments का उपयोग code को explain करने के लिए किया जाता है ताकि अन्य developers logic समझ सकें। Python interpreter comments को ignore करता है।
# This program adds two numbers
a = 10
b = 5
sum = a + b # Adding the numbers
print("Sum =", sum)
# से शुरू होने वाली lines comments हैं।
Docstrings का उपयोग functions, classes और modules के अंदर documentation लिखने के लिए किया जाता है।
ये triple quotes (""" ... """) में लिखे जाते हैं।
def greet(name):
"""This function greets the user with their name."""
print("Hello,", name)
help(greet) # Displays the docstring
External documentation project के बाहर बनाई जाती है और अक्सर text files या PDFs के रूप में होती है। यह developers और users दोनों के लिए reference का काम करती है।
pydoc -w myprogram.py
IndentationError.== और is में फर्क?== values की equality चेक करता है; is object identity (same memory) चेक करता है।*args और **kwargs क्या करते हैं?*args = variable positional args (tuple); **kwargs = variable keyword args (dict).with क्यों?try risky code, except error handle, else no-error path, finally cleanup.import math, from math import sqrt, import math as m.__name__ == "__main__" का मतलब?seq[start:stop:step], negative indices allowed; e.g. s[::-1] reverses sequence.input() string देता है; number चाहिए तो cast करें: int(input()).and, or, not (booleans); Bitwise: &, |, ^, ~, <<, >> (bits).
def fact(n):
res = 1
for i in range(1, n+1):
res *= i
return res
print(fact(5)) # 120
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b) # [5 7 9]