Full guide of python program

अगस्त 27, 2025

सम्पूर्ण पाइथन गाइड

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

1. पाइथन क्या है और इसका उपयोग क्यों किया जाता है?

पाइथन (Python) एक इंटरप्रेटेड (interpreted), ऑब्जेक्ट-ओरिएंटेड (object-oriented), और उच्च-स्तरीय (high-level) प्रोग्रामिंग भाषा है जिसे गुइडो वैन रोसुम (Guido van Rossum) ने 1991 में बनाया था।

इसका डिज़ाइन दर्शन कोड पठनीयता (readability) पर जोर देता है, और इसका सिंटैक्स प्रोग्रामर्स को कम कोड लाइनों में अवधारणाओं को व्यक्त करने की अनुमति देता है।

पाइथन का उपयोग क्यों करें?

सरल और सीखने में आसान: अंग्रेजी जैसी सिंटैक्स इसे शुरुआती लोगों के लिए आदर्श बनाती है।
बहुमुखी प्रतिभा (Versatility): वेब डेवलपमेंट, डेटा साइंस, मशीन लर्निंग, ऑटोमेशन, वैज्ञानिक कंप्यूटिंग, गेम डेवलपमेंट आदि में उपयोग किया जाता है।
बड़ी लाइब्रेरी और फ्रेमवर्क: इसमें एक विशाल मानक लाइब्रेरी और हजारों तृतीय-पक्ष पैकेज (जैसे NumPy, Pandas, Django, Flask, Scikit-learn) हैं जो विकास को गति देते हैं।
बड़ा समुदाय: एक सक्रिय और सहायक समुदाय का मतलब है कि मदद और संसाधन आसानी से उपलब्ध हैं।
पोर्टेबिलिटी: पाइथन कोड विंडोज, मैकओएस, लिनक्स जैसे विभिन्न प्लेटफार्मों पर चल सकता है।
इंटरप्रेटेड: कोड लाइन-बाय-लाइन निष्पादित होता है, जिससे डिबगिंग आसान हो जाती है।

2. पाइथन में वेरिएबल कैसे घोषित करें?

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



# वेरिएबल असाइनमेंट

naam = "एलिस"  # स्ट्रिंग (String)

umr = 30     # इंटीजर (Integer)

unchai = 5.8   # फ्लोट (Float)

is_student = False # बूलियन (Boolean)

# वेरिएबल्स का मान प्रिंट करना

print(naam)

print(umr)

print(unchai)

print(is_student)

वेरिएबल नाम अक्षर (a-z, A-Z) या अंडरस्कोर (_) से शुरू होना चाहिए और इसमें अक्षर, संख्याएं और अंडरस्कोर हो सकते हैं। यह केस-संवेदी (case-sensitive) होता है (age और Age अलग-अलग वेरिएबल हैं)।

3. पाइथन में डेटा टाइप क्या हैं?

पाइथन में कई अंतर्निहित डेटा प्रकार होते हैं:

न्यूमेरिक टाइप्स (Numeric Types):
- int: पूर्णांक संख्याएं (जैसे 10, -5, 0)।
- float: दशमलव संख्याएं (जैसे 3.14, -0.5)।
- complex: जटिल संख्याएं (जैसे 3+5j)।
सीक्वेंस टाइप्स (Sequence Types):
- str: टेक्स्ट डेटा (जैसे "Hello", 'Python')।
- list: क्रमबद्ध, परिवर्तनीय संग्रह (जैसे [1, "apple", 3.5])।
- tuple: क्रमबद्ध, अपरिवर्तनीय संग्रह (जैसे (1, "apple", 3.5))।
मैपिंग टाइप (Mapping Type):
- dict: बिना क्रम वाला, कुंजी-मान युग्मों का संग्रह (जैसे {'नाम': 'बॉब', 'उम्र': 25})।
सेट टाइप्स (Set Types):
- set: बिना क्रम वाला, अद्वितीय तत्वों का संग्रह (जैसे {1, 2, 3})।
- frozenset: सेट का अपरिवर्तनीय संस्करण।
बूलियन टाइप (Boolean Type):
- bool: सत्य मान (True या False)।
बाइनरी टाइप्स (Binary Types):
- bytes, bytearray, memoryview
None टाइप (None Type):
- NoneType: इसका केवल एक मान होता है: None (किसी मान की अनुपस्थिति को दर्शाता है)।

आप type() फ़ंक्शन का उपयोग करके किसी वेरिएबल का डेटा प्रकार जांच सकते हैं:



x = 10

print(type(x))  # आउटपुट: <class 'int'>

y = "नमस्ते"

print(type(y))  # आउटपुट: <class 'str'>

z = [1, 2, 3]

print(type(z))  # आउटपुट: <class 'list'>

4. पाइथन में ऑपरेटर कैसे काम करते हैं?

ऑपरेटर विशेष प्रतीक होते हैं जो मानों (ऑपरेंड) पर गणना या संचालन करते हैं।

अंकगणितीय ऑपरेटर्स (Arithmetic Operators): + (जोड़), - (घटाव), * (गुणा), / (भाग), % (मॉड्यूलस - शेषफल), ** (घात), // (फ्लोर डिवीजन - पूर्णांक भाग)।
तुलना ऑपरेटर्स (Comparison Operators): == (बराबर), != (बराबर नहीं), > (से बड़ा), < (से छोटा), >= (से बड़ा या बराबर), <= (से छोटा या बराबर)। ये True या False लौटाते हैं।
लॉजिकल ऑपरेटर्स (Logical Operators): and (और), or (या), not (नहीं)। बूलियन मानों पर काम करते हैं।
असाइनमेंट ऑपरेटर्स (Assignment Operators): =, +=, -=, *=, /=, आदि। वेरिएबल्स को मान असाइन करने के लिए।
सदस्यता ऑपरेटर्स (Membership Operators): in (में है), not in (में नहीं है)। जांचते हैं कि कोई मान सीक्वेंस में मौजूद है या नहीं।
पहचान ऑपरेटर्स (Identity Operators): is (है), is not (नहीं है)। जांचते हैं कि क्या दो वेरिएबल मेमोरी में एक ही ऑब्जेक्ट को संदर्भित करते हैं।
बिटवाइज़ ऑपरेटर्स (Bitwise Operators): &, |, ^, ~, <<, >>। बाइनरी संख्याओं पर बिट स्तर पर काम करते हैं।

उदाहरण:



# अंकगणितीय

a = 10

b = 3

print(a + b)  # आउटपुट: 13

print(a / b)  # आउटपुट: 3.333...

