NumPy के साथ रैंडम नंबर जनरेटर ट्यूटोरियल

NumPy का random मॉड्यूल स्यूडो-रैंडम नंबर जेनरेशन पर आधारित फ़ंक्शनों का एक समूह है। Random का अर्थ है ऐसा जो तार्किक रूप से पूर्वानुमानित न हो सके।

अपडेट किया गया 25 सित॰ 2026 · 4 मि॰ पढ़ें

AI के साथ खोजें

ChatGPT Claude Perplexity

`np.random.seed()` फ़ंक्शन

इस उदाहरण में, आप सिक्का उछालने का सिमुलेशन करेंगे। आप np.random() फ़ंक्शन का उपयोग करेंगे, जो 0 और 1 के बीच एक संख्या चुनता है ताकि इस अंतराल की सभी संख्याएँ समान संभावना से आएँ।

यदि निकली हुई संख्या 0.5 से कम है, जिसकी होने की 50% संभावना है, तो आप हेड्स कहेंगे, अन्यथा टेल्स। ऐसे परिणाम, जहाँ नतीजा या तो True (हेड्स) या False (टेल्स) होता है, को Bernoulli ट्रायल कहा जाता है।

स्यूडो-रैंडम नंबर एक seed नाम के पूर्णांक से शुरू होकर क्रमिक रूप से संख्याएँ उत्पन्न करके काम करता है। वही seed वही रैंडम संख्याओं का क्रम देता है, इसलिए इसे "स्यूडो" रैंडम नंबर जेनरेशन कहा जाता है। यदि आप पुनरुत्पाद्य (reproducible) कोड चाहते हैं, तो np.random.seed() फ़ंक्शन का उपयोग करके रैंडम नंबर जेनरेटर को seed करना अच्छा होता है।

सिक्का उछालने के लिए, आप NumPy आयात करते हैं, रैंडम नंबर जेनरेटर को seed करते हैं, और फिर चार रैंडम संख्याएँ निकालते हैं। आप size कीवर्ड से यह बता सकते हैं कि आपको कितनी रैंडम संख्याएँ चाहिए।

import numpy as np
np.random.seed(42)
random_numbers = np.random.random(size=4)
random_numbers

array([0.3745012, 0.95071431, 0.73199394, 0.59865848])

आपको मिली पहली संख्या 0.5 से कम है, इसलिए वह हेड्स है जबकि बाकी तीन टेल्स हैं। आप इसे स्पष्ट रूप से less-than ऑपरेशन का उपयोग करके दिखा सकते हैं, जो आपको boolean मानों वाला एक array देता है—हेड्स के लिए True और टेल्स के लिए False।

heads = random_numbers < 0.5
heads

array([True, False, False, False], dtype=bool)

अंत में, आप boolean heads array का योग करके हेड्स की संख्या निकाल सकते हैं, क्योंकि संख्यात्मक संदर्भ में Python True को एक और False को शून्य मानता है।

np.sum(heads)

चार रैंडम सिक्का उछाल का सिमुलेशन

अगले उदाहरण में, हम यह जानना चाहते हैं कि यदि हम सिक्के की चार उछालों को बार-बार दोहराएँ, तो चारों बार हेड्स आने की प्रायिकता क्या होगी। हम यह for लूप से कर सकते हैं।

हम पहले काउंट को शून्य से आरंभ करते हैं। फिर हम चार-उछाल वाले ट्रायल के 10,000 दोहराव करते हैं। यदि किसी दिए गए ट्रायल में चारों हेड्स आए, तो हम काउंट बढ़ा देते हैं।

तो चारों हेड्स आने की प्रायिकता क्या है? यह है जितनी बार आपको सभी हेड्स मिले, उसे कुल ट्रायल की संख्या से भाग देना। परिणाम लगभग 0.06 आता है।

n_all_heads = 0

# Initialize number of 4-heads trials
for _ in range(10000):
         heads = np.random.random(size=4) < 0.5
         n_heads = np.sum(heads)
         if n_heads == 4:
             n_all_heads += 1

n_all_heads / 10000

0.0621

रैंडम संख्याएँ जनरेट करने का इंटरैक्टिव उदाहरण

इस उदाहरण में, हम शून्य और एक के बीच बहुत-सी रैंडम संख्याएँ जनरेट करेंगे, और फिर परिणामों का एक histogram प्लॉट करेंगे। यदि संख्याएँ वास्तव में रैंडम हैं, तो histogram की सभी पट्टियाँ (लगभग) समान ऊँचाई की होनी चाहिए।

इस उदाहरण के लिए आपको यह करना होगा:

np.random.seed से seed 42 का उपयोग करके रैंडम नंबर जेनरेटर को seed करें।
100,000 प्रविष्टियों वाला एक खाली array, random_numbers, आरंभ करें ताकि उसमें random numbers संग्रहीत हों। सुनिश्चित करें कि आप इसके लिए np.empty(100000) का उपयोग करें।
np.random.random() का उपयोग करके 100,000 रैंडम संख्याएँ निकालने और उन्हें random_numbers array में रखने के लिए एक for लूप लिखें। ऐसा करने के लिए range(100000) पर लूप करें।
random_numbers का histogram प्लॉट करें। इस मामले में अक्षों को लेबल करना आवश्यक नहीं है क्योंकि हम सिर्फ रैंडम नंबर जेनरेटर की जाँच कर रहे हैं।

# Seed the random number generator
np.random.seed(42)

# Initialize random numbers: random_numbers
random_numbers = np.empty(100000)

# Generate random numbers by looping over range(100000)
for i in range(100000):
    random_numbers[i] = np.random.random()

# Plot a histogram
_ = plt.hist(random_numbers)

# Show the plot
plt.show()

जब हम ऊपर दिया गया कोड चलाते हैं, तो यह निम्नलिखित परिणाम उत्पन्न करता है: