मध्यवर्ती पायथन

मॉड्यूल्स

Python सीखने की यात्रा में, हमने print(), input(), type() आदि जैसे पूर्वनिर्धारित Python फ़ंक्शंस का उपयोग किया है। Python में बहुत सारे फ़ंक्शंस हैं, और उनमें से सभी सीधे एक नए Python स्क्रिप्ट से उपलब्ध नहीं होते। इसके बजाय, वे अलग-अलग फाइलों में संग्रहीत होते हैं, जिन्हें modules कहा जाता है। इन फ़ंक्शंस का उपयोग करने के लिए, हमें उस मॉड्यूल को import करना होता है जिसमें वे होते हैं। यह import स्टेटमेंट का उपयोग करके किया जाता है। आइए इसे एक उदाहरण से समझते हैं:
import math           # math मॉड्यूल को इम्पोर्ट करना

print(math.pi)        # math मॉड्यूल से स्थिरांक pi तक पहुंचना
print(math.sqrt(16))  # math मॉड्यूल से sqrt फ़ंक्शन का उपयोग करना
यह प्रोग्राम pi का मान (3.141592653589793) और 16 का वर्गमूल (4.0) प्रिंट करेगा।
हम from...import स्टेटमेंट का उपयोग करके किसी मॉड्यूल से विशेष गुण या फ़ंक्शंस भी इम्पोर्ट कर सकते हैं:
from math import pi, sqrt  # math मॉड्यूल से केवल pi और sqrt को इम्पोर्ट करना

print(pi)                  # हम pi का उपयोग सीधे कर सकते हैं बिना मॉड्यूल नाम के
print(sqrt(16))            # इसी तरह, हम sqrt का सीधे उपयोग कर सकते हैं
प्रोग्राम का आउटपुट पहले वाले के समान ही होगा।
कभी-कभी, मॉड्यूल्स के नाम बहुत लंबे होते हैं, और जब भी हमें कोई फ़ंक्शन उपयोग करना होता है, तो पूरा नाम टाइप करना थकाऊ हो सकता है। इसे रोकने के लिए, हम as कीवर्ड का उपयोग करके मॉड्यूल को एक अलग नाम (उपनाम) दे सकते हैं।
import math as m   # math मॉड्यूल को इम्पोर्ट करना और इसे m नाम देना

print(m.pi)        # अब हम छोटे उपनाम का उपयोग कर सकते हैं
print(m.sqrt(16))  # उपनाम का उपयोग करके sqrt फ़ंक्शन का उपयोग करना
आउटपुट भी पहले की तरह 3.141592653589793 और 4.0 होगा।
अंत में, Python में मॉड्यूल्स टूलबॉक्स की तरह हैं जो पूर्वनिर्धारित फ़ंक्शंस और वेरिएबल्स को रखते हैं जिन्हें हम अपने प्रोग्राम में इम्पोर्ट करके उपयोग कर सकते हैं। वे कोड को संगठित करने और उसे अधिक दक्ष बनाने में मदद करते हैं।
मॉड्यूल्स अंदर से कैसे काम करते हैं
जब आप किसी मॉड्यूल को इम्पोर्ट करते हैं, तो Python पृष्ठभूमि में कुछ काम करता है जो तुरंत स्पष्ट नहीं हो सकता। यहां बताया गया है कि जब आप import स्टेटमेंट का उपयोग करते हैं तो क्या होता है:
  1. मॉड्यूल को ढूँढना: Python सबसे पहले अपने sys.path सूची में निर्दिष्ट स्थानों को चेक करके मॉड्यूल ढूँढता है। इस सूची में वर्तमान डायरेक्टरी, बिल्ट-इन Python पैकेजेस डायरेक्टरी, और PYTHONPATH एन्वायरनमेंट वेरिएबल में निर्दिष्ट कोई भी पथ शामिल होता है। यदि Python को मॉड्यूल मिलता है, तो वह अगले चरणों पर बढ़ता है। यदि नहीं, तो वह ModuleNotFoundError उत्पन्न करता है।
  1. मॉड्यूल का Initialization: एक बार मॉड्यूल फ़ाइल मिलने के बाद, Python एक नया मॉड्यूल ऑब्जेक्ट (types.ModuleType) बनाता है। फिर यह मॉड्यूल की सामग्री को इस नए मॉड्यूल ऑब्जेक्ट में लोड करता है, मॉड्यूल फ़ाइल के सभी टॉप-लेवल कोड को निष्पादित करते हुए। इसमें फ़ंक्शंस, क्लासेस, वेरिएबल्स की परिभाषाएँ और इनिशियलाइजेशन कोड का निष्पादन शामिल होता है।
  1. मॉड्यूल को कैश करना: Initialization के बाद, मॉड्यूल को sys.modules (एक डिक्शनरी) में कैश किया जाता है। यह कदम सुनिश्चित करता है कि जब एक ही मॉड्यूल को फिर से स्क्रिप्ट में (या अन्य स्क्रिप्ट्स द्वारा) इम्पोर्ट किया जाता है, तो Python को फिर से मॉड्यूल को ढूँढने और इनिशियलाइज़ करने की आवश्यकता नहीं होती। इसके बजाय, यह कैश किए गए संस्करण का उपयोग कर सकता है। इस डिक्शनरी में कुंजी मॉड्यूल का नाम है, और मान मॉड्यूल ऑब्जेक्ट है।
  1. मॉड्यूल को इम्पोर्टर के Namespace में जोड़ना: अंत में, Python उस स्क्रिप्ट या मॉड्यूल के नेमस्पेस में मॉड्यूल का नाम जोड़ता है जिसने इसे इम्पोर्ट किया है। यह नाम मॉड्यूल ऑब्जेक्ट को संदर्भित करता है, इसलिए आप डॉट नोटेशन का उपयोग करके मॉड्यूल के फ़ंक्शंस और वेरिएबल्स तक पहुंच सकते हैं।
