Python 3.7 - random

यादृच्छिक - छद्म यादृच्छिक संख्या उत्पन्न करें




python

यादृच्छिक - छद्म यादृच्छिक संख्या उत्पन्न करें

स्रोत कोड: Lib/random.py

यह मॉड्यूल विभिन्न वितरणों के लिए छद्म यादृच्छिक संख्या जनरेटर लागू करता है।

पूर्णांकों के लिए, एक सीमा से एक समान चयन होता है। अनुक्रमों के लिए, एक यादृच्छिक तत्व का एक समान चयन होता है, एक जगह में एक सूची के यादृच्छिक क्रमांकन उत्पन्न करने के लिए एक फ़ंक्शन, और प्रतिस्थापन के बिना यादृच्छिक नमूनाकरण के लिए एक फ़ंक्शन।

वास्तविक रेखा पर, समान, सामान्य (गाऊसी), लॉगनॉर्मल, नकारात्मक घातांक, गामा और बीटा वितरण की गणना करने के लिए कार्य हैं। कोणों के वितरण को उत्पन्न करने के लिए, वॉन मिल्स वितरण उपलब्ध है।

लगभग सभी मॉड्यूल फ़ंक्शन बुनियादी फ़ंक्शन random() पर निर्भर करते हैं, जो अर्ध-खुली सीमा [0.0, 1.0) में समान रूप से एक यादृच्छिक फ्लोट उत्पन्न करता है। पाइथन कोर जनरेटर के रूप में मेर्सेन ट्विस्टर का उपयोग करता है। यह 53-बिट सटीक फ़्लोट्स का उत्पादन करता है और इसकी अवधि 2 ** 19937-1 है। सी में अंतर्निहित कार्यान्वयन दोनों तेज और थ्रेडसेफ़ हैं। Mersenne ट्विस्टर अस्तित्व में सबसे व्यापक रूप से परीक्षण किए गए यादृच्छिक संख्या जनरेटर में से एक है। हालांकि, पूरी तरह से निर्धारक होने के नाते, यह सभी उद्देश्यों के लिए उपयुक्त नहीं है, और क्रिप्टोग्राफ़िक उद्देश्यों के लिए पूरी तरह से अनुपयुक्त है।

इस मॉड्यूल द्वारा आपूर्ति किए गए कार्य वास्तव में random.Random वर्ग के एक छिपे हुए उदाहरण के बंधे हुए तरीके हैं। आप उन जनरेटर को प्राप्त करने के लिए Random अपने स्वयं के उदाहरणों को Random कर सकते हैं जो राज्य को साझा नहीं करते हैं।

यदि आप अपने स्वयं के getstate() एक अलग मूल जनरेटर का उपयोग करना चाहते हैं तो क्लास Random को भी उप-वर्गित किया जा सकता है: उस स्थिति में, random() , seed() , getstate() , और setstate() विधियों को setstate() । वैकल्पिक रूप से, एक नया जनरेटर एक getrandbits() विधि की आपूर्ति कर सकता है - इससे randrange() एक मनमाने ढंग से बड़ी सीमा पर चयन का उत्पादन करने की अनुमति देता है।

random मॉड्यूल भी SystemRandom वर्ग प्रदान करता है जो ऑपरेटिंग सिस्टम द्वारा प्रदान किए गए स्रोतों से यादृच्छिक संख्या उत्पन्न करने के लिए सिस्टम फ़ंक्शन os.urandom() का उपयोग करता है।

चेतावनी

इस मॉड्यूल के छद्म यादृच्छिक जनरेटर का उपयोग सुरक्षा उद्देश्यों के लिए नहीं किया जाना चाहिए। सुरक्षा या क्रिप्टोग्राफ़िक उपयोगों के लिए, secrets मॉड्यूल देखें।

यह भी देखें

एम। मात्सुमोतो और टी। निशिमुरा, "मेर्सेन ट्विस्टर: ए 623-डिमेंसिडली यूनिफॉर्म स्यूडोरैंड्रैंडम नंबर जनरेटर", मॉडलिंग और कंप्यूटर सिमुलेशन वॉल्यूम पर एसीएम लेनदेन। 8, नंबर 1, जनवरी pp.330 1998।

एक लंबी अवधि और तुलनात्मक रूप से सरल अद्यतन संचालन के साथ एक संगत वैकल्पिक यादृच्छिक संख्या जनरेटर के लिए पूरक-बहु-साथ-साथ नुस्खा

