0 और 9 के बीच यादृच्छिक पूर्णांक बनाएं

Question

मैं पायथन में 0 और 9 (समावेशी) के बीच यादृच्छिक पूर्णांक कैसे उत्पन्न कर सकता हूं?

उदाहरण के लिए, 0, 1, 2, 3, 4, 5, 6, 7, 8,9

Comments

0-9 की "बेतरतीब" पीढ़ी पर अच्छा स्टाइल अंक

— कॉलिनमैक

Answer 1

प्रयत्न:

from random import randrange
print(randrange(10))

अधिक जानकारी: http://docs.python.org/library/random.html#random.randrange

Comments

बस एक नोट, ये छद्म आयामी संख्याएं हैं और वे क्रिप्टोग्राफिक रूप से सुरक्षित नहीं हैं। किसी भी मामले में इसका उपयोग न करें जहां आप एक हमलावर को अपनी संख्या का अनुमान नहीं लगाना चाहते हैं। secretsबेहतर यादृच्छिक संख्याओं के लिए मॉड्यूल का उपयोग करें । संदर्भ: docs.python.org/3/library/random.html

Answer 2

import random
print(random.randint(0,9))

---

random.randint(a, b)

एक यादृच्छिक पूर्णांक N को लौटाएं जैसे कि <= N <= b।

डॉक्स: https://docs.python.org/3.1/library/random.html#random.randint

Comments

नए पायथन संस्करणों में, ऊपरी बाउंड अनन्य प्रतीत होता है (यानी randint(0,9)9 कभी नहीं लौटेगा)। यह ऑनलाइन प्रलेखन में परिलक्षित नहीं होता है, लेकिन यह अंतर्निहित मदद में है।

— Yly

Answer 3

इसे इस्तेमाल करे:

from random import randrange, uniform

# randrange gives you an integral value
irand = randrange(0, 10)

# uniform gives you a floating-point value
frand = uniform(0, 10)

Answer 4

from random import randint

x = [randint(0, 9) for p in range(0, 10)]

यह 0 से 9 की रेंज में 10 छद्म आयामी पूर्णांक बनाता है।

Answer 5

secretsमॉड्यूल अजगर 3.6 में नई है। यह randomक्रिप्टोग्राफी या सुरक्षा उपयोग के लिए मॉड्यूल से बेहतर है ।

समावेशी श्रेणी में बेतरतीब ढंग से पूर्णांक प्रिंट करने के लिए 0-9:

from secrets import randbelow
print(randbelow(10))

विवरण के लिए, PEP 506 देखें ।

Comments

इससे उत्तर में सुधार होगा और इसे जोड़ा जाना चाहिए। यदि उपलब्ध हो तो अधिक सुरक्षा दिमाग वाले उत्तरों को हमेशा जोड़ा जाना चाहिए।

— सूडोकिड

Answer 6

सरणी का आकार चुनें (इस उदाहरण में, मैंने आकार 20 चुना है)। और फिर, निम्नलिखित का उपयोग करें:

import numpy as np   
np.random.randint(10, size=(1, 20))

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

array([[1, 6, 1, 2, 8, 6, 3, 3, 2, 5, 6, 5, 0, 9, 5, 6, 4, 5, 9, 3]])

Comments

यह जानना भी मददगार है कि कैसे Numpy केवल एक यादृच्छिक संख्या नहीं, बल्कि निर्दिष्ट आकार का एक यादृच्छिक सरणी उत्पन्न कर सकता है। (डॉक्स: numpy.random.randint )

— jkdev

Answer 7

इसके माध्यम से प्रयास करें random.shuffle

>>> import random
>>> nums = range(10)
>>> random.shuffle(nums)
>>> nums
[6, 3, 5, 4, 0, 1, 2, 9, 8, 7]

Comments

यह एक सही उत्तर नहीं है, और इसे हटा दिया जाना चाहिए।

— निकोलस

Answer 8

मैं निम्नलिखित में से एक कोशिश करूँगा:

1. 1. numpy.random.randint

import numpy as np
X1 = np.random.randint(low=0, high=10, size=(15,))

print (X1)
>>> array([3, 0, 9, 0, 5, 7, 6, 9, 6, 7, 9, 6, 6, 9, 8])

2. " numpy.random.uniform

import numpy as np
X2 = np.random.uniform(low=0, high=10, size=(15,)).astype(int)

