शुरुआती लोगों के लिए Python अभ्यास: उत्तरों सहित एक हैंड्स‑ऑन गाइड

Python सीखने का सबसे अच्छा तरीका है दोहराव, प्रयोग और समस्याओं को सुलझाने के माध्यम से परिचित होना। यही कारण है कि “करके सीखें” का सिद्धांत प्रभावी प्रोग्रामर्स के प्रशिक्षण का मूल है। 

कोड लिखना, गलतियाँ करना और उन्हें सुधारना—यही वास्तविक कौशल विकसित करने का तरीका है।

इस लेख में, हम शुरुआती लोगों के लिए विशेष रूप से तैयार किए गए Python अभ्यासों के एक संरचित सेट से गुजरेंगे। अभ्यास सरल वेरिएबल्स से शुरू होते हैं और धीरे‑धीरे फ़ंक्शंस, डेटा स्ट्रक्चर्स और छोटे डेटा प्रोजेक्ट्स तक बढ़ते हैं।

आगे पढ़ने से पहले, आपके लिए एक चुनौती: इस लेख के पहले तीन अभ्यासों को तुरंत हल करने की कोशिश करें, बिना आगे के स्पष्टीकरण देखे। भले ही आप अटक जाएँ, कोशिश करना ही वह जगह है जहाँ अधिकांश सीखना होता है।

यदि आप अधिक गाइडेड अनुभव पसंद करते हैं, तो DataCamp पाठ्यक्रम आपकी सिंटैक्स और लॉजिक को कदम‑दर‑कदम स्वतः जाँचते हैं। यह छोटी गलतियों को प्रगति में बाधा बनने से रोकता है और खासकर शुरुआती लोगों के लिए सहायक है। एक अच्छा शुरुआती बिंदु है Introduction to Python कोर्स।

Python अभ्यासों के साथ शुरुआत

अभ्यासों में कूदने से पहले, आपको Python कोड लिखने और चलाने के लिए एक बुनियादी वातावरण चाहिए। सौभाग्य से, शुरुआत करना अब पहले से कहीं आसान है।

तैयारी

Python को लोकल रूप से चलाने के लिए, Visual Studio Code जैसे शुरुआती‑अनुकूल कोड एडिटर को इंस्टॉल करें।

एक सामान्य सेटअप इस तरह दिखता है:

• आधिकारिक वेबसाइट से Python इंस्टॉल करें

• Visual Studio Code इंस्टॉल करें

• VS Code के अंदर Python एक्सटेंशन जोड़ें

• एक नया .py फ़ाइल बनाएँ और कोडिंग शुरू करें

VS Code कोडिंग शुरू करने के लिए अच्छा स्थान है, क्योंकि यह ओपन‑सोर्स और निःशुल्क है। आप उनका सॉफ्टवेयर डाउनलोड करने के लिए उनके डाउनलोड पेज पर जा सकते हैं। डाउनलोड पूरा होने पर इसे इंस्टॉल कर लें।

यदि आप कुछ इंस्टॉल नहीं करना चाहते हैं, तो आप DataLab का उपयोग कर सकते हैं—एक ब्राउज़र‑आधारित वातावरण जो आपको तुरंत Python (और SQL) कोड चलाने देता है। यह ट्यूटोरियल्स के साथ चलने, स्निपेट्स का परीक्षण करने और सेटअप समस्याओं की चिंता किए बिना प्रयोग करने के लिए आदर्श है।

इन अभ्यासों का उपयोग कैसे करें

सीखने को अधिकतम करने के लिए, इस लेख का प्रत्येक अभ्यास समाधान या स्पष्टीकरण पढ़ने से पहले करने के लिए डिज़ाइन किया गया है।

इन अभ्यासों का पूरा लाभ उठाने का सबसे अच्छा तरीका यह है:

• कम से कम 15 मिनट तक स्वयं समाधान निकालने की कोशिश करें
• पूरा प्रोग्राम लिखें, भले ही वह दोहरावपूर्ण लगे
• केवल तभी उत्तर कुंजी देखें जब आपने प्रयास कर लिया हो

सभी अभ्यासों की पूरी उत्तर कुंजी इस लिंक्ड DataLab वर्कबुक में उपलब्ध है। यह आपको अपने दृष्टिकोण की तुलना एक कार्यशील समाधान से करने और उसी समस्या को हल करने के वैकल्पिक तरीकों को समझने देता है।

