0 සහ 9 අතර අහඹු පූර්ණ සංඛ්‍යා උත්පාදනය කරන්න

1366

පයිතන් හි 0 සහ 9 (ඇතුළුව) අතර අහඹු පූර්ණ සංඛ්‍යාවක් ජනනය කරන්නේ කෙසේද?

උදාහරණයක් ලෙස, 0, 1, 2, 3, 4, 5, 6, 7, 8,9

python random integer

— aneuryzm
source

22

0-9 හි "අහඹු" පරම්පරාව පිළිබඳ හොඳ ශෛලීය කරුණු

— කොලින්මාක්

2077

උත්සාහ කරන්න:

from random import randrange
print(randrange(10))

ලියකියවිලි: https://docs.python.org/3/library/random.html#random.randrange

— කොව්ෂෙනින්
source

83

සටහනක් පමණක්, මේවා ව්‍යාජ සංඛ්‍යා වන අතර ඒවා ගුප්ත විද්‍යාත්මකව ආරක්ෂිත නොවේ. ඔබේ අංක අනුමාන කිරීමට ප්‍රහාරකයාට අවශ්‍ය නැති ඕනෑම අවස්ථාවක මෙය භාවිතා නොකරන්න. secretsවඩා හොඳ අහඹු සංඛ්‍යා සඳහා මොඩියුලය භාවිතා කරන්න . යොමුව: docs.python.org/3/library/random.html

491

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

random.randint(a, b)

<= N <= b වැනි අහඹු නිඛිල සංඛ්‍යාවක් ආපසු එවන්න.

ලියකියවිලි: https://docs.python.org/3.1/library/random.html#random.randint

— ජේ.එම්.සමුඩියෝ
source

3.8 සඳහා තවමත් "අහඹු පූර්ණ සංඛ්‍යාවක් එන් ආපසු එවන්න a <= N <= b. අන්වර්ථය randrange(a, b+1)" සඳහා @Yly

— Denis

136

මේක උත්සාහ කරන්න:

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)

— ඇන්ඩ rew හාරේ
source

83

from random import randint

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

මෙය 0 සිට 9 දක්වා පරාසයක ව්‍යාජ සංඛ්‍යා 10 ක් ජනනය කරයි.

— පරිශීලක 14372
source

65

මෙම secretsමොඩියුලය Python 3.6 නව වේ. randomගුප්ත ලේඛනකරණය හෝ ආරක්ෂක භාවිතය සඳහා වන මොඩියුලයට වඩා මෙය හොඳය .

ඇතුළත් කළ පරාසය තුළ පූර්ණ සංඛ්‍යාවක් අහඹු ලෙස මුද්‍රණය කිරීම සඳහා: 0-9:

from secrets import randbelow
print(randbelow(10))

වැඩි විස්තර සඳහා PEP 506 බලන්න .

— ක්‍රිස්_රෑන්ඩ්ස්
source

3

මෙය පිළිතුර වැඩිදියුණු කරන අතර එකතු කළ යුතුය. ලබා ගත හැකි නම් වඩා ආරක්‍ෂිත මනසක් ඇති පිළිතුරු සෑම විටම එකතු කළ යුතුය.

— සුදොකිඩ්

31

අරාවේ ප්‍රමාණය තෝරන්න (මෙම උදාහරණයේ දී, මම ප්‍රමාණය 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]])

— පොදු
source

3

එක් අහඹු අංකයක් පමණක් නොව නිශ්චිත ප්‍රමාණයේ අහඹු ශ්‍රේණියක් Numpy හට ජනනය කරන්නේ කෙසේදැයි දැන ගැනීමද ප්‍රයෝජනවත් වේ. (Docs: numpy.random.randint )

— jkdev

28

මෙය හරහා උත්සාහ කරන්න random.shuffle

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

— zangw
source

මෙය නිවැරදි පිළිතුරක් නොවන අතර මකා දැමිය යුතුය.

— නිකොලස් ගර්වේස්

23