बहीखाता कार्य

random.seed(a=None, version=2)

यादृच्छिक संख्या जनरेटर को प्रारंभ करें।

यदि कोई छोड़ा गया है या None , तो वर्तमान सिस्टम समय का उपयोग किया जाता है। यदि ऑपरेटिंग सिस्टम द्वारा यादृच्छिकता स्रोत प्रदान किए जाते हैं, तो सिस्टम समय के बजाय उनका उपयोग किया जाता है os.urandom() उपलब्धता पर विवरण के लिए os.urandom() फ़ंक्शन देखें)।

यदि कोई इंट है, तो इसका उपयोग सीधे किया जाता है।

संस्करण 2 (डिफ़ॉल्ट) के साथ, एक str , bytes या bytearray ऑब्जेक्ट एक int परिवर्तित हो जाता है और इसके सभी बिट्स का उपयोग किया जाता है।

संस्करण 1 के साथ (पायथन के पुराने संस्करणों से यादृच्छिक दृश्यों को पुन: प्रस्तुत करने के लिए प्रदान किया गया), str और bytes लिए एल्गोरिथ्म बीज की एक संकीर्ण रेंज उत्पन्न करता है।

संस्करण 3.2 में बदला: एक स्ट्रिंग बीज में सभी बिट्स का उपयोग करने वाले संस्करण 2 योजना में ले जाया गया।

random.getstate()

जेनरेटर की वर्तमान आंतरिक स्थिति को कैप्चर करने वाली कोई वस्तु लौटाएं। इस ऑब्जेक्ट को राज्य को पुनर्स्थापित करने के लिए setstate() पारित किया जा सकता है।

random.setstate(state)

राज्य को पिछले कॉल से getstate() तक प्राप्त किया जाना चाहिए, और setstate() जनरेटर की आंतरिक स्थिति को पुनर्स्थापित करता है कि यह उस समय क्या था getstate() कहा जाता था।

random.getrandbits(k)

के यादृच्छिक बिट्स के साथ एक अजगर पूर्णांक लौटाता है। यह विधि MersenneTwister जनरेटर के साथ आपूर्ति की जाती है और कुछ अन्य जनरेटर भी इसे एपीआई के वैकल्पिक भाग के रूप में प्रदान कर सकते हैं। जब उपलब्ध हो, getrandbits() randrange() को मनमाने ढंग से बड़ी श्रेणियों को संभालने में सक्षम बनाता है।

पूर्णांकों के लिए कार्य

random.randrange(stop)
random.randrange(start, stop[, step])

range(start, stop, step) से एक यादृच्छिक रूप से चयनित तत्व लौटें। यह choice(range(start, stop, step)) बराबर है choice(range(start, stop, step)) , लेकिन वास्तव में रेंज ऑब्जेक्ट नहीं बनता है।

स्थिति तर्क पैटर्न range() से मेल खाती है। कीवर्ड तर्क का उपयोग नहीं किया जाना चाहिए क्योंकि फ़ंक्शन अप्रत्याशित तरीकों से उनका उपयोग कर सकता है।

संस्करण 3.2 में बदला: समान रूप से वितरित मूल्यों के उत्पादन के बारे में randrange() अधिक परिष्कृत है। पूर्व में इसने int(random()*n) जैसी शैली का उपयोग किया था जो थोड़ा असमान वितरण पैदा कर सकता था।

random.randint(a, b)

एक यादृच्छिक पूर्णांक N को लौटाएं जैसे कि a <= N <= brandrange(a, b+1) लिए उपनाम randrange(a, b+1)

अनुक्रमों के लिए कार्य

random.choice(seq)

गैर-रिक्त अनुक्रम seq से एक यादृच्छिक तत्व लौटें। यदि seq खाली है, तो IndexError उठाता है।

random.choices(population, weights=None, *, cum_weights=None, k=1)

प्रतिस्थापन के साथ जनसंख्या से चुने गए तत्वों की k आकार सूची लौटाएं। यदि आबादी खाली है, तो IndexError उठाता है।

यदि एक भार अनुक्रम निर्दिष्ट किया जाता है, तो सापेक्ष भार के अनुसार चयन किया जाता है। वैकल्पिक रूप से, यदि एक cum_weights अनुक्रम दिया जाता है, तो चयन संचयी भार (शायद itertools.accumulate() ) का उपयोग करके गणना की जाती है। उदाहरण के लिए, सापेक्ष भार [10, 5, 30, 5] संचयी भार के बराबर हैं [10, 15, 45, 50] । आंतरिक रूप से, सापेक्ष वजन चयन करने से पहले संचयी भार में बदल जाते हैं, इसलिए संचयी भार की आपूर्ति से काम बच जाता है।