वेरिएबल्स, इनपुट और आउटपुट के लिए Python अभ्यास

आइए कुछ बुनियादी अभ्यासों से शुरुआत करें जो मूल बिल्डिंग ब्लॉक्स पर केंद्रित हैं: मानों को स्टोर करना, यूज़र इनपुट पढ़ना और स्क्रीन पर आउटपुट प्रिंट करना।

व्यक्तिगत अभिवादन

शुरू करने के लिए, एक सरल Python अभ्यास देखें जो एक व्यक्तिगत संदेश प्रिंट करता है।

अभ्यास

एक प्रोग्राम लिखें जो:

• input() का उपयोग करके यूज़र से उसका नाम पूछे

• input() का उपयोग करके यूज़र से उसकी आयु पूछे

• फॉर्मैटेड स्ट्रिंग्स का उपयोग करते हुए एक अभिवादन संदेश प्रिंट करे

• वह वर्ष गणना करे जब यूज़र 100 वर्ष का होगा

कोड लिखने से पहले, ऐसे साधारण प्रोग्राम में सूचना का प्रवाह कैसे होता है, इस पर सोचना सहायक होता है। यूज़र कच्चा इनपुट टेक्स्ट के रूप में देता है, Python उस इनपुट को वेरिएबल्स में स्टोर करता है, और फिर आप उन मानों को किसी अर्थपूर्ण चीज़ में बदलते हैं। 

यह अभ्यास कई वास्तविक प्रोग्रामों का प्रतिबिंब है, जहाँ यूज़र इनपुट शायद ही अपने मूल रूप में उपयोगी होता है और पहले उसे मान्य या परिवर्तित करना पड़ता है।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

# Task: Ask for the user's name
name = input("Enter your name: ")

# Task: Ask for the user's age (note: input() returns a string)
age_str = input("Enter your age: ")

# Task: Convert age_str to an int
# age = ...

# Task: Calculate the year the user turns 100
# Tip: you'll need the current year
# current_year = ...
# year_turn_100 = ...

# Task: Print a personalized message using an f-string
# print(...)संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• input() हमेशा एक स्ट्रिंग लौटाता है

• int() का उपयोग करके स्ट्रिंग्स को इंटीजर में बदलना

• संख्याओं के साथ बुनियादी अंकगणित

• f‑स्ट्रिंग्स का उपयोग करके स्ट्रिंग फॉर्मैटिंग

यह अभ्यास सिखाता है कि कैलकुलेशन में उपयोग करने से पहले यूज़र इनपुट को अक्सर परिवर्तित करना पड़ता है।

टेम्परेचर कन्वर्टर

आइए आपकी Python स्किल्स का उपयोग कुछ बुनियादी यूनिट कन्वर्ज़न पर करें।

अभ्यास

एक प्रोग्राम लिखें जो:

• यूज़र से Celsius में तापमान पूछे

• इसे सूत्र F = (C × 9/5) + 32 का उपयोग करके Fahrenheit में बदले

• परिवर्तित तापमान प्रिंट करे

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

# Task: Ask the user for a Celsius temperature
celsius_str = input("Temperature in Celsius: ")

# Task: Convert the input to a float
# celsius = ...

# Task: Apply the conversion formula
# fahrenheit = ...

# Task: Print the result (consider formatting to 1–2 decimal places)
# print(...)संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• फ़्लोटिंग‑पॉइंट संख्याएँ

• अंकगणितीय अभिव्यक्तियाँ

• float() के साथ टाइप कास्टिंग

यह अभ्यास पुष्ट करता है कि सभी संख्यात्मक इनपुट पूर्णांक नहीं होते, और Python प्राकृतिक रूप से दशमलव को संभालता है।

स्वैप लॉजिक पहेली

यह अभ्यास मामूली दिखता है, लेकिन अक्सर शुरुआती वेरिएबल्स को ऐसे डिब्बों की तरह सोचते हैं जिन्हें चरणबद्ध तरीके से खाली और फिर से भरा जाना चाहिए। आइए देखें कि Python में वैल्यू स्वैप कैसे कर सकते हैं।

अभ्यास

आपको दो वेरिएबल्स दिए गए हैं: a = 5 और b = 10। उनकी वैल्यू को बिना मैन्युअली एक‑एक करके पुनः असाइन किए स्वैप करें।