මම පහත සඳහන් දේවලින් එකක් උත්සාහ කරමි:

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.> 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.> random.randint

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 වඩා වේගවත් වේ (- 12 ගුණයක් වේගවත් ~ 8) 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 (නවත්වන්න) පරාසය වෙතින් අහඹු අංකයක් ජනනය කරයි (ආරම්භය, නැවැත්වීම, පියවර).

4.> random.randint (a, b) <= N <= b වැනි අහඹු පූර්ණ සංඛ්‍යාවක් N ලබා දෙයි.

5.> ඇස්ටයිප් (int) සංඛ්‍යාත්මක අරාව int දත්ත වර්ගයට ඇතුළත් කරයි.

6.> මම ප්‍රමාණය = (15,) තෝරාගෙන ඇත. මෙය ඔබට දිගින් දිගට = 15 ලබා දෙනු ඇත.

— සිද්ධාර්ත් සත්පති
source

19

බොහෝ තනතුරු ලබා ගැනීමට ආකාරය නිරූපණය වන අතර එක් අහඹු පූර්ණ සංඛ්යාමය, මුල් ප්රශ්නය අහඹු පූර්ණ සංඛ්යාමය ජනනය කරන්නේ කෙසේ අසයි ගේ (බහු වචන):

පයිතන් හි 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]

විස්තර

සමහර තනතුරු natively උත්පාදනය කිරීමට කෙසේද යන්න පැහැදිලි බහු අහඹු නිඛිල. ¹ ගම්‍ය වන ප්‍රශ්නය ආමන්ත්‍රණය කරන විකල්ප කිහිපයක් මෙන්න:

A : random.randomපරාසය තුළ අහඹු පාවීමක් ලබා දෙයි[0.0, 1.0)
B : random.randintඅහඹු සංඛ්‍යාවක් පූර්ණ ලෙස ලබා Nදෙයිa <= N <= b
ඇ : random.randrangeඅන්වර්ථයrandint(a, b+1)
D : random.shuffleඅනුපිළිවෙලක් තැනින් තැන මාරු කරයි
ඊ : random.choiceහිස් නොවන අනුක්‍රමයෙන් අහඹු මූලද්‍රව්‍යයක් ලබා දෙයි
එෆ් : random.choicesප්රතිලාභ kජනගහනය (ප්රතිස්ථාපනය, Python 3.6+ සමග) සිට තෝරා
ජී : random.sampleප්රතිලාභ kජනගහනය සිට අද්විතීය ෙදකක් (ආදේශන රහිත): ²

ආර් Hettinger ගේ ද බලන්න සාකච්ඡාව සිට උදාහරණ භාවිතා Chunking සහ අනුවර්ත නාමකරණයට මතrandom මොඩියුලය.

සම්මත පුස්තකාලයේ සහ නැම්පි හි අහඹු කාර්යයන් කිහිපයක් සංසන්දනය කිරීම මෙන්න:

| | 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 මොහොමඩ්, idd සිද් දකිඩ්, @ user14372, @ සැන්ග්ව් සහ වෙනත් අය.} _{² @ ප්‍රශාන්ත් මෙම මොඩියුලය එක් පූර්ණ සංඛ්‍යාවක් පෙන්වන බව සඳහන් කරයි.} _{³ සිද්ධාර්ත් සත්පති විසින් නිරූපණය කරන ලදී}

— pylang
source

18

අඛණ්ඩ සංඛ්‍යා සම්බන්ධයෙන් නම් 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

— MSeifert
source

අනුක්‍රමයෙන් අපට තවත් සංඛ්‍යා අවශ්‍ය නම් කුමක් කළ යුතුද?

— ගුන්ජන් නයික්

ඒවා ප්‍රතිස්ථාපනයකින් තොරව විය යුතු නම් : random.sample. ප්‍රතිස්ථාපනය සමඟ ඔබට තේරුම් ගැනීමක් භාවිතා කළ හැකිය choice: නිදසුනක් ලෙස අහඹු අගයන් 3 ක් සහිත ලැයිස්තුවක් ආදේශ කිරීම සමඟ:[choice(values) for _ in range(3)]