यदि न तो वज़न और न ही cum_weights निर्दिष्ट हैं, तो चयन समान संभावना के साथ किए जाते हैं। यदि एक वेट सीक्वेंस की आपूर्ति की जाती है, तो यह जनसंख्या अनुक्रम के समान लंबाई होनी चाहिए। यह वज़न और सह_ दोनों को निर्दिष्ट करने के लिए एक टाइपऑयॉर है

वेट या कम_वेट्स किसी भी संख्यात्मक प्रकार का उपयोग कर सकते हैं जो random पूर्णांक ( फ्लोटर्स , और अंशों को शामिल करता है, लेकिन दशमलव को शामिल करता है random द्वारा लौटाए गए मानों के साथ अंतर करता है।

संस्करण 3.6 में नया।

random.shuffle(x[, random])

अनुक्रम x को जगह में फेरबदल करें।

वैकल्पिक तर्क यादृच्छिक एक 0-तर्क फ़ंक्शन है जो [0.0, 1.0) में एक यादृच्छिक फ्लोट लौटाता है; डिफ़ॉल्ट रूप से, यह फ़ंक्शन random()

एक अपरिवर्तनीय अनुक्रम को फेरबदल करने के लिए और एक नई फेरबदल सूची को वापस करने के बजाय, sample(x, k=len(x)) उपयोग करें।

ध्यान दें कि यहां तक ​​कि छोटे len(x) , len(x) के क्रमपरिवर्तन की कुल संख्या सबसे यादृच्छिक रैंडम जनरेटर की अवधि की तुलना में बड़ी हो सकती है। इसका तात्पर्य है कि एक लंबे अनुक्रम के अधिकांश क्रमपरिवर्तन कभी उत्पन्न नहीं हो सकते। उदाहरण के लिए, लंबाई 2080 का एक क्रम सबसे बड़ा है जो मेर्सन ट्विस्टर यादृच्छिक संख्या जनरेटर की अवधि के भीतर फिट हो सकता है।

random.sample(population, k)

जनसंख्या अनुक्रम या सेट से चुने गए अद्वितीय तत्वों की k लंबाई सूची लौटाएं। प्रतिस्थापन के बिना यादृच्छिक नमूने के लिए उपयोग किया जाता है।

मूल आबादी को अपरिवर्तित छोड़ते हुए जनसंख्या से तत्वों से युक्त एक नई सूची लौटाता है। परिणामी सूची चयन क्रम में है ताकि सभी उप-स्लाइस भी वैध यादृच्छिक नमूने होंगे। यह रैफ़ल विजेताओं (नमूने) को भव्य पुरस्कार और दूसरे स्थान के विजेताओं (उप-वर्गों) में विभाजित करने की अनुमति देता है।

आबादी के सदस्यों को hashable या अद्वितीय नहीं होना चाहिए। यदि जनसंख्या में दोहराव होता है, तो प्रत्येक घटना नमूने में एक संभावित चयन है।

पूर्णांक की एक श्रेणी से एक नमूना चुनने के लिए, एक तर्क के रूप में एक range() ऑब्जेक्ट का उपयोग करें। यह एक बड़ी आबादी से नमूना लेने के लिए विशेष रूप से तेज और अंतरिक्ष कुशल है: sample(range(10000000), k=60)

यदि नमूना आकार जनसंख्या आकार से बड़ा है, तो एक ValueError उठाया जाता है।

वास्तविक मूल्य वितरण

निम्न कार्य विशिष्ट वास्तविक-मूल्यवान वितरण उत्पन्न करते हैं। फंक्शन मापदंडों को वितरण के समीकरण में संबंधित चर के नाम पर रखा गया है, जैसा कि सामान्य गणितीय अभ्यास में उपयोग किया जाता है; इनमें से अधिकांश समीकरण किसी भी सांख्यिकी पाठ में पाए जा सकते हैं।

random.random()

रेंज में अगला रैंडम फ्लोटिंग पॉइंट नंबर [0.0, 1.0) पर लौटें।

random.uniform(a, b)

रैंडम फ्लोटिंग पॉइंट नंबर N को ऐसे लौटाएँ कि a <= N <= b लिए a <= b और b <= N <= a लिए।

अंतिम बिंदु मान b , समीकरण a + (ba) * random() में फ्लोटिंग-पॉइंट राउंडिंग के आधार पर सीमा में शामिल हो भी सकता है और नहीं भी।

random.triangular(low, high, mode)

एक यादृच्छिक फ़्लोटिंग पॉइंट नंबर N को ऐसे लौटाएं कि low <= N <= high और उन सीमाओं के बीच निर्दिष्ट मोड के साथ। निम्न और उच्च सीमा शून्य और एक के लिए डिफ़ॉल्ट होती है। मोड तर्क सीमा के बीच के मध्य बिंदु तक पहुंचता है, एक सममित वितरण देता है।

random.betavariate(alpha, beta)

बीटा वितरण। मापदंडों पर स्थितियां alpha > 0 और beta > 0 । लौटाया गया मान 0 और 1 के बीच होता है।

random.expovariate(lambd)

घातांकी रूप से वितरण। लैंबड 1.0 वांछित भाग से विभाजित है। यह नॉनवेज होना चाहिए। (पैरामीटर को "लैम्ब्डा" कहा जाएगा, लेकिन वह पायथन में एक आरक्षित शब्द है।) लौटा मान 0 से सकारात्मक अनंत तक होता है यदि लैम्बड सकारात्मक है, और नकारात्मक इन्फिनिटी से 0 तक अगर लैम्बड नकारात्मक है।

random.gammavariate(alpha, beta)

गामा वितरण। (गामा फ़ंक्शन नहीं!) मापदंडों पर स्थितियां alpha > 0 और beta > 0

संभाव्यता वितरण समारोह है:

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
random.gauss(mu, sigma)

गौसियन वितरण। म्यू मतलब है, और सिग्मा मानक विचलन है। यह नीचे दिए गए normalvariate() फ़ंक्शन की तुलना में थोड़ा तेज है।

random.lognormvariate(mu, sigma)

सामान्य वितरण लॉग करें। यदि आप इस वितरण का प्राकृतिक लघुगणक लेते हैं, तो आपको मा और मानक विचलन सिग्मा के साथ एक सामान्य वितरण मिलेगा। म्यू का कोई भी मूल्य हो सकता है, और सिग्मा शून्य से अधिक होना चाहिए।

random.normalvariate(mu, sigma)

सामान्य वितरण। म्यू मतलब है, और सिग्मा मानक विचलन है।

random.vonmisesvariate(mu, kappa)

एमयू औसत कोण है, जिसे 0 और 2 * पीआई के बीच रेडियन में व्यक्त किया गया है, और कप्पा एकाग्रता पैरामीटर है, जो शून्य से अधिक या उसके बराबर होना चाहिए। यदि कप्पा शून्य के बराबर है, तो यह वितरण 0 से 2 * pi तक एक समान यादृच्छिक कोण पर कम हो जाता है।

random.paretovariate(alpha)

परेटो वितरण। अल्फा आकार पैरामीटर है।

random.weibullvariate(alpha, beta)

वीबुल वितरण। अल्फा स्केल पैरामीटर है और बीटा शेप पैरामीटर है।

वैकल्पिक जनरेटर

class random.SystemRandom([seed])

ऑपरेटिंग सिस्टम द्वारा प्रदान किए गए स्रोतों से यादृच्छिक संख्या पैदा करने के लिए क्लास जो os.urandom() फ़ंक्शन का उपयोग करता है। सभी प्रणालियों पर उपलब्ध नहीं है। सॉफ़्टवेयर स्थिति पर निर्भर नहीं करता है, और अनुक्रम प्रतिलिपि प्रस्तुत करने योग्य नहीं हैं। तदनुसार, seed() विधि का कोई प्रभाव नहीं है और इसे अनदेखा किया जाता है। getstate() और setstate() विधियाँ NotImplementedError यदि कहा जाता है।

Reproducibility पर नोट्स

कभी-कभी यह छद्म यादृच्छिक संख्या जनरेटर द्वारा दिए गए अनुक्रमों को पुन: पेश करने में सक्षम होने के लिए उपयोगी है। एक बीज मूल्य का पुन: उपयोग करके, एक ही अनुक्रम को रन से चलाने के लिए प्रतिलिपि प्रस्तुत करने योग्य होना चाहिए जब तक कि कई धागे नहीं चल रहे हों।

रैंडम मॉड्यूल के अधिकांश एल्गोरिदम और सीडिंग कार्य पायथन संस्करणों में परिवर्तन के अधीन हैं, लेकिन दो पहलुओं को नहीं बदलने की गारंटी है:

  • यदि एक नया बीजारोपण विधि जोड़ा जाता है, तो एक पिछड़े संगत बीजक की पेशकश की जाएगी।
  • जनरेटर के random() विधि उसी क्रम का उत्पादन करना जारी रखेगी जब संगत सीडर को एक ही बीज दिया जाता है।

उदाहरण और व्यंजनों

मूल उदाहरण:

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x < 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

सिमुलेशन:

>>> # Six roulette wheel spins (weighted sampling with replacement)
>>> choices(['red', 'black', 'green'], [18, 18, 2], k=6)
['red', 'green', 'black', 'black', 'red', 'black']

>>> # Deal 20 cards without replacement from a deck of 52 playing cards
>>> # and determine the proportion of cards with a ten-value
>>> # (a ten, jack, queen, or king).
>>> deck = collections.Counter(tens=16, low_cards=36)
>>> seen = sample(list(deck.elements()), k=20)
>>> seen.count('tens') / 20
0.15

>>> # Estimate the probability of getting 5 or more heads from 7 spins
>>> # of a biased coin that settles on heads 60% of the time.
>>> trial = lambda: choices('HT', cum_weights=(0.60, 1.00), k=7).count('H') >= 5
>>> sum(trial() for i in range(10000)) / 10000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> trial = lambda : 2500 <= sorted(choices(range(10000), k=5))[2]  < 7500
>>> sum(trial() for i in range(10000)) / 10000
0.7958

पांच के आकार के नमूने के लिए एक विश्वास अंतराल का अनुमान लगाने के लिए प्रतिस्थापन के साथ resampling का उपयोग कर सांख्यिकीय बूटस्ट्रैपिंग का उदाहरण:

# http://statistics.about.com/od/Applications/a/Example-Of-Bootstrapping.htm
from statistics import mean
from random import choices

data = 1, 2, 4, 4, 10
means = sorted(mean(choices(data, k=5)) for i in range(20))
print(f'The sample mean of {mean(data):.1f} has a 90% confidence '
      f'interval from {means[1]:.1f} to {means[-2]:.1f}')

एक दवा बनाम एक प्लेसबो के प्रभाव के बीच सांख्यिकीय अंतर के सांख्यिकीय महत्व या p-value का निर्धारण करने के लिए एक पुन: नमूनाकरण क्रमांकन परीक्षण का उदाहरण:

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)