Python असाइनमेंट के बारे में अधिक अभिव्यक्तिपूर्ण तरीका देता है, जहाँ वैल्यूज़ को एक ही ऑपरेशन में अनपैक और रिअसाइन किया जा सकता है।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

a = 5
b = 10

# Task: Swap a and b
# Hint: Try a temporary variable first.
# Then try the Pythonic approach (tuple unpacking).

# Task: Print the swapped values to verify
# print("a:", a)
# print("b:", b)संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• वेरिएबल असाइनमेंट
• टेम्पररी वेरिएबल्स बनाम ट्यूपल अनपैकिंग

यह ट्यूपल अनपैकिंग का परिचय कराता है, जो Python को संक्षिप्त और अभिव्यक्तिपूर्ण बनाता है।

बुनियादी बातों पर अधिक जानकारी के लिए हमारा Python चीट शीट देखें।

कंट्रोल फ्लो और लॉजिक के लिए Python अभ्यास

कंट्रोल फ्लो आपके प्रोग्राम्स को स्थितियों के आधार पर निर्णय लेने और क्रियाओं को दोहराने देता है।

ऑड या ईवन चेकर

मॉड्यूलो ऑपरेटर का एक सामान्य उपयोग ऑड/ईवन जाँच करना है। आइए इसे नीचे आजमाएँ।

अभ्यास

एक प्रोग्राम लिखें जो:

• यूज़र से एक संख्या पूछे

• मॉड्यूलो ऑपरेटर % का उपयोग करे

• प्रिंट करे कि संख्या ईवन है या ऑड

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

# Task: Ask the user for a number
num_str = input("Enter a whole number: ")

# Task: Convert to int
# num = ...

# Task: Use modulo (%) to decide even vs odd
# if ...:
#     print("Even")
# else:
#     print("Odd")संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• मॉड्यूलो ऑपरेटर

• if / else स्टेटमेंट्स

• बूलियन लॉजिक

यह अक्सर पहला उदाहरण होता है जहाँ शुरुआती देखते हैं कि स्थितियाँ प्रोग्राम के व्यवहार को कैसे नियंत्रित करती हैं।

क्लासिक FizzBuzz चैलेंज

एक सामान्य प्रोग्रामिंग चैलेंज FizzBuzz है। आइए देखें कि यह अभ्यास क्या शामिल करता है।

अभ्यास

1 से 100 तक की संख्याएँ निम्न नियमों के साथ प्रिंट करें:

• 3 के गुणज पर Fizz प्रिंट करें

• 5 के गुणज पर Buzz प्रिंट करें

• दोनों के गुणज पर FizzBuzz प्रिंट करें

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

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

# Task: Loop from 1 to 100
for n in range(1, 101):
    # Task: Check multiples of 3 AND 5 first
    # if ...:
    #     print("FizzBuzz")

    # Task: Then multiples of 3
    # elif ...:
    #     print("Fizz")

    # Task: Then multiples of 5
    # elif ...:
    #     print("Buzz")

    # Task: Otherwise, print the number
    # else:
    #     print(n)
    passसंचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• for लूप्स

• कंडीशनल ऑर्डरिंग

• लॉजिकल ऑपरेटर्स

यह अभ्यास प्रोग्रामर्स के लिए एक परंपरागत मील का पत्थर है और कंट्रोल फ्लो में संरचित सोच सिखाने के लिए आम है। लूप्स पर अधिक पढ़ें हमारे Python लूप ट्यूटोरियल में।

गेसिंग गेम

यह अभ्यास इंटरैक्टिव प्रोग्राम्स का परिचय कराता है जो यूज़र इनपुट पर डायनैमिक प्रतिक्रिया देते हैं।

अभ्यास

एक प्रोग्राम लिखें जो:

• एक रैंडम संख्या जनरेट करे (random इम्पोर्ट करते हुए)

• while लूप का उपयोग करके अनुमान पूछे

• हर अनुमान के बाद "Too high" या "Too low" फीडबैक प्रिंट करे

• सही संख्या अनुमान होने पर रुक जाए

यह अक्सर पहला अभ्यास है जहाँ शुरुआती एक ऐसा प्रोग्राम अनुभव करते हैं जो रैखिक नहीं लगता। पहले के स्क्रिप्ट्स के विपरीत, जो ऊपर से नीचे तक चलते हैं और समाप्त हो जाते हैं, यह प्रोग्राम तब तक चलता रहता है जब तक कोई शर्त पूरी न हो जाए।