print (X2)
>>> array([8, 3, 6, 9, 1, 0, 3, 6, 3, 3, 1, 2, 4, 0, 4])

3. 3. random.randrange

from random import randrange
X3 = [randrange(10) for i in range(15)]

print (X3)
>>> [2, 1, 4, 1, 2, 8, 8, 6, 4, 1, 0, 5, 8, 3, 5]

4. * यादृच्छिक

from random import randint
X4 = [randint(0, 9) for i in range(0, 15)]

print (X4)
>>> [6, 2, 6, 9, 5, 3, 2, 3, 3, 4, 4, 7, 4, 9, 6]

गति:

► np.random.randint है सबसे तेजी से , जिसके बाद np.random.uniform और random.randrange । random.randint है धीमी ।

► दोनों np.random.randint और np.random.uniform बहुत तेजी से कर रहे हैं (~ 8 - 12 बार तेज) random.randrange और random.randint से ।

%timeit np.random.randint(low=0, high=10, size=(15,))
>> 1.64 µs ± 7.83 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit np.random.uniform(low=0, high=10, size=(15,)).astype(int)
>> 2.15 µs ± 38.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit [randrange(10) for i in range(15)]
>> 12.9 µs ± 60.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit [randint(0, 9) for i in range(0, 15)]
>> 20 µs ± 386 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

टिप्पणियाँ:

1. [ np.random.randint आधे खुले अंतराल [कम, उच्च) पर यादृच्छिक पूर्णांक उत्पन्न करता है।

2. " np.random.uniform आधे-खुले अंतराल [कम, उच्च) पर समान रूप से वितरित संख्या उत्पन्न करती है।

3. " random.randrange (stop) रेंज (स्टार्ट, स्टॉप, स्टेप) से एक यादृच्छिक संख्या उत्पन्न करता है।

4. * random.randint (a, b) एक यादृच्छिक पूर्णांक N को लौटाता है जैसे कि एक <= N <= b।

5. " astype (int) इंटेलीजेंट डेटा टाइप करने के लिए numpy ऐरे को कास्ट करता है।

6.> मैंने आकार चुना है = (15,)। यह आपको लंबाई = 15 का एक सुव्यवस्थित सरणी देगा।

Answer 9

निरंतर संख्या के मामले में randintया randrangeशायद सबसे अच्छे विकल्प हैं, लेकिन यदि आपके पास अनुक्रम में कई अलग-अलग मूल्य हैं (यानी list) तो आप भी उपयोग कर सकते हैं choice:

>>> import random
>>> values = list(range(10))
>>> random.choice(values)
5

choice निरंतर नहीं होने वाले नमूने में से एक आइटम के लिए भी काम करता है:

>>> values = [1, 2, 3, 5, 7, 10]
>>> random.choice(values)
7

यदि आपको इसकी आवश्यकता है "क्रिप्टोग्राफिक रूप से मजबूत" तो वहाँ भी एक secrets.choiceहै अजगर 3.6 और नए:

>>> import secrets
>>> values = list(range(10))
>>> secrets.choice(values)
2

Comments

क्या होगा अगर हम अनुक्रम से अधिक संख्या चाहते हैं?

— गुंजन नाइक

अगर वे प्रतिस्थापन के बिना होना चाहिए random.sample:। प्रतिस्थापन के साथ आप एक समझ का उपयोग कर सकते हैं choice: उदाहरण के लिए प्रतिस्थापन के साथ 3 यादृच्छिक मूल्यों वाली सूची के लिए:[choice(values) for _ in range(3)]

— MSeifert

Answer 10

जबकि कई पोस्ट प्रदर्शित करते हैं कि एक यादृच्छिक पूर्णांक कैसे प्राप्त करें , मूल प्रश्न पूछता है कि यादृच्छिक पूर्णांक s (बहुवचन) कैसे उत्पन्न करें :

मैं पायथन में 0 और 9 (समावेशी) के बीच यादृच्छिक पूर्णांक कैसे उत्पन्न कर सकता हूं?

स्पष्टता के लिए, यहाँ हम प्रदर्शित करते हैं कि कैसे कई यादृच्छिक पूर्णांक प्राप्त करें।

दिया हुआ

>>> import random


lo = 0
hi = 10
size = 5

कोड

मल्टीपल, रैंडम इंटेगर

# A
>>> [lo + int(random.random() * (hi - lo)) for _ in range(size)]
[5, 6, 1, 3, 0]

# B
>>> [random.randint(lo, hi) for _ in range(size)]
[9, 7, 0, 7, 3]

# C
>>> [random.randrange(lo, hi) for _ in range(size)]
[8, 3, 6, 8, 7]

# D
>>> lst = list(range(lo, hi))
>>> random.shuffle(lst)
>>> [lst[i] for i in range(size)]
[6, 8, 2, 5, 1]

# E
>>> [random.choice(range(lo, hi)) for _ in range(size)]
[2, 1, 6, 9, 5]

रैंडम इंटेगर का नमूना

# F
>>> random.choices(range(lo, hi), k=size)
[3, 2, 0, 8, 2]

# G
>>> random.sample(range(lo, hi), k=size)
[4, 5, 1, 2, 3]

---

विवरण

कुछ पोस्ट प्रदर्शित करते हैं कि कैसे मूल रूप से कई यादृच्छिक पूर्णांक उत्पन्न होते हैं। ¹ यहाँ कुछ विकल्प दिए गए हैं जो निहित प्रश्न को संबोधित करते हैं:

• A : random.randomसीमा में एक यादृच्छिक फ्लोट देता है[0.0, 1.0)
• बी : इस तरह random.randintएक यादृच्छिक पूर्णांक Nदेता हैa <= N <= b
• सी : random.randrangeउर्फ कोrandint(a, b+1)
• डी : random.shuffleजगह में एक अनुक्रम फेरबदल
• ई : random.choiceगैर-खाली अनुक्रम से एक यादृच्छिक तत्व देता है
• एफ : एक आबादी से random.choicesरिटर्न का kचयन (प्रतिस्थापन के साथ, पायथन 3.6+)
• जी : एक आबादी (प्रतिस्थापन के बिना) से अद्वितीय चयन random.sampleलौटाता है k: ²

मॉड्यूल से उदाहरणों का उपयोग करके चंकिंग और अलियासिंग पर आर। हेटिंगर की बात भी देखें random।

यहाँ मानक पुस्तकालय और Numpy में कुछ यादृच्छिक कार्यों की तुलना है:

| | random                | numpy.random                     |
|-|-----------------------|----------------------------------|
|A| random()              | random()                         |
|B| randint(low, high)    | randint(low, high)               |
|C| randrange(low, high)  | randint(low, high)               |
|D| shuffle(seq)          | shuffle(seq)                     |
|E| choice(seq)           | choice(seq)                      |
|F| choices(seq, k)       | choice(seq, size)                |
|G| sample(seq, k)        | choice(seq, size, replace=False) |

आप Numpy में कई वितरणों में से एक को भी यादृच्छिक पूर्णांकों के नमूने में जल्दी से बदल सकते हैं। ³

उदाहरण

>>> np.random.normal(loc=5, scale=10, size=size).astype(int)
array([17, 10,  3,  1, 16])

>>> np.random.poisson(lam=1, size=size).astype(int)
array([1, 3, 0, 2, 0])

>>> np.random.lognormal(mean=0.0, sigma=1.0, size=size).astype(int)
array([1, 3, 1, 5, 1])

_{¹ नामी @ जॉन लॉरेंस एस्पेन, @ST मोहम्मद, @ सिद्दिकिड, @ user14372, @zangw, एट अल। ² @prhanhanth इस मॉड्यूल में एक पूर्णांक दिखा रहा है। ³ @ सिद्धार्थ सतपथी द्वारा प्रदर्शित}

Answer 11

यदि आप सुन्न का उपयोग करना चाहते हैं तो निम्नलिखित का उपयोग करें:

import numpy as np
print(np.random.randint(0,10))

Comments

आप "सुन्न" के बारे में कुछ बता सकते हैं।

— सिमोन

हाँ। लिंक के लिए धन्यवाद। लेकिन मेरा अभिप्राय यह था कि कोड की दो पंक्तियों को उद्धृत करने से पहले आप विवरण प्रदान करके अपने उत्तर को बेहतर बना सकते थे; किस कारण से कोई व्यक्ति पहले से निर्मित किसी वस्तु के बजाय इसका उपयोग करना पसंद करेगा। ऐसा नहीं है कि आप इसके लिए वैसे भी बाध्य हैं।

— सिमोन

Answer 12

>>> import random
>>> random.randrange(10)
3
>>> random.randrange(10)
1

दस नमूनों की सूची प्राप्त करने के लिए:

>>> [random.randrange(10) for x in range(10)]
[9, 0, 4, 0, 5, 7, 4, 3, 6, 8]

Answer 13

0 और 9 के बीच यादृच्छिक पूर्णांक बनाना।

import numpy
X = numpy.random.randint(0, 10, size=10)
print(X)

आउटपुट:

[4 8 0 4 9 6 9 9 0 7]

Answer 14

random.sample एक और है जिसका उपयोग किया जा सकता है

import random
n = 1 # specify the no. of numbers
num = random.sample(range(10),  n)
num[0] # is the required number

Answer 15

सबसे अच्छा तरीका आयात यादृच्छिक समारोह का उपयोग करना है

import random
print(random.sample(range(10), 10))

या बिना किसी पुस्तकालय आयात के:

n={} 
for i in range(10):
    n[i]=i

for p in range(10):
    print(n.popitem()[1])

यहाँ शब्दकोष से डिबेट हटाता है और एक मनमाना मूल्य देता है n।

Answer 16

यह गणितीय दृष्टिकोण से अधिक है लेकिन यह समय के 100% काम करता है:

मान लें कि आप random.random()किसी संख्या को बीच aऔर उत्पन्न करने के लिए फ़ंक्शन का उपयोग करना चाहते हैं b। इसे प्राप्त करने के लिए, बस निम्नलिखित करें:

num = (b-a)*random.random() + a;

बेशक, आप अधिक संख्या उत्पन्न कर सकते हैं।

Answer 17

यादृच्छिक मॉड्यूल के लिए प्रलेखन पृष्ठ से :

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

random.SystemRandom , जिसे पायथन 2.4 में पेश किया गया था, को क्रिप्टोग्राफिक रूप से सुरक्षित माना जाता है । यह अभी भी पायथन 3.7.1 में उपलब्ध है जो लेखन के समय चालू है।

>>> import string
>>> string.digits
'0123456789'
>>> import random
>>> random.SystemRandom().choice(string.digits)
'8'
>>> random.SystemRandom().choice(string.digits)
'1'
>>> random.SystemRandom().choice(string.digits)
'8'
>>> random.SystemRandom().choice(string.digits)
'5'

इसके बजाय string.digits, rangeशायद एक समझ के साथ-साथ अन्य कुछ उत्तर प्रति इस्तेमाल किया जा सकता। अपनी जरूरत के अनुसार मिक्स एंड मैच करें।

Answer 18

OpenTURNS न केवल यादृच्छिक पूर्णांकों को अनुकरण करने की अनुमति देता है, बल्कि संबंधित वितरण को UserDefinedपरिभाषित वर्ग के साथ परिभाषित करने की भी अनुमति देता है ।

निम्नलिखित वितरण के 12 परिणामों का अनुकरण करता है।

import openturns as ot
points = [[i] for i in range(10)]
distribution = ot.UserDefined(points) # By default, with equal weights.
for i in range(12):
    x = distribution.getRealization()
    print(i,x)

यह प्रिंट:

0 [8]
1 [7]
2 [4]
3 [7]
4 [3]
5 [3]
6 [2]
7 [9]
8 [0]
9 [5]
10 [9]
11 [6]

कोष्ठक देखते हैं क्योंकि xएक है Point1-आयाम में। एक कॉल में 12 परिणामों को उत्पन्न करना आसान होगा getSample:

sample = distribution.getSample(12)

उत्पादन होगा:

>>> print(sample)
     [ v0 ]
 0 : [ 3  ]
 1 : [ 9  ]
 2 : [ 6  ]
 3 : [ 3  ]
 4 : [ 2  ]
 5 : [ 6  ]
 6 : [ 9  ]
 7 : [ 5  ]
 8 : [ 9  ]
 9 : [ 5  ]
10 : [ 3  ]
11 : [ 2  ]

इस विषय पर अधिक जानकारी यहाँ हैं: http://openturns.github.io/openturns/master/user_manual/_generated/openturns.UserDefined.html

Answer 19

पाइथन 3.6 के लिए मेरे पास इससे बेहतर किस्मत थी

str_Key = ""                                                                                                
str_RandomKey = ""                                                                                          
for int_I in range(128):                                                                                    
      str_Key = random.choice('0123456789')
      str_RandomKey = str_RandomKey + str_Key 

चरित्र पूल में परिवर्तन करने के लिए 'ABCD' और 'abcd' या '^! ~!