print(a // b) # आउटपुट: 3

print(a % b)  # आउटपुट: 1

print(a ** b) # आउटपुट: 1000

# तुलना

print(a > b)  # आउटपुट: True

print(a == 10) # आउटपुट: True

# लॉजिकल

x = True

y = False

print(x and y) # आउटपुट: False

print(not x)   # आउटपुट: False

# सदस्यता

my_list = [1, 2, 3]

print(2 in my_list) # आउटपुट: True

print(4 not in my_list) # आउटपुट: True

5. पाइथन में फंक्शन कैसे बनाएं?

फंक्शन कोड का एक ब्लॉक होता है जो केवल तब चलता है जब उसे कॉल किया जाता है। आप डेटा (पैरामीटर) को फंक्शन में पास कर सकते हैं। फंक्शन डेटा वापस (रिटर्न) कर सकता है।

फंक्शन बनाने के लिए def कीवर्ड का उपयोग किया जाता है।



# फंक्शन परिभाषा

def greet(name):

  """यह फंक्शन दिए गए नाम का अभिवादन करता है।""" # यह डॉकस्ट्रिंग है

  print(f"नमस्ते, {name}!")

# फंक्शन कॉल

greet("दुनिया") # आउटपुट: नमस्ते, दुनिया!

# रिटर्न वैल्यू वाला फंक्शन

def add_numbers(x, y):

  """यह फंक्शन दो संख्याओं को जोड़ता है और योग लौटाता है।"""

  return x + y

# फंक्शन कॉल और रिटर्न वैल्यू को स्टोर करना

result = add_numbers(5, 3)

print(result) # आउटपुट: 8

फंक्शन कोड को पुन: प्रयोज्य (reusable) और संगठित (organized) बनाते हैं।

6. पाइथन में मॉड्यूल क्या हैं और कैसे आयात करें?

मॉड्यूल (Module) एक पाइथन फ़ाइल (.py) होती है जिसमें पाइथन परिभाषाएँ और कथन होते हैं। मॉड्यूल आपको अपने कोड को तार्किक रूप से व्यवस्थित करने की अनुमति देते हैं।

किसी मॉड्यूल की सामग्री (फंक्शन, क्लास, वेरिएबल) का उपयोग करने के लिए, आपको उसे import कीवर्ड का उपयोग करके आयात करना होगा।

आयात करने के तरीके:

पूरा मॉड्यूल आयात करें:



import math # गणितीय कार्यों के लिए मॉड्यूल

print(math.sqrt(16)) # आउटपुट: 4.0

print(math.pi)       # आउटपुट: 3.14159...

मॉड्यूल से विशिष्ट नाम आयात करें:



from math import sqrt, pi

print(sqrt(25)) # आउटपुट: 5.0

print(pi)       # आउटपुट: 3.14159...

मॉड्यूल को उपनाम (alias) दें:



import math as m

print(m.pow(2, 3)) # आउटपुट: 8.0

मॉड्यूल से सब कुछ आयात करें (अनुशंसित नहीं):



from math import * # सावधान: यह नेमस्पेस को प्रदूषित कर सकता है

print(log10(100)) # आउटपुट: 2.0

आप अपनी खुद की मॉड्यूल फाइलें भी बना सकते हैं और उन्हें अन्य स्क्रिप्ट में आयात कर सकते हैं।

7. पाइथन में फंक्शन के तर्क और रिटर्न वैल्यू कैसे काम करते हैं?

तर्क (Arguments) वे मान होते हैं जो फंक्शन को कॉल करते समय पास किए जाते हैं। फंक्शन परिभाषा में इन मानों को प्राप्त करने वाले वेरिएबल्स को पैरामीटर (Parameters) कहा जाता है।

रिटर्न वैल्यू (Return Value) वह मान होता है जिसे फंक्शन अपना काम पूरा करने के बाद वापस भेजता है। return स्टेटमेंट का उपयोग मान वापस भेजने के लिए किया जाता है। यदि कोई return स्टेटमेंट नहीं है, तो फंक्शन डिफ़ॉल्ट रूप से None लौटाता है।

तर्कों के प्रकार:

स्थितीय तर्क (Positional Arguments): क्रम के आधार पर पास किए जाते हैं।
कीवर्ड तर्क (Keyword Arguments): नाम के साथ पास किए जाते हैं (name=value)। क्रम मायने नहीं रखता।
डिफ़ॉल्ट तर्क (Default Arguments): पैरामीटर के लिए डिफ़ॉल्ट मान सेट किए जाते हैं। यदि कॉल करते समय कोई मान पास नहीं किया जाता है, तो डिफ़ॉल्ट मान का उपयोग होता है।
चर-लंबाई तर्क (*args): अनिश्चित संख्या में स्थितीय तर्कों को टपल के रूप में स्वीकार करता है।
चर-लंबाई कीवर्ड तर्क (**kwargs): अनिश्चित संख्या में कीवर्ड तर्कों को डिक्शनरी के रूप में स्वीकार करता है।



# विभिन्न प्रकार के तर्कों वाला फंक्शन

def describe_pet(pet_name, animal_type="कुत्ता", owner="अज्ञात"): # डिफ़ॉल्ट तर्क

  """पालतू जानवर का वर्णन करता है।"""

  print(f"मेरे पास एक {animal_type} है।")

  print(f"उसका नाम {pet_name} है और मालिक {owner} है।")

# स्थितीय तर्क

describe_pet("फिदो")

# कीवर्ड तर्क

describe_pet(animal_type="बिल्ली", pet_name="मिट्टू")

# डिफ़ॉल्ट और स्थितीय तर्क का मिश्रण

describe_pet("बडी", owner="चार्ली")

# *args और **kwargs का उदाहरण

def process_data(*args, **kwargs):

    print("स्थितीय तर्क (Tuple):", args)

    print("कीवर्ड तर्क (Dictionary):", kwargs)

    total = sum(args)

    print("योग:", total)

    if 'message' in kwargs:

        print("संदेश:", kwargs['message'])

process_data(1, 2, 3, name="टेस्ट", message="सफलता!")

# आउटपुट:

# स्थितीय तर्क (Tuple): (1, 2, 3)

# कीवर्ड तर्क (Dictionary): {'name': 'टेस्ट', 'message': 'सफलता!'}

# योग: 6

# संदेश: सफलता!

# रिटर्न वैल्यू

def multiply(a, b):

    return a * b

product = multiply(4, 5)

print(f"गुणनफल: {product}") # आउटपुट: गुणनफल: 20

8. पाइथन में लिस्ट क्या है और कैसे उपयोग करें?

लिस्ट (List) पाइथन में सबसे बहुमुखी डेटा प्रकारों में से एक है। यह आइटम का एक क्रमबद्ध (ordered) और परिवर्तनीय (mutable) संग्रह है। लिस्ट को वर्गाकार कोष्ठक [] में परिभाषित किया जाता है, और आइटम अल्पविराम से अलग होते हैं।

लिस्ट में विभिन्न प्रकार के आइटम हो सकते हैं।



# लिस्ट बनाना

fruits = ["सेब", "केला", "चेरी", "संतरा"]

numbers = [1, 5, 2, 8, 3]

mixed_list = [10, "नमस्ते", True, 3.14]

# एलिमेंट एक्सेस करना (Indexing) - 0 से शुरू होता है

print(fruits[0])   # आउटपुट: सेब

print(fruits[1])   # आउटपुट: केला

print(fruits[-1])  # आउटपुट: संतरा (आखिरी आइटम)

# स्लाइसिंग (Slicing) - लिस्ट का हिस्सा निकालना

print(fruits[1:3]) # आउटपुट: ['केला', 'चेरी'] (इंडेक्स 1 से 2 तक)

print(fruits[:2])  # आउटपुट: ['सेब', 'केला'] (शुरुआत से इंडेक्स 1 तक)

print(fruits[2:])  # आउटपुट: ['चेरी', 'संतरा'] (इंडेक्स 2 से अंत तक)

# लिस्ट बदलना (Mutable)

fruits[1] = "आम"

print(fruits)      # आउटपुट: ['सेब', 'आम', 'चेरी', 'संतरा']

# लिस्ट मेथड्स

fruits.append("अंगूर") # अंत में जोड़ना

print(fruits)      # आउटपुट: ['सेब', 'आम', 'चेरी', 'संतरा', 'अंगूर']

fruits.insert(1, "अनार") # विशिष्ट इंडेक्स पर जोड़ना

print(fruits)      # आउटपुट: ['सेब', 'अनार', 'आम', 'चेरी', 'संतरा', 'अंगूर']

fruits.remove("चेरी") # आइटम हटाना

print(fruits)      # आउटपुट: ['सेब', 'अनार', 'आम', 'संतरा', 'अंगूर']

popped_fruit = fruits.pop(2) # इंडेक्स से हटाना और वापस पाना

print(popped_fruit) # आउटपुट: आम

print(fruits)      # आउटपुट: ['सेब', 'अनार', 'संतरा', 'अंगूर']

numbers.sort() # सॉर्ट करना (जगह में)

print(numbers)     # आउटपुट: [1, 2, 3, 5, 8]

print(len(fruits)) # लिस्ट की लंबाई

print("सेब" in fruits) # सदस्यता जांचना (True)

9. पाइथन में टपल क्या है और कैसे उपयोग करें?

टपल (Tuple) लिस्ट के समान ही आइटम का एक क्रमबद्ध (ordered) संग्रह है, लेकिन यह अपरिवर्तनीय (immutable) होता है। इसका मतलब है कि एक बार टपल बन जाने के बाद, आप उसके आइटम को बदल, जोड़ या हटा नहीं सकते।

टपल को गोल कोष्ठक () में परिभाषित किया जाता है।



# टपल बनाना

coordinates = (10, 20, 30)

colors = ("लाल", "हरा", "नीला")

single_item_tuple = (5,) # एकल आइटम टपल के लिए अल्पविराम आवश्यक है

# एलिमेंट एक्सेस करना (Indexing) - लिस्ट की तरह

print(coordinates[0]) # आउटपुट: 10

print(colors[-1])     # आउटपुट: नीला

# स्लाइसिंग (Slicing) - लिस्ट की तरह

print(colors[1:])     # आउटपुट: ('हरा', 'नीला')

# टपल अपरिवर्तनीय हैं

# coordinates[0] = 5 # यह TypeError देगा

# टपल मेथड्स (कम होते हैं)

print(colors.count("लाल")) # आइटम की गिनती

print(colors.index("हरा")) # आइटम का इंडेक्स

# टपल का उपयोग कब करें?

# - जब आप डेटा को अपरिवर्तनीय रखना चाहते हैं (जैसे निर्देशांक, RGB रंग मान)।

# - डिक्शनरी की कुंजी के रूप में (क्योंकि वे अपरिवर्तनीय हैं)।

# - लिस्ट की तुलना में थोड़ा तेज हो सकता है।

# टपल अनपैकिंग

x, y, z = coordinates

print(x, y, z) # आउटपुट: 10 20 30

10. पाइथन में डिक्शनरी क्या है और कैसे उपयोग करें?

डिक्शनरी (Dictionary) कुंजी-मान (key-value) युग्मों का एक बिना क्रम वाला (unordered - पाइथन 3.7+ में क्रमबद्ध), परिवर्तनीय (mutable) संग्रह है। प्रत्येक कुंजी अद्वितीय होनी चाहिए और मान तक पहुंचने के लिए उपयोग की जाती है।

डिक्शनरी को कर्ली ब्रेसिज़ {} में परिभाषित किया जाता है, जिसमें कुंजी और मान को कोलन (:) से अलग किया जाता है।



# डिक्शनरी बनाना

student = {

    "naam": "राहुल",

    "umr": 21,

    "course": "कंप्यूटर साइंस",

    "shahar": "दिल्ली"

}

# मान एक्सेस करना (कुंजी का उपयोग करके)

print(student["naam"])    # आउटपुट: राहुल

print(student.get("umr")) # आउटपुट: 21 (get() सुरक्षित है, कुंजी न होने पर None देता है)

print(student.get("grade", "N/A")) # कुंजी न होने पर डिफ़ॉल्ट मान

# मान बदलना या जोड़ना

student["umr"] = 22 # मौजूदा मान बदलें

student["email"] = "rahul@example.com" # नया कुंजी-मान युग्म जोड़ें

print(student)

# आइटम हटाना

del student["shahar"]

popped_course = student.pop("course") # कुंजी से हटाना और मान वापस पाना

print(popped_course) # आउटपुट: कंप्यूटर साइंस

print(student)

# डिक्शनरी मेथड्स

print(student.keys())   # सभी कुंजियाँ प्राप्त करें (dict_keys ऑब्जेक्ट)

print(student.values()) # सभी मान प्राप्त करें (dict_values ऑब्जेक्ट)

print(student.items())  # सभी कुंजी-मान युग्म प्राप्त करें (dict_items ऑब्जेक्ट)

# डिक्शनरी पर लूप चलाना

print("\nडिक्शनरी के आइटम:")

for key, value in student.items():

    print(f"{key}: {value}")

print("\nकेवल कुंजियाँ:")

for key in student.keys():

    print(key)

# डिक्शनरी की लंबाई

print(f"\nआइटम की संख्या: {len(student)}")

11. पाइथन में सेट क्या है और कैसे उपयोग करें?

सेट (Set) आइटम का एक बिना क्रम वाला (unordered), परिवर्तनीय (mutable) संग्रह है जिसमें कोई डुप्लिकेट (no duplicates) आइटम नहीं होते हैं।

सेट को कर्ली ब्रेसिज़ {} में परिभाषित किया जाता है (खाली सेट बनाने के लिए set() का उपयोग करें, क्योंकि {} एक खाली डिक्शनरी बनाता है)।

सेट गणितीय सेट संचालन (यूनियन, इंटरसेक्शन, डिफरेंस) के लिए उपयोगी होते हैं और सदस्यता परीक्षण (membership testing) के लिए बहुत कुशल होते हैं।



# सेट बनाना

numbers_set = {1, 2, 3, 4, 4, 5} # डुप्लिकेट 4 हटा दिया जाएगा

print(numbers_set) # आउटपुट: {1, 2, 3, 4, 5} (क्रम भिन्न हो सकता है)

empty_set = set() # खाली सेट

print(empty_set)   # आउटपुट: set()

# लिस्ट से सेट बनाना (डुप्लिकेट हटाने के लिए उपयोगी)

my_list = [1, 2, 2, 3, 4, 3, 5]

unique_numbers = set(my_list)

print(unique_numbers) # आउटपुट: {1, 2, 3, 4, 5}

# सेट मेथड्स

numbers_set.add(6) # आइटम जोड़ना

print(numbers_set) # आउटपुट: {1, 2, 3, 4, 5, 6}

numbers_set.update({6, 7, 8}) # एकाधिक आइटम जोड़ना

print(numbers_set) # आउटपुट: {1, 2, 3, 4, 5, 6, 7, 8}

numbers_set.remove(3) # आइटम हटाना (यदि आइटम मौजूद नहीं है तो KeyError देगा)

print(numbers_set) # आउटपुट: {1, 2, 4, 5, 6, 7, 8}

numbers_set.discard(10) # आइटम हटाना (यदि आइटम मौजूद नहीं है तो कोई त्रुटि नहीं देगा)

numbers_set.discard(1)

print(numbers_set) # आउटपुट: {2, 4, 5, 6, 7, 8}

# सेट ऑपरेशंस

set_a = {1, 2, 3, 4}

set_b = {3, 4, 5, 6}

# यूनियन (Union) - सभी अद्वितीय आइटम

print(set_a | set_b) # या set_a.union(set_b)

# आउटपुट: {1, 2, 3, 4, 5, 6}

# इंटरसेक्शन (Intersection) - कॉमन आइटम

print(set_a & set_b) # या set_a.intersection(set_b)

# आउटपुट: {3, 4}

# डिफरेंस (Difference) - A में हैं लेकिन B में नहीं

print(set_a - set_b) # या set_a.difference(set_b)

# आउटपुट: {1, 2}

# सिमेट्रिक डिफरेंस (Symmetric Difference) - A या B में हैं, लेकिन दोनों में नहीं

print(set_a ^ set_b) # या set_a.symmetric_difference(set_b)

# आउटपुट: {1, 2, 5, 6}

# सदस्यता परीक्षण (बहुत तेज)

print(3 in set_a) # आउटपुट: True

print(7 in set_a) # आउटपुट: False

12. पाइथन में फाइल कैसे पढ़ें और लिखें?

पाइथन आपको फाइलों को पढ़ने और लिखने की अनुमति देता है। फाइल ऑपरेशन का मूल तरीका open() फ़ंक्शन का उपयोग करना है, जो एक फाइल ऑब्जेक्ट लौटाता है।

with स्टेटमेंट का उपयोग करना सबसे अच्छा अभ्यास है क्योंकि यह सुनिश्चित करता है कि फाइल ठीक से बंद हो गई है, भले ही कोई त्रुटि हो।



# फाइल में लिखना ('w' मोड - राइट मोड, यदि फाइल मौजूद है तो ओवरराइट करता है)

try:

    with open("my_file.txt", "w", encoding="utf-8") as f: # utf-8 एन्कोडिंग हिंदी के लिए महत्वपूर्ण है

        f.write("नमस्ते दुनिया!\n")

        f.write("यह पाइथन फाइल लेखन का एक उदाहरण है।\n")

        f.writelines(["तीसरी पंक्ति।\n", "चौथी पंक्ति।\n"])

    print("फाइल 'my_file.txt' सफलतापूर्वक लिखी गई।")

except IOError as e:

    print(f"फाइल लिखने में त्रुटि: {e}")

# फाइल में जोड़ना ('a' मोड - अपेंड मोड, फाइल के अंत में जोड़ता है)

try:

    with open("my_file.txt", "a", encoding="utf-8") as f:

        f.write("यह पंक्ति जोड़ी गई है।\n")

    print("फाइल 'my_file.txt' में सफलतापूर्वक जोड़ा गया।")

except IOError as e:

    print(f"फाइल में जोड़ने में त्रुटि: {e}")

# फाइल पढ़ना ('r' मोड - रीड मोड, डिफ़ॉल्ट मोड)

try:

    print("\nफाइल 'my_file.txt' पढ़ना:")

    with open("my_file.txt", "r", encoding="utf-8") as f:

        # लाइन-बाय-लाइन पढ़ें

        print("--- लाइन-बाय-लाइन ---")

        for line in f:

            print(line.strip()) # strip() अतिरिक्त व्हाइटस्पेस हटाता है

except FileNotFoundError:

    print("त्रुटि: फाइल 'my_file.txt' नहीं मिली।")

except IOError as e:

    print(f"फाइल पढ़ने में त्रुटि: {e}")

13. पाइथन में फाइल मोड क्या हैं और कैसे उपयोग करें?

open() फ़ंक्शन का दूसरा तर्क फ़ाइल मोड निर्दिष्ट करता है। यह बताता है कि फ़ाइल को किस उद्देश्य के लिए खोला जाना है।

मुख्य फाइल मोड:

'r': Read (पढ़ना) - डिफ़ॉल्ट मोड। फ़ाइल को पढ़ने के लिए खोलता है। यदि फ़ाइल मौजूद नहीं है तो त्रुटि देता है।
'w': Write (लिखना) - फ़ाइल को लिखने के लिए खोलता है। यदि फ़ाइल मौजूद है, तो उसकी सामग्री को मिटा देता है (ओवरराइट करता है)। यदि फ़ाइल मौजूद नहीं है, तो नई फ़ाइल बनाता है।
'a': Append (जोड़ना) - फ़ाइल को जोड़ने के लिए खोलता है। फ़ाइल पॉइंटर फ़ाइल के अंत में होता है। यदि फ़ाइल मौजूद नहीं है, तो नई फ़ाइल बनाता है।
'x': Create (बनाना) - एक नई फ़ाइल विशेष रूप से बनाने के लिए। यदि फ़ाइल पहले से मौजूद है तो त्रुटि देता है।
'b': Binary (बाइनरी) - बाइनरी मोड (जैसे चित्र या निष्पादन योग्य फ़ाइलें पढ़ना/लिखना)। इसे अन्य मोड (जैसे 'rb', 'wb') के साथ जोड़ा जाता है।
't': Text (टेक्स्ट) - टेक्स्ट मोड। डिफ़ॉल्ट। इसे अन्य मोड (जैसे 'rt', 'wt') के साथ जोड़ा जाता है।
'+': Update (अपडेट) - पढ़ने और लिखने दोनों के लिए फ़ाइल खोलता है (जैसे 'r+', 'w+', 'a+')।

हमेशा टेक्स्ट फाइलों के लिए encoding="utf-8" निर्दिष्ट करना एक अच्छा अभ्यास है, खासकर जब गैर-अंग्रेजी वर्णों (जैसे हिंदी) के साथ काम कर रहे हों।



# उदाहरण: पढ़ने और लिखने के लिए खोलना ('r+' मोड)

try:

    with open("my_file.txt", "r+", encoding="utf-8") as f:

        content = f.read()

        print("\n'r+' मोड में पढ़ना:\n", content)

        # फ़ाइल पॉइंटर को अंत में ले जाएं लिखने से पहले

        f.seek(0, 2) # 0 बाइट्स अंत (2) से

        f.write("\nयह 'r+' मोड द्वारा जोड़ा गया है।")

        print("'r+' मोड में सफलतापूर्वक लिखा गया।")

except FileNotFoundError:

    print("त्रुटि: फाइल 'my_file.txt' नहीं मिली।")

except IOError as e:

    print(f"फाइल ऑपरेशन में त्रुटि: {e}")

# उदाहरण: बाइनरी मोड में लिखना ('wb' मोड)

try:

    with open("binary_file.bin", "wb") as f:

        data = b'\x00\x01\x02\x03\xFF' # बाइट्स ऑब्जेक्ट

        f.write(data)

    print("\nबाइनरी फाइल 'binary_file.bin' सफलतापूर्वक लिखी गई।")

except IOError as e:

    print(f"बाइनरी फाइल लिखने में त्रुटि: {e}")

# उदाहरण: बाइनरी मोड में पढ़ना ('rb' मोड)

try:

    with open("binary_file.bin", "rb") as f:

        binary_content = f.read()

        print("\nबाइनरी फाइल पढ़ना:", binary_content)

except FileNotFoundError:

    print("त्रुटि: बाइनरी फाइल 'binary_file.bin' नहीं मिली।")

except IOError as e:

    print(f"बाइनरी फाइल पढ़ने में त्रुटि: {e}")

14. पाइथन में क्लास और ऑब्जेक्ट क्या हैं और कैसे बनाएं?

पाइथन एक ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (Object-Oriented Programming - OOP) भाषा है। OOP वास्तविक दुनिया की संस्थाओं को सॉफ्टवेयर में मॉडल करने का एक तरीका है।

क्लास (Class): एक ब्लूप्रिंट या टेम्पलेट है जिससे ऑब्जेक्ट बनाए जाते हैं। यह गुणों (attributes) और व्यवहारों (methods) को परिभाषित करता है जो उस क्लास के सभी ऑब्जेक्ट्स में होंगे। क्लास बनाने के लिए class कीवर्ड का उपयोग किया जाता है।
ऑब्जेक्ट (Object): क्लास का एक इंस्टेंस (instance) या उदाहरण है। जब आप किसी क्लास से एक ऑब्जेक्ट बनाते हैं, तो आप उस क्लास के ब्लूप्रिंट का उपयोग करके मेमोरी में एक विशिष्ट इकाई बना रहे होते हैं।
एट्रिब्यूट (Attribute): ऑब्जेक्ट से जुड़े डेटा या विशेषताएँ (वेरिएबल्स की तरह)।
मेथड (Method): ऑब्जेक्ट पर किए जा सकने वाले कार्य या व्यवहार (फंक्शंस की तरह)।
__init__() मेथड: एक विशेष मेथड जिसे "कंस्ट्रक्टर" कहा जाता है। यह तब स्वचालित रूप से कॉल होता है जब आप क्लास का एक नया ऑब्जेक्ट बनाते हैं। इसका उपयोग ऑब्जेक्ट के एट्रिब्यूट्स को इनिशियलाइज़ करने के लिए किया जाता है।
self पैरामीटर: क्लास के मेथड्स में पहला पैरामीटर हमेशा self होता है। यह उस इंस्टेंस (ऑब्जेक्ट) को संदर्भित करता है जिस पर मेथड कॉल किया जा रहा है, जिससे आप उस ऑब्जेक्ट के एट्रिब्यूट्स और मेथड्स तक पहुंच सकते हैं।



# क्लास परिभाषा

class Dog:

    # क्लास एट्रिब्यूट (सभी Dog ऑब्जेक्ट्स के लिए समान)

    species = "Canis familiaris"

    # कंस्ट्रक्टर (__init__ मेथड)

    def __init__(self, name, breed, age):

        # इंस्टेंस एट्रिब्यूट (प्रत्येक Dog ऑब्जेक्ट के लिए विशिष्ट)

        self.name = name

        self.breed = breed

        self.age = age

        print(f"{self.name} ऑब्जेक्ट बनाया गया!")

    # इंस्टेंस मेथड

    def bark(self):

        return f"{self.name} भौंकता है: वूफ! वूफ!"

    def describe(self):

        return f"{self.name} एक {self.breed} है और {self.age} साल का है।"

    def celebrate_birthday(self):

        self.age += 1

        print(f"जन्मदिन मुबारक, {self.name}! अब आप {self.age} साल के हैं।")

# क्लास से ऑब्जेक्ट बनाना (इंस्टेंसिएशन)

dog1 = Dog("बडी", "लैब्राडोर", 3)

dog2 = Dog("लूसी", "पूडल", 5)

# ऑब्जेक्ट के एट्रिब्यूट एक्सेस करना

print(f"\n{dog1.name} की नस्ल: {dog1.breed}") # आउटपुट: बडी की नस्ल: लैब्राडोर

print(f"{dog2.name} की उम्र: {dog2.age}")   # आउटपुट: लूसी की उम्र: 5

print(f"सभी कुत्तों की प्रजाति: {Dog.species}") # क्लास एट्रिब्यूट एक्सेस करना

# ऑब्जेक्ट के मेथड कॉल करना

print(dog1.bark())      # आउटपुट: बडी भौंकता है: वूफ! वूफ!

print(dog2.describe())  # आउटपुट: लूसी एक पूडल है और 5 साल का है।

dog1.celebrate_birthday() # आउटपुट: जन्मदिन मुबारक, बडी! अब आप 4 साल के हैं।

print(dog1.describe())  # आउटपुट: बडी एक लैब्राडोर है और 4 साल का है।

15. पाइथन में इनहेरिटेंस क्या है और कैसे काम करता है?

इनहेरिटेंस (Inheritance) OOP का एक मूलभूत सिद्धांत है जो एक क्लास (जिसे चाइल्ड क्लास या सबक्लास कहा जाता है) को दूसरी क्लास (जिसे पेरेंट क्लास या सुपरक्लास कहा जाता है) के गुणों (एट्रिब्यूट्स) और व्यवहारों (मेथड्स) को प्राप्त करने की अनुमति देता है।

यह कोड पुन: उपयोग (code reuse) को बढ़ावा देता है और एक "is-a" संबंध बनाता है (जैसे, एक 'GoldenRetriever' is-a 'Dog')।

चाइल्ड क्लास पेरेंट क्लास के मेथड्स को ओवरराइड (override) कर सकती है या नए मेथड जोड़ सकती है। super() फ़ंक्शन का उपयोग पेरेंट क्लास के मेथड्स (विशेष रूप से __init__) को कॉल करने के लिए किया जाता है।



# पेरेंट क्लास (पिछला Dog क्लास से थोड़ा संशोधित)

class Dog:

    species = "Canis familiaris"

    def __init__(self, name, age):

        self.name = name

        self.age = age

        print(f"Dog ऑब्जेक्ट '{self.name}' बनाया गया।")

    def speak(self):

        return f"{self.name} कहता है: वूफ!"

    def describe(self):

        return f"{self.name} {self.age} साल का है।"

# चाइल्ड क्लास (Dog से इनहेरिट करती है)

class GoldenRetriever(Dog): # पेरेंट क्लास को कोष्ठक में निर्दिष्ट करें

    def __init__(self, name, age, favorite_toy="बॉल"):

        # पेरेंट क्लास के __init__ को कॉल करें

        super().__init__(name, age)

        self.favorite_toy = favorite_toy # चाइल्ड क्लास का अपना एट्रिब्यूट

        print(f"GoldenRetriever ऑब्जेक्ट '{self.name}' बनाया गया।")

    # पेरेंट क्लास के मेथड को ओवरराइड करना

    def speak(self):

        # पेरेंट के speak() को कॉल करना और उसमें जोड़ना (वैकल्पिक)

        # parent_speak = super().speak()

        # return f"{parent_speak} ... और खुशी से पूंछ हिलाता है!"

        return f"{self.name} खुशी से भौंकता है: वूफ वूफ!"

    # नया मेथड जोड़ना

    def fetch(self):

        return f"{self.name} खुशी से अपनी {self.favorite_toy} लाता है!"

# चाइल्ड क्लास का ऑब्जेक्ट बनाना

my_retriever = GoldenRetriever("गोल्डी", 2, "रबर चिकन")

# पेरेंट क्लास से इनहेरिट किए गए मेथड का उपयोग करना

print(my_retriever.describe()) # आउटपुट: गोल्डी 2 साल का है।

# ओवरराइड किए गए मेथड का उपयोग करना

print(my_retriever.speak())    # आउटपुट: गोल्डी खुशी से भौंकता है: वूफ वूफ!

# चाइल्ड क्लास के विशिष्ट मेथड का उपयोग करना

print(my_retriever.fetch())    # आउटपुट: गोल्डी खुशी से अपनी रबर चिकन लाता है!

# पेरेंट क्लास का एट्रिब्यूट एक्सेस करना

print(f"{my_retriever.name} की प्रजाति: {my_retriever.species}") # आउटपुट: गोल्डी की प्रजाति: Canis familiaris

# isinstance() और issubclass() का उपयोग

print(f"क्या my_retriever Dog का इंस्टेंस है? {isinstance(my_retriever, Dog)}") # आउटपुट: True

print(f"क्या my_retriever GoldenRetriever का इंस्टेंस है? {isinstance(my_retriever, GoldenRetriever)}") # आउटपुट: True

print(f"क्या GoldenRetriever Dog की सबक्लास है? {issubclass(GoldenRetriever, Dog)}") # आउटपुट: True

16. पाइथन में डेटा विश्लेषण के लिए कौन से लाइब्रेरी उपयोग करें?

पाइथन डेटा विश्लेषण और डेटा विज्ञान के लिए एक अत्यंत शक्तिशाली भाषा है, जिसका मुख्य कारण इसकी उत्कृष्ट लाइब्रेरी हैं।

प्रमुख डेटा विश्लेषण लाइब्रेरी:

NumPy (Numerical Python):
- बहुआयामी ऐरे (arrays) और मैट्रिक्स के साथ काम करने के लिए मौलिक पैकेज।
- उच्च-प्रदर्शन गणितीय कार्य प्रदान करता है।
- कई अन्य डेटा साइंस लाइब्रेरी (जैसे Pandas, Scikit-learn) NumPy ऐरे पर निर्मित हैं।
- pip install numpy
Pandas:
- उच्च-प्रदर्शन, उपयोग में आसान डेटा संरचनाएं (मुख्य रूप से DataFrame और Series) और डेटा विश्लेषण उपकरण प्रदान करता है।
- डेटा को लोड करने, साफ करने, बदलने, मर्ज करने और विश्लेषण करने के लिए आदर्श।
- CSV, Excel, SQL डेटाबेस आदि जैसे विभिन्न प्रारूपों से डेटा पढ़ना/लिखना आसान बनाता है।
- pip install pandas
Matplotlib:
- स्थिर, एनिमेटेड और इंटरैक्टिव विज़ुअलाइज़ेशन बनाने के लिए एक व्यापक लाइब्रेरी।
- लाइन प्लॉट, स्कैटर प्लॉट, बार चार्ट, हिस्टोग्राम आदि बनाने के लिए उपयोग किया जाता है।
- अत्यधिक अनुकूलन योग्य।
- pip install matplotlib
Seaborn:
- Matplotlib पर आधारित एक डेटा विज़ुअलाइज़ेशन लाइब्रेरी।
- आकर्षक और सूचनात्मक सांख्यिकीय ग्राफिक्स बनाने के लिए एक उच्च-स्तरीय इंटरफ़ेस प्रदान करता है।
- जटिल विज़ुअलाइज़ेशन को सरल बनाता है।
- pip install seaborn
SciPy (Scientific Python):
- NumPy पर निर्मित, यह वैज्ञानिक और तकनीकी कंप्यूटिंग के लिए मॉड्यूल का एक संग्रह प्रदान करता है।
- इसमें अनुकूलन (optimization), रैखिक बीजगणित (linear algebra), एकीकरण (integration), इंटरपोलेशन (interpolation), विशेष कार्य (special functions), FFT, सिग्नल और इमेज प्रोसेसिंग आदि के लिए सबमॉड्यूल शामिल हैं।
- pip install scipy

इन लाइब्रेरी का संयोजन डेटा वैज्ञानिकों को डेटा के साथ कुशलतापूर्वक काम करने और अंतर्दृष्टि प्राप्त करने में सक्षम बनाता है।



# Pandas और NumPy का संक्षिप्त उदाहरण

import pandas as pd

import numpy as np

# NumPy ऐरे बनाना

arr = np.array([[1, 2, 3], [4, 5, 6]])

print("NumPy Array:\n", arr)

# Pandas DataFrame बनाना

data = {'Naam': ['एलिस', 'बॉब', 'चार्ली'], # Changed keys to avoid conflict with variable names

        'Umr': [25, 30, 22],

        'Shahar': ['न्यूयॉर्क', 'पेरिस', 'लंदन']}

df = pd.DataFrame(data)

print("\nPandas DataFrame:\n", df)

# DataFrame से डेटा एक्सेस करना

print("\nकेवल नाम कॉलम:\n", df['Naam'])

print("\nपहली पंक्ति:\n", df.iloc[0])

# डेटा फ़िल्टर करना

print("\n30 साल से कम उम्र वाले:\n", df[df['Umr'] < 30])

17. पाइथन में मशीन लर्निंग के लिए कौन से लाइब्रेरी उपयोग करें?

पाइथन मशीन लर्निंग (ML) और आर्टिफिशियल इंटेलिजेंस (AI) के क्षेत्र में अग्रणी भाषा है। इसके लिए कई शक्तिशाली लाइब्रेरी उपलब्ध हैं।

प्रमुख मशीन लर्निंग लाइब्रेरी:

Scikit-learn:
- पारंपरिक ML एल्गोरिदम के लिए सबसे लोकप्रिय लाइब्रेरी में से एक।
- वर्गीकरण (classification), प्रतिगमन (regression), क्लस्टरिंग (clustering), आयामी कमी (dimensionality reduction), मॉडल चयन (model selection), और प्रीप्रोसेसिंग (preprocessing) के लिए कुशल उपकरण प्रदान करता है।
- NumPy, SciPy और Matplotlib के साथ अच्छी तरह से एकीकृत होता है।
- उपयोग में आसान और उत्कृष्ट दस्तावेज़ीकरण।
- pip install scikit-learn
TensorFlow:
- Google द्वारा विकसित एक ओपन-सोर्स लाइब्रेरी।
- मुख्य रूप से डीप लर्निंग (deep learning) और तंत्रिका नेटवर्क (neural networks) के लिए उपयोग किया जाता है।
- बड़े पैमाने पर संख्यात्मक गणना के लिए लचीला पारिस्थितिकी तंत्र प्रदान करता है।
- TensorBoard जैसे विज़ुअलाइज़ेशन टूल शामिल हैं।
- pip install tensorflow
Keras:
- एक उच्च-स्तरीय तंत्रिका नेटवर्क API, जो TensorFlow, Theano, या CNTK के शीर्ष पर चल सकता है (आमतौर पर TensorFlow के साथ प्रयोग किया जाता है)।
- तेजी से प्रयोग करने पर ध्यान केंद्रित करता है। उपयोगकर्ता के अनुकूल, मॉड्यूलर और विस्तार योग्य।
- डीप लर्निंग मॉडल को जल्दी से बनाने और प्रशिक्षित करने के लिए बढ़िया है।
- TensorFlow 2.x में एकीकृत है (tensorflow.keras)।
- pip install tensorflow (आमतौर पर केरस शामिल होता है)
PyTorch:
- Facebook के AI रिसर्च लैब (FAIR) द्वारा विकसित एक ओपन-सोर्स लाइब्रेरी।
- डीप लर्निंग के लिए TensorFlow का एक प्रमुख विकल्प।
- गतिशील गणना ग्राफ़ (dynamic computation graphs) के लिए जाना जाता है, जो कुछ अनुप्रयोगों में अधिक लचीलापन प्रदान करता है।
- अनुसंधान समुदाय में बहुत लोकप्रिय है।
- pip install torch torchvision torchaudio (इंस्टॉलेशन निर्देश भिन्न हो सकते हैं)
NLTK (Natural Language Toolkit):
- मानव भाषा डेटा (प्राकृतिक भाषा प्रसंस्करण - NLP) के साथ काम करने के लिए एक प्रमुख मंच।
- टेक्स्ट वर्गीकरण, टोकनाइजेशन, स्टेमिंग, टैगिंग, पार्सिंग और सिमेंटिक रीजनिंग के लिए लाइब्रेरी और प्रोग्राम प्रदान करता है।
- pip install nltk
spaCy:
- औद्योगिक-शक्ति प्राकृतिक भाषा प्रसंस्करण (NLP) के लिए एक और लोकप्रिय लाइब्रेरी।
- गति और दक्षता पर ध्यान केंद्रित करता है। बड़े टेक्स्ट कॉर्पस को संसाधित करने के लिए डिज़ाइन किया गया है।
- pip install spacy और फिर भाषा मॉडल डाउनलोड करें (जैसे python -m spacy download en_core_web_sm)।

सही लाइब्रेरी का चुनाव आपकी विशिष्ट आवश्यकता, परियोजना के पैमाने और व्यक्तिगत पसंद पर निर्भर करता है। Scikit-learn सामान्य ML कार्यों के लिए एक बढ़िया प्रारंभिक बिंदु है, जबकि TensorFlow और PyTorch डीप लर्निंग के लिए मानक हैं।

18. पाइथन में वेब डेवलपमेंट के लिए कौन से फ्रेमवर्क उपयोग करें?

पाइथन वेब डेवलपमेंट के लिए भी एक लोकप्रिय विकल्प है, जिसमें कई शक्तिशाली और लचीले फ्रेमवर्क उपलब्ध हैं।

प्रमुख वेब फ्रेमवर्क:

Django:
- एक उच्च-स्तरीय, "बैटरी-शामिल" (batteries-included) वेब फ्रेमवर्क जो तेजी से विकास और स्वच्छ, व्यावहारिक डिजाइन को प्रोत्साहित करता है।
- बहुत सारी अंतर्निहित सुविधाएँ प्रदान करता है, जैसे ORM (ऑब्जेक्ट-रिलेशनल मैपर), व्यवस्थापन इंटरफ़ेस (admin interface), प्रमाणीकरण (authentication) प्रणाली, आदि।
- सुरक्षा पर जोर देता है और सामान्य सुरक्षा कमजोरियों से बचाने में मदद करता है।
- बड़े और जटिल वेब अनुप्रयोगों के लिए उपयुक्त है।
- pip install Django
Flask:
- एक माइक्रो-फ्रेमवर्क जो न्यूनतम और लचीला है।
- यह ORM या फॉर्म सत्यापन जैसे बहुत सारे अंतर्निहित उपकरण प्रदान नहीं करता है, जिससे डेवलपर्स को अपनी पसंद की लाइब्रेरी और एक्सटेंशन चुनने की स्वतंत्रता मिलती है।
- शुरू करना आसान है और छोटे से मध्यम आकार के अनुप्रयोगों, API और प्रोटोटाइप के लिए बढ़िया है।
- Werkzeug (WSGI टूलकिट) और Jinja2 (टेम्पलेट इंजन) पर आधारित है।
- pip install Flask
FastAPI:
- API बनाने के लिए एक आधुनिक, तेज (उच्च-प्रदर्शन) वेब फ्रेमवर्क।
- मानक पाइथन प्रकार संकेतों (type hints) पर आधारित है।
- स्वचालित इंटरैक्टिव API दस्तावेज़ीकरण (Swagger UI और ReDoc के माध्यम से) प्रदान करता है।
- एसिंक्रोनस कोड (async/await) के लिए अंतर्निहित समर्थन।
- डेटा सत्यापन के लिए Pydantic का उपयोग करता है।
- pip install fastapi uvicorn (Uvicorn ASGI सर्वर है)
Pyramid:
- एक और लचीला फ्रेमवर्क जो छोटे और बड़े दोनों अनुप्रयोगों के लिए उपयुक्त है।
- यह Django की तरह पूर्ण-स्टैक या Flask की तरह न्यूनतम होने के बीच एक मध्य मार्ग प्रदान करता है।
- स्केलेबिलिटी और लचीलेपन पर ध्यान केंद्रित करता है।
- pip install pyramid

Django उन लोगों के लिए एक अच्छा विकल्प है जो एक पूर्ण-विशेषताओं वाला समाधान चाहते हैं और तेजी से एक मजबूत एप्लिकेशन बनाना चाहते हैं। Flask उन लोगों के लिए बेहतर है जो अधिक नियंत्रण और लचीलापन चाहते हैं और केवल आवश्यक घटकों का उपयोग करना पसंद करते हैं। FastAPI आधुनिक API बनाने के लिए उत्कृष्ट है।

19. पाइथन में वेब एप्लिकेशन कैसे बनाएं?

पाइथन वेब फ्रेमवर्क (जैसे Flask या Django) का उपयोग करके वेब एप्लिकेशन बनाना एक संरचित प्रक्रिया है। यहाँ Flask का उपयोग करके एक बहुत ही सरल उदाहरण दिया गया है:

चरण:

फ्रेमवर्क इंस्टॉल करें: pip install Flask
एक पाइथन फ़ाइल बनाएं: (उदा., app.py)
Flask ऑब्जेक्ट बनाएं: from flask import Flask और app = Flask(__name__)
रूट (Routes) परिभाषित करें: रूट URL पथों को पाइथन फ़ंक्शंस (व्यू फ़ंक्शंस) से मैप करते हैं। @app.route('/') डेकोरेटर का उपयोग रूट बनाने के लिए किया जाता है।
व्यू फ़ंक्शन लिखें: ये फ़ंक्शन अनुरोधों को संभालते हैं और प्रतिक्रियाएँ (आमतौर पर HTML) लौटाते हैं।
एप्लिकेशन चलाएं: स्क्रिप्ट के अंत में कोड जोड़ें ताकि जब फ़ाइल सीधे चलाई जाए तो डेवलपमेंट सर्वर शुरू हो जाए।

सरल Flask उदाहरण (app.py):



from flask import Flask, request

# Flask एप्लिकेशन इंस्टेंस बनाएं

app = Flask(__name__)

# होम पेज के लिए रूट ('/')

@app.route('/')

def home():

    # HTML स्ट्रिंग लौटाना

    page_title = "होम पेज"

    # Inline styles for simplicity in this example

    html_content = f"""

    <!DOCTYPE html>

    <html lang="hi">

    <head>

        <meta charset="UTF-8">

        <title>{page_title}</title>

        <style>

            body {{ font-family: 'Noto Sans Devanagari', sans-serif; padding: 20px; background-color: #f9fafb; color: #374151; }}

            h1 {{ color: #1e3a8a; }} /* Darker blue */

            a {{ color: #1d4ed8; text-decoration: none; }}

            a:hover {{ text-decoration: underline; }}

        </style>

    </head>

    <body>

        <h1>नमस्ते, Flask!</h1>

        <p>यह मेरा पहला वेब ऐप है।</p>

        <p><a href="/greet?name=मित्र">अभिवादन पेज पर जाएं (उदाहरण)</a></p>

         <p>URL में नाम बदलने के लिए <code>?name=आपका_नाम</code> जोड़ें।</p>

    </body>

    </html>

    """

    return html_content

# एक और रूट ('/greet')

@app.route('/greet')

def greet():

    # URL से पैरामीटर प्राप्त करना (जैसे /greet?name=विश्व)

    user_name = request.args.get('name', 'अतिथि') # डिफ़ॉल्ट मान 'अतिथि'

    # Inline styles for simplicity

    html_content = f"""

    <!DOCTYPE html>

    <html lang="hi">

    <head>

        <meta charset="UTF-8">

        <title>अभिवादन</title>

         <style>

            body {{ font-family: 'Noto Sans Devanagari', sans-serif; padding: 20px; background-color: #f9fafb; color: #374151; }}

            h1 {{ color: #059669; }} /* Emerald green */

            a {{ color: #1d4ed8; text-decoration: none; }}

            a:hover {{ text-decoration: underline; }}

        </style>

    </head>

    <body>

        <h1>नमस्ते, {user_name}!</h1>

        <p><a href="/">होम पर वापस जाएं</a></p>

    </body>

    </html>

    """

    return html_content

# सुनिश्चित करें कि यह कोड केवल तब चलता है जब स्क्रिप्ट सीधे निष्पादित होती है

if __name__ == '__main__':

    # डेवलपमेंट सर्वर शुरू करें

    # debug=True डेवलपमेंट के दौरान उपयोगी है (त्रुटियों को दिखाता है और ऑटो-रीलोड करता है)

    # host='0.0.0.0' इसे नेटवर्क पर उपलब्ध कराता है (वैकल्पिक)

    app.run(debug=True, host='0.0.0.0')

इस फ़ाइल को चलाने के लिए, टर्मिनल में जाएं और python app.py टाइप करें। फिर अपने वेब ब्राउज़र में http://127.0.0.1:5000/ (या यदि host='0.0.0.0' का उपयोग किया है तो आपका लोकल IP एड्रेस) पर जाएं।

यह एक बहुत ही बुनियादी उदाहरण है। वास्तविक दुनिया के अनुप्रयोगों में डेटाबेस, उपयोगकर्ता प्रमाणीकरण, फॉर्म, टेम्पलेटिंग इंजन (जैसे Jinja2), और बहुत कुछ शामिल होगा। Django इन सुविधाओं में से कई को अंतर्निहित प्रदान करता है।

पाइथन से संबंधित अन्य विभिन्न तथ्य

डायनामिक टाइपिंग (Dynamic Typing): आपको वेरिएबल का प्रकार घोषित करने की आवश्यकता नहीं है; यह रनटाइम पर निर्धारित होता है।
गारबेज कलेक्शन (Garbage Collection): पाइथन स्वचालित रूप से मेमोरी प्रबंधन करता है, उन ऑब्जेक्ट्स द्वारा उपयोग की जाने वाली मेमोरी को पुनः प्राप्त करता है जिनकी अब आवश्यकता नहीं है।
विशाल मानक लाइब्रेरी (Extensive Standard Library): स्ट्रिंग ऑपरेशन, नेटवर्किंग, फ़ाइल I/O, रेगुलर एक्सप्रेशन और बहुत कुछ के लिए अंतर्निहित मॉड्यूल प्रदान करता है।
पाइथन 2 बनाम पाइथन 3: पाइथन 3 भाषा का वर्तमान और भविष्य है। पाइथन 2 अब समर्थित नहीं है (जनवरी 2020 में समर्थन समाप्त हो गया)। नया कोड हमेशा पाइथन 3 में लिखा जाना चाहिए।
PEP 8: पाइथन कोड के लिए आधिकारिक स्टाइल गाइड, जो कोड को सुसंगत और पठनीय बनाने में मदद करता है।
वर्चुअल एनवायरनमेंट (Virtual Environments): विभिन्न परियोजनाओं के लिए निर्भरता (लाइब्रेरी) को अलग रखने के लिए venv या conda जैसे उपकरणों का उपयोग करना एक अच्छा अभ्यास है।
पैकेज मैनेजर (pip): पाइथन पैकेज इंडेक्स (PyPI) से तृतीय-पक्ष लाइब्रेरी को स्थापित और प्रबंधित करने के लिए मानक उपकरण।
इंटरैक्टिव शेल (Interactive Shell): आप सीधे टर्मिनल में python या ipython टाइप करके पाइथन कोड की छोटी पंक्तियों का परीक्षण कर सकते हैं।
नामकरण परंपराएं (Naming Conventions): वेरिएबल्स और फ़ंक्शंस के लिए snake_case (जैसे my_variable), क्लास के लिए CamelCase (जैसे MyClass), और स्थिरांकों के लिए ALL_CAPS (जैसे PI = 3.14) का उपयोग करना आम है।

Anilhub