यहाँ मुख्य वैचारिक छलांग है लूप टर्मिनेशन को समझना।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

import random

# Task: Pick a random number in a reasonable range
# target = random.randint(1, 100)

# Task: Use a while loop to keep asking until correct
# while ...:
#     guess_str = input("Your guess (1–100): ")
#     # guess = ...
#     # if guess > target:
#     #     print("Too high")
#     # elif guess < target:
#     #     print("Too low")
#     # else:
#     #     print("Correct!")
#     #     breakसंचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• मॉड्यूल्स इम्पोर्ट करना (random)

• while लूप्स

• लूप टर्मिनेशन कंडीशंस

लिस्ट्स, लूप्स और इटरेशन के लिए Python अभ्यास

लिस्ट्स आपको मानों के संग्रह के साथ काम करने देती हैं, जबकि लूप्स उन्हें कुशलता से प्रोसेस करने देते हैं।

लिस्ट समेशन

यह पैटर्न डेटा प्रोसेसिंग और एनालिटिक्स वर्कफ़्लोज़ में अक्सर दिखाई देता है।

अभ्यास

एक प्रोग्राम लिखें जो लिस्ट में सभी संख्याओं का योग निकाले, बिना बिल्ट‑इन sum() फ़ंक्शन का उपयोग किए। प्रोग्राम को स्वयं लूप में जोड़ने की लॉजिक को स्पष्ट रूप से करना चाहिए, न कि अन्य एग्रीगेशन हेल्पर्स पर निर्भर रहना चाहिए।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

numbers = [3, 7, 2, 9, 4]

# Task: Create an accumulator variable
# total = ...

# Task: Loop through numbers and add each value to total
# for ...:
#     ...

# Task: Print the final total
# print(total)संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• एक एक्यूम्युलेटर वेरिएबल इनिशियलाइज़ करना

• for लूप्स के साथ इटरेट करना

• कदम‑दर‑कदम मानों को अपडेट करना

लिस्ट से संबंधित अधिक उदाहरणों के लिए, हमारा गाइड देखें: Most Common Python List Questions।

अधिकतम संख्या खोजना

अगला अभ्यास पिछले वाले के समान है, लेकिन यह लूप के अंदर अलग तरह से काम करता है। यह एल्गोरिथ्मिक सोच को मजबूत करता है और दर्शाता है कि बिल्ट‑इन फ़ंक्शंस अंदरूनी तौर पर कैसे काम करते हैं।

अभ्यास

यूज़र को चुनौती दें कि वे लिस्ट में सबसे बड़ी संख्या max() का उपयोग किए बिना खोजें।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

numbers = [12, 5, 27, 3, 19]

# Task: Initialize current_max using the first element
# current_max = numbers[0]

# Task: Loop through the remaining elements and update current_max
# for ...:
#     if ...:
#         current_max = ...

# Task: Print the largest number
# print(current_max)संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• तुलनात्मक लॉजिक
• इटरेशन के दौरान स्टेट को ट्रैक करना

डुप्लिकेट्स हटाना

वास्तविक दुनिया का डेटा गड़बड़ होता है, और गड़बड़ डेटा में अक्सर डुप्लिकेट डेटा पॉइंट्स होते हैं। निम्नलिखित अभ्यास आपको डेटा क्लीनिंग कार्यों के लिए तैयार करता है।

अभ्यास

डुप्लिकेट तत्वों वाली लिस्ट को केवल यूनिक आइटम्स वाली नई लिस्ट में बदलें।

पहली नज़र में, यह समस्या सरल लग सकती है, लेकिन यह इस विचार का परिचय कराती है कि आपने अब तक क्या देखा है, इसका ट्रैक रखें। यह डेटा प्रोसेसिंग में एक आधारभूत अवधारणा है, जहाँ डुप्लिकेट रिकॉर्ड्स की पहचान और उन्हें हटाना एक नियमित कार्य है।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

data = ["apple", "banana", "apple", "orange", "banana", "kiwi"]

# Task: Create a new list for unique items
# unique = []

# Task: Loop through data and append items you haven't seen yet
# for item in data:
#     if ...:
#         ...

# Task: Print or return the unique list
# print(unique)संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• in का उपयोग करके मेंबरशिप जाँच

• नई लिस्ट्स बनाना

• डेटा की यूनिकनेस को समझना

डिक्शनरीज़ और स्ट्रिंग मैनिपुलेशन के लिए Python अभ्यास