n = 10000
count = 0
combined = drug + placebo
for i in range(n):
    shuffle(combined)
    new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
    count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')

एक ही सर्वर कतार में आगमन के समय और सेवा प्रदान करने का अनुकरण:

from random import expovariate, gauss
from statistics import mean, median, stdev

average_arrival_interval = 5.6
average_service_time = 5.0
stdev_service_time = 0.5

num_waiting = 0
arrivals = []
starts = []
arrival = service_end = 0.0
for i in range(20000):
    if arrival <= service_end:
        num_waiting += 1
        arrival += expovariate(1.0 / average_arrival_interval)
        arrivals.append(arrival)
    else:
        num_waiting -= 1
        service_start = service_end if num_waiting else arrival
        service_time = gauss(average_service_time, stdev_service_time)
        service_end = service_start + service_time
        starts.append(service_start)

waits = [start - arrival for arrival, start in zip(arrivals, starts)]
print(f'Mean wait: {mean(waits):.1f}.  Stdev wait: {stdev(waits):.1f}.')
print(f'Median wait: {median(waits):.1f}.  Max wait: {max(waits):.1f}.')

यह भी देखें

हैकर्स के लिए सांख्यिकी, जेक वेंडरप्लस द्वारा सांख्यिकीय विश्लेषण पर एक वीडियो ट्यूटोरियल, जिसमें सिमुलेशन, नमूनाकरण, फेरबदल, और क्रॉस-मान्यता सहित कुछ मौलिक अवधारणाओं का उपयोग किया गया है।

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

संभावना का एक ठोस परिचय (पायथन का उपयोग करते हुए) पीटर नॉर्विग द्वारा एक ट्यूटोरियल, संभाव्यता सिद्धांत की मूल बातें को कवर करते हुए, सिमुलेशन कैसे लिखें, और पायथन का उपयोग करके डेटा विश्लेषण कैसे करें।