आइए इसे कुछ कोड के साथ दर्शाते हैं:
import sys
import math

print(sys.path)       # मॉड्यूल्स खोजने के लिए Python जिन पथों को चेक करता है
print(sys.modules)    # कैश किए गए मॉड्यूल्स
print(math.sqrt(16))  # math मॉड्यूल से एक फ़ंक्शन का उपयोग करना
sys.path उन डायरेक्टरीज़ की सूची प्रिंट करता है जहां Python मॉड्यूल्स की खोज करता है। sys.modules मॉड्यूल नामों (कुंजियों) और उनके संबंधित मॉड्यूल ऑब्जेक्ट्स (मानों) की एक डिक्शनरी प्रिंट करता है।

चुनौती: रैंडम नंबर्स

क्रिप्टोग्राफी की दुनिया में, रैंडम नंबर्स एक बेहद महत्वपूर्ण भूमिका निभाते हैं। क्रिप्टोग्राफिक एल्गोरिदम अक्सर डेटा को सुरक्षित रखने के लिए रैंडम नंबर्स की एक श्रृंखला उत्पन्न करने पर निर्भर करते हैं।
इस चुनौती में, आपको एक सरल रैंडम नंबर जेनरेटर का सिमुलेशन करना है जो हमें रैंडमनेस को अधिक स्पष्ट रूप से समझने में मदद करेगा। Python में random नामक एक बिल्ट-इन मॉड्यूल है जिसमें विभिन्न फ़ंक्शंस हैं जो रैंडम नंबर्स जनरेट करते हैं। आपको इस मॉड्यूल का उपयोग करते हुए दो दिए गए नंबर a और b के बीच n रैंडम पूर्णांकों की एक सूची जनरेट करनी है। हालांकि, रैंडमनेस वास्तव में पूरी तरह से रैंडम नहीं होनी चाहिए - हमें प्रयोग की पुनरावृत्ति के लिए सीड को 42 पर फिक्स करना है। आप सीड को फिक्स करने के लिए seed() फ़ंक्शन और रैंडम नंबर जनरेट करने के लिए randint() का उपयोग कर सकते हैं।
इनपुट की पहली पंक्ति में तीन स्पेस द्वारा अलग किए गए पूर्णांक होते हैं: n, a, और b। नंबर a और b उस रेंज (इन्क्लूसिव) को निर्धारित करते हैं जिससे रैंडम नंबर चुने जाने चाहिए, और n से पता चलता है कि आपको ऐसे कितने नंबर जनरेट करने हैं।
प्रोग्राम को [a, b] रेंज के भीतर जनरेट किए गए n स्पेस द्वारा अलग किए गए रैंडम नंबर प्रिंट करना चाहिए, जिसमें रैंडम सीड 42 पर फिक्स हो।
इनपुट
आउटपुट
10 1 100
82 15 4 95 36 32 29 18 95 14
5 1 5
1 1 3 2 2
3 10 20
20 11 10
नोट: चूंकि हमने रैंडम सीड को 42 पर सेट किया है, आउटपुट का क्रम प्रोग्राम के कई रन में समान रहेगा। यह एक विशेषता है जिसे हम टेस्टिंग, डिबगिंग, और अन्य स्थितियों में उपयोग करते हैं जहां निश्चित आउटपुट आवश्यक होता है।
 

Constraints

Time limit: 2 seconds

Memory limit: 512 MB

Output limit: 1 MB

To check your solution you need to sign in
Sign in to continue