डिक्शनरीज़ और स्ट्रिंग्स टेक्स्टुअल डेटा को व्यवस्थित और रूपांतरित करने के लिए आवश्यक हैं। आइए देखें कि इन्हें कैसे संभालें।

कैरक्टर फ़्रीक्वेंसी काउंटर

यह अभ्यास आपको फ़्रीक्वेंसी टेबल बनाना सिखाता है, जो एक सामान्य डेटा विश्लेषण कार्य है।

अभ्यास

एक स्ट्रिंग इनपुट लें और एक डिक्शनरी लौटाएँ जो गिने कि प्रत्येक कैरक्टर कितनी बार आता है।

यह अभ्यास एक बड़ा वैचारिक कदम दर्शाता है: आपका प्रोग्राम चलते समय डायनैमिक रूप से डेटा स्ट्रक्चर बनाना। पहले से परिभाषित लिस्ट या डिक्शनरी के साथ काम करने के बजाय, आप मिले डेटा के आधार पर एंट्री बनाते और अपडेट करते हैं।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

text = input("Enter some text: ")

# Task: Create an empty dictionary
# counts = {}

# Task: Loop over each character and update counts
# for ch in text:
#     # Option A: counts[ch] = counts.get(ch, 0) + 1
#     # Option B: if ch in counts: ... else: ...
#     pass

# Task: Print the frequency table
# print(counts)संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• डिक्शनरीज़

• .get() मेथड

• कंडीशनल इनिशियलाइज़ेशन

सरल फोनबुक

यह अभ्यास डिक्शनरी लॉजिक को छूता है, जो आगे चलकर सारणीबद्ध डेटा स्ट्रक्चर्स को समझने की नींव रखता है।

अभ्यास

एक ऐसा प्रोग्राम बनाएँ जो डिक्शनरी में नाम और नंबर स्टोर करे और यूज़र को नाम से सर्च करने दे।

यह अभ्यास एक बार की गणना के बजाय एक पर्सिस्टेंट लुकअप टूल के रूप में प्रोग्राम का उपयोग करने के विचार का परिचय कराता है। आप यह मॉडल कर रहे हैं कि कई एप्लिकेशन जानकारी को कैसे स्टोर और रिट्रीव करते हैं—एक सरल संस्करण।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

phonebook = {
    # "Alice": "9123 4567",
    # "Ben": "9876 5432",
}

# Task: (Optional) add entries via input()
# name = input("Name to add: ")
# number = input("Number to add: ")
# phonebook[name] = number

# Task: Search loop (one lookup is fine for a start)
query = input("Search name: ")

# Task: Print the number if found, otherwise print a friendly message
# if ...:
#     print(...)
# else:
#     print("Not found")संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• डिक्शनरी लुकअप्स
• की‑वैल्यू संबंध

यदि आप डिक्शनरीज़ में गहराई से जाना चाहते हैं, तो हमारा व्यापक गाइड पढ़ने की सलाह देता हूँ: Python Dictionary Methods।

पलिंड्रोम चेकर

यह अभ्यास टेक्स्ट प्रोसेसिंग को तार्किक तुलना के साथ जोड़ता है, पलिंड्रोम्स को देखते हुए।

अभ्यास

पलिंड्रोम वह शब्द, वाक्यांश, संख्या या कैरक्टरों का क्रम होता है जो आगे और पीछे से पढ़ने पर समान हो। एक स्क्रिप्ट बनाएँ जो जाँच करे कि कोई स्ट्रिंग आगे और पीछे से समान पढ़ी जाती है या नहीं (केस और स्पेसेज़ को नज़रअंदाज़ करते हुए)।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

text = input("Enter a word or phrase: ")

# Task: Normalize (lowercase + remove spaces)
# normalized = ...

# Task: Reverse using slicing
# reversed_text = ...

# Task: Compare and print a result message
# if ...:
#     print("Palindrome")
# else:
#     print("Not a palindrome")संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• स्ट्रिंग मेथड्स (lower(), replace())

• स्ट्रिंग स्लाइसिंग ([::-1])

फ़ंक्शंस और मॉड्युलैरिटी के लिए Python अभ्यास

फ़ंक्शंस आपको दोहराव से बचाते हुए, पुन: उपयोग योग्य, व्यवस्थित कोड लिखने देते हैं।

फ़ैक्टोरियल कैलकुलेटर