— MSeifert

14

ඔබට අංක භාවිතා කිරීමට අවශ්‍ය නම් පහත සඳහන් දෑ භාවිතා කරන්න:

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

— සුෂ්මිත්
source

1

ඔබට "අංකී" ගැන යමක් පැවසිය හැකිය.

— සිමන්

11

ඔව්. සබැඳියට ස්තූතියි. නමුත් මම අදහස් කළේ කේත පේළි දෙකක් උපුටා දැක්වීමට පෙර විස්තර ලබා දීමෙන් ඔබේ පිළිතුර වැඩිදියුණු කළ හැකි බවයි; දැනටමත් ගොඩනගා ඇති දෙයක් වෙනුවට යමෙකු එය භාවිතා කිරීමට කැමති කුමන හේතුවක් නිසාද යන්න. කෙසේ වෙතත් ඔබ බැඳී සිටින බව නොවේ.

— සිමන්

9

>>> 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]

— ජෝන් ලෝරන්ස් ඇස්ප්ඩන්
source

7

0 සහ 9 අතර අහඹු පූර්ණ සංඛ්‍යා උත්පාදනය කිරීම.

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

ප්‍රතිදානය:

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

— අශෝක් කුමාර් ජයරාමන්
source

6

random.sample භාවිතා කළ හැකි තවත් එකකි

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

— ප්‍රශාන්ත්
source

6

හොඳම ක්‍රමය වන්නේ ආනයන සසම්භාවී ශ්‍රිතය භාවිතා කිරීමයි

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.

— එස්.ටී. මොහොමඩ්
source

3

මෙය ගණිතමය ප්‍රවේශයකට වඩා වැඩි නමුත් එය 100% කාලය ක්‍රියාත්මක වේ:

සහ random.random()අතර සංඛ්‍යාවක් ජනනය කිරීම සඳහා ඔබට ශ්‍රිතය භාවිතා කිරීමට අවශ්‍ය යැයි කියමු . මෙය සාක්ෂාත් කර ගැනීම සඳහා පහත සඳහන් දේ කරන්න:ab

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

ඇත්ත වශයෙන්ම, ඔබට තවත් සංඛ්යා ජනනය කළ හැකිය.

— ඔරෙස්ටිස් සෙකායි
source

2

අහඹු මොඩියුලය සඳහා ප්‍රලේඛන පිටුවෙන් :

අවවාදයයි: මෙම මොඩියුලයේ ව්‍යාජ සසම්භාවී උත්පාදක යන්ත්ර ආරක්ෂක අරමුණු සඳහා භාවිතා නොකළ යුතුය. ඔබට ගුප්ත විද්‍යාත්මකව ආරක්ෂිත ව්‍යාජ සසම්භාවී සංඛ්‍යා උත්පාදකයක් අවශ්‍ය නම් os.urandom () හෝ 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වෙනත් සමහර පිළිතුරු සඳහා තේරුම් ගැනීමක් සමඟ භාවිතා කළ හැකිය. ඔබේ අවශ්‍යතා අනුව මිශ්‍ර කර ගලපන්න.

— රයිහෙල්
source

0

OpenTURNS මඟින් සසම්භාවී පූර්ණ සංඛ්‍යා අනුකරණය කිරීමට පමණක් නොව, ඒ සමඟ සම්බන්ධිත ව්‍යාප්තිය අර්ථ දැක්වීමට ද ඉඩ දෙයි UserDefined ලද පන්තිය .

පහත දැක්වෙන්නේ බෙදාහැරීමේ ප්‍රති come ල 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 මානයකින් වන බැවිනි. ප්‍රති call ල 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

— මයිකල් බෝඩින්
source

-1

පයිතන් 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' හෝ '^! ~ = -> <' වැනි අක්ෂර එක් කරන්න, ජනනය කරන ලද අක්ෂර ගණන වෙනස් කිරීමට පරාසය වෙනස් කරන්න.

— එම්ටී හෙඩ්
source