फ़ैक्टोरियल कैलकुलेटर आपको रिटर्न वैल्यूज़ समझने में मदद करेगा, जो बड़े प्रोग्राम बनाने के लिए अहम हैं।

अभ्यास

एक फ़ंक्शन परिभाषित करें जो एक इंटीजर ले और एक लूप का उपयोग करके उसका फ़ैक्टोरियल लौटाए।

किसी वैल्यू को प्रिंट करना और उसे रिटर्न करना—इनके बीच का अंतर विशेष रूप से महत्वपूर्ण है। रिटर्न करने से आपका फ़ंक्शन अन्य कोड के साथ संयोजित किया जा सकता है, जो तब आवश्यक होता है जब प्रोग्राम एक ही फ़ाइल से आगे बढ़ता है।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

def factorial(n: int) -> int:
    """Return n! (factorial of n) using a loop."""
    # Task: Decide how to handle n < 0

    # Task: Initialize result
    # result = ...

    # Task: Multiply result by each integer from 1 to n
    # for ...:
    #     ...

    # Task: Return the computed factorial
    # return result
    pass

# Optional quick test
# print(factorial(5))  # expected: 120संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• फ़ंक्शन डेफिनिशंस
• लूप‑आधारित कैलकुलेशंस
• रिटर्निंग वैल्यूज़ बनाम प्रिंटिंग

फ़ंक्शंस पर अधिक पढ़ें हमारे Python फ़ंक्शंस ट्यूटोरियल में।

प्राइम नंबर वेलिडेटर

अगला, हम प्राइम नंबर वेलिडेटर फ़ंक्शन देखेंगे। इससे आपको पुन: उपयोग योग्य फ़ंक्शंस बनाना सीखने में मदद मिलेगी।

अभ्यास

True लौटाने वाला एक फ़ंक्शन लिखें यदि संख्या प्राइम है, अन्यथा False।

प्राइम जाँच यह भी दर्शाती है कि फ़ंक्शंस लॉजिक को साफ़‑सुथरे तरीके से संक्षिप्त कर सकते हैं। एक बार लिखने के बाद, फ़ंक्शन को कहीं भी उसके आंतरिक विवरण समझे बिना पुन: उपयोग किया जा सकता है।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

def is_prime(n: int) -> bool:
    """Return True if n is prime, otherwise False."""
    # Task: Handle small cases (n <= 1)

    # Task: Check divisibility from 2 up to an appropriate limit
    # for ...:
    #     if ...:
    #         return False

    # Task: If no divisors found, return True
    # return True
    pass

# Optional quick tests
# print(is_prime(2))   # expected: True
# print(is_prime(15))  # expected: Falseसंचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• लूपिंग
• अर्ली रिटर्न्स
• तार्किक दक्षता

लचीला आर्गुमेंट प्रिंटर

यह कई Python लाइब्रेरीज़ में उपयोग होने वाले उन्नत फ़ंक्शन सिग्नेचर्स का परिचय कराता है।

अभ्यास

एक फ़ंक्शन बनाएँ जो *args का उपयोग करके किसी भी संख्या में आर्गुमेंट्स स्वीकार करे और उन्हें एक‑एक करके प्रिंट करे।

यह अभ्यास आपको Python की एक लचीली विशेषता—वेरिएबल‑लेंथ आर्गुमेंट्स—से परिचित कराता है। यह आपकी सोच को फिक्स्ड इनपुट्स से हटाकर ऐसे फ़ंक्शंस की ओर ले जाता है जो अलग‑अलग उपयोग पैटर्न्स के अनुसार ढल सकते हैं।

*args को समझना वास्तविक‑दुनिया की Python लाइब्रेरीज़ को पढ़ना और उपयोग करना आसान बनाता है, जहाँ फ़ंक्शंस अक्सर सुविधा और विस्तारशीलता के लिए लचीली संख्या में पैरामीटर्स स्वीकार करते हैं।

स्टार्टर कोड

यहाँ मार्गदर्शन के लिए कुछ स्टार्टर कोड दिया गया है:

def print_args(*args) -> None:
    """Print each positional argument on its own line."""
    # Task: Loop over args and print each one
    # for ...:
    #     print(...)
    pass

# Optional quick test
# print_args("hello", 42, True)संचालित द्वारा

प्रमुख अवधारणाएँ अभ्यास में

• वेरिएबल‑लेंथ आर्गुमेंट्स
• फ़ंक्शन की लचीलापन

गाइडेड प्रोजेक्ट्स के साथ Python स्किल्स लागू करना

अभ्यास कौशल बनाते हैं, लेकिन प्रोजेक्ट्स उन कौशलों को आत्मविश्वास में बदलते हैं।

Netflix फिल्मों की जाँच

Investigating Netflix Movies गाइडेड प्रोजेक्ट एक भ्रामक रूप से सरल प्रश्न पूछता है: क्या समय के साथ फिल्में छोटी होती जा रही हैं? इसका उत्तर देने के लिए, आप Netflix शीर्षकों के एक वास्तविक डेटासेट के साथ काम करेंगे और कच्ची डेटा पंक्तियों को क्रमशः एक स्पष्ट, दृश्य अंतर्दृष्टि में बदलेंगे।

इस प्रोजेक्ट की ताकत यह है कि यह शुरुआती Python बुनियादी बातों और लागू डेटा विश्लेषण के बीच की खाई को पाटता है। आप देखते हैं कि साधारण लॉजिक कैसे सही टूल्स के साथ मिलकर स्केल होता है—वह भी कुछ लोकल इंस्टॉल किए बिना।

डॉ. सेमेल्वाइस और हैंडवॉशिंग की खोज

यह Dr. Semmelweis and the Importance of Handwashing प्रोजेक्ट आपको एक डेटा विश्लेषक की भूमिका में रखता है जो एक वास्तविक ऐतिहासिक समस्या की जाँच कर रहा है। उन्नीसवीं सदी के मध्य में, डॉ. इग्नाज़ सेमेल्वाइस ने एक अस्पताल की एक वार्ड में असामान्य रूप से उच्च मृत्यु दर देखी, लेकिन यह साबित करने के लिए उनके पास संगणनात्मक उपकरण नहीं थे कि क्यों।

ऐतिहासिक अभिलेखों का उपयोग करते हुए, आप हैंडवॉशिंग की शुरुआत से पहले और बाद की मृत्यु दर का विश्लेषण करेंगे। प्रोजेक्ट का फोकस pandas के साथ सारणीबद्ध डेटा में बदलाव करना, दरों की गणना करना और समय अवधियों में औसत की तुलना करना है। 

NYC Airbnb मार्केट का अन्वेषण

Exploring Airbnb Market Trends प्रोजेक्ट में, आप एक ऐसी स्थिति में कदम रखते हैं जो वास्तविक‑दुनिया के एनालिटिक्स कार्य से काफ़ी मेल खाती है: बिखरा‑बिखरा, असंगत डेटा जिसे किसी भी सार्थक विश्लेषण से पहले काफ़ी सफाई की आवश्यकता होती है। 

डेटासेट में रेंटल लिस्टिंग्स हैं जिनमें कीमतें स्ट्रिंग्स के रूप में स्टोर हैं, रिव्यू स्कोर गायब हैं, और फ़ॉर्मैटिंग असंगत है।

आपका प्राथमिक कार्य डेटा को साफ़ करना और मानकीकृत करना है। प्रोजेक्ट इस विचार को मजबूत करता है कि डेटा तैयारी कोई प्रारंभिक झंझट नहीं, बल्कि एक मुख्य विश्लेषणात्मक कौशल है। अक्सर, डेटा प्रैक्टिशनर्स का अधिकांश समय डेटा साफ़ करने में जाता है, और यह प्रोजेक्ट उस क्षमता के लिए एक उत्कृष्ट व्यावहारिक चेकपॉइंट है।

निष्कर्ष

आपने सरल वेरिएबल्स और यूज़र इनपुट से शुरुआत की, फिर कंट्रोल फ्लो, डेटा स्ट्रक्चर्स, फ़ंक्शंस तक प्रगति की, और अंत में गाइडेड प्रोजेक्ट्स में सब कुछ लागू किया। इन अभ्यासों ने आपको यह समझने की अच्छी झलक दी होगी कि वास्तविक‑दुनिया के परिवेश में Python का उपयोग कैसे होता है।

आपका स्वाभाविक अगला कदम है संरचित सीखना। नियमित अभ्यास और संरचित, गाइडेड निर्देश का संयोजन—अभ्यासों को विशेषज्ञता में बदलने का सबसे तेज़ तरीका है। मैं हमारे Python Programming या Data Scientist ट्रैक में नामांकन करने की सिफारिश करता/करती हूँ ताकि आप शुर‍ू कर सकें।