Hướng dẫn random number generator from scratch python - trình tạo số ngẫu nhiên từ python đầu

Chức năng kế toán

Khởi tạo trình tạo số ngẫu nhiên.

Nếu A bị bỏ qua hoặc

random.randint[a,b]

random.randint[a,b]

Nếu A là INT, nó được sử dụng trực tiếp.

Với phiên bản 2 [mặc định], đối tượng

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

Với phiên bản 1 [được cung cấp để tái tạo các chuỗi ngẫu nhiên từ các phiên bản Python cũ hơn], thuật toán cho

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

Đã thay đổi trong phiên bản 3.2: Đã chuyển sang sơ đồ phiên bản 2 sử dụng tất cả các bit trong hạt giống.Moved to the version 2 scheme which uses all of the bits in a string seed.

Đã thay đổi trong phiên bản 3.11: Hạt giống phải là một trong các loại sau: Nonetype,

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

Trả về một đối tượng chụp trạng thái bên trong hiện tại của trình tạo. Đối tượng này có thể được chuyển sang

random.randint[a,b]

Nhà nước đáng lẽ phải được lấy từ một cuộc gọi trước đó đến

random.randint[a,b]

random.randint[a,b]

random.randint[a,b]

Chức năng cho byte¶

Tạo n ngẫu nhiên byte.

Phương pháp này không nên được sử dụng để tạo mã thông báo bảo mật. Sử dụng

>>> random[]                             # Random float:  0.0 >> uniform[2.5, 10.0]                   # Random float:  2.5 > 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]

Mới trong phiên bản 3.9.

Chức năng cho số nguyên

Trả về một phần tử được chọn ngẫu nhiên từ

>>> random[]                             # Random float:  0.0 >> uniform[2.5, 10.0]                   # Random float:  2.5 > 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]

>>> random[]                             # Random float:  0.0 >> uniform[2.5, 10.0]                   # Random float:  2.5 > 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]

Các mẫu đối số vị trí phù hợp với

>>> random[]                             # Random float:  0.0 >> uniform[2.5, 10.0]                   # Random float:  2.5 > 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]

Đã thay đổi trong phiên bản 3.2:

random.randint[a,b]

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

random.randint[a,b]

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

Không dùng nữa kể từ phiên bản 3.10: Chuyển đổi tự động các loại không nguyên thành các số nguyên tương đương được không dùng nữa. Hiện tại

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

Không dùng nữa kể từ phiên bản 3.10: Ngoại lệ được nâng lên đối với các giá trị không tích hợp như

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

Trả về một số nguyên ngẫu nhiên n sao cho

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

# //www.thoughtco.com/example-of-bootstrapping-3126155
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted[mean[choices[data, k=len[data]]] for i in range[100]]
print[f'The sample mean of {mean[data]:.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}']

Trả về một số nguyên python không âm với K BIT ngẫu nhiên. Phương pháp này được cung cấp với Trình tạo Mersennetwister và một số trình tạo khác cũng có thể cung cấp nó như một phần tùy chọn của API. Khi có sẵn,

random.randint[a,b]

random.randint[a,b]

Đã thay đổi trong phiên bản 3.9: Phương pháp này hiện không chấp nhận số 0 cho k.This method now accepts zero for k.

Chức năng cho trình tự lor

Trả về một phần tử ngẫu nhiên từ chuỗi không trống seq. Nếu SEQ trống, tăng

# //www.thoughtco.com/example-of-bootstrapping-3126155
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted[mean[choices[data, k=len[data]]] for i in range[100]]
print[f'The sample mean of {mean[data]:.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}']

Trả lại một danh sách kích thước k các yếu tố được chọn từ dân số với sự thay thế. Nếu dân số trống, tăng

# //www.thoughtco.com/example-of-bootstrapping-3126155
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted[mean[choices[data, k=len[data]]] for i in range[100]]
print[f'The sample mean of {mean[data]:.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}']

Nếu một chuỗi trọng số được chỉ định, các lựa chọn được thực hiện theo các trọng số tương đối. Ngoài ra, nếu một chuỗi cum_weights được đưa ra, các lựa chọn được thực hiện theo các trọng số tích lũy [có thể được tính toán bằng

# //www.thoughtco.com/example-of-bootstrapping-3126155
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted[mean[choices[data, k=len[data]]] for i in range[100]]
print[f'The sample mean of {mean[data]:.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}']

# //www.thoughtco.com/example-of-bootstrapping-3126155
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted[mean[choices[data, k=len[data]]] for i in range[100]]
print[f'The sample mean of {mean[data]:.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}']

# //www.thoughtco.com/example-of-bootstrapping-3126155
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted[mean[choices[data, k=len[data]]] for i in range[100]]
print[f'The sample mean of {mean[data]:.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}']

Nếu không có trọng số và không được chỉ định, các lựa chọn được thực hiện với xác suất bằng nhau. Nếu một chuỗi trọng số được cung cấp, nó phải có cùng chiều dài với trình tự dân số. Đó là một

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

Trọng lượng hoặc cum_ weights có thể sử dụng bất kỳ loại số nào tương tác với các giá trị

          x ** [alpha - 1] * math.exp[-x / beta]
pdf[x] =  --------------------------------------
            math.gamma[alpha] * beta ** alpha

5

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

Đối với một hạt giống nhất định, hàm

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as 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 = 10_000
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.']

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as 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 = 10_000
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.']

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as 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 = 10_000
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.']

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as 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 = 10_000
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.']

Mới trong phiên bản 3.6.

Đã thay đổi trong phiên bản 3.9: tăng

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

Xáo trộn chuỗi x tại chỗ.

Để xáo trộn một chuỗi bất biến và trả lại một danh sách xáo trộn mới, hãy sử dụng

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as 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 = 10_000
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.']

Lưu ý rằng ngay cả đối với

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as 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 = 10_000
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.']

Không dùng nữa kể từ phiên bản 3.9, bị xóa trong phiên bản 3.11: Tham số tùy chọn ngẫu nhiên.The optional parameter random.

Trả về một danh sách chiều dài k của các yếu tố duy nhất được chọn từ chuỗi dân số. Được sử dụng để lấy mẫu ngẫu nhiên mà không cần thay thế.

Trả về một danh sách mới chứa các yếu tố từ dân số trong khi để lại dân số ban đầu không thay đổi. Danh sách kết quả theo thứ tự lựa chọn để tất cả các lớp phụ cũng sẽ là các mẫu ngẫu nhiên hợp lệ. Điều này cho phép người chiến thắng xổ số [mẫu] được phân chia thành giải thưởng lớn và người chiến thắng vị trí thứ hai [các phụ].

Các thành viên của dân số không cần phải có thể băm hoặc duy nhất. Nếu dân số chứa lặp lại, thì mỗi lần xuất hiện là một lựa chọn có thể trong mẫu.hashable or unique. If the population contains repeats, then each occurrence is a possible selection in the sample.

Các phần tử lặp lại có thể được chỉ định một lần hoặc với tham số số lượng từ khóa chỉ tùy chọn. Ví dụ,

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as 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 = 10_000
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 heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify[servers]
for i in range[1_000_000]:
    arrival_time += expovariate[1.0 / average_arrival_interval]
    next_server_available = servers[0]
    wait = max[0.0, next_server_available - arrival_time]
    waits.append[wait]
    service_duration = max[0.0, gauss[average_service_time, stdev_service_time]]
    service_completed = arrival_time + wait + service_duration
    heapreplace[servers, service_completed]

print[f'Mean wait: {mean[waits]:.1f}   Max wait: {max[waits]:.1f}']
print['Quartiles:', [round[q, 1] for q in quantiles[waits]]]

Để chọn một mẫu từ một loạt các số nguyên, hãy sử dụng đối tượng

>>> random[]                             # Random float:  0.0 >> uniform[2.5, 10.0]                   # Random float:  2.5 > 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]

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify[servers]
for i in range[1_000_000]:
    arrival_time += expovariate[1.0 / average_arrival_interval]
    next_server_available = servers[0]
    wait = max[0.0, next_server_available - arrival_time]
    waits.append[wait]
    service_duration = max[0.0, gauss[average_service_time, stdev_service_time]]
    service_completed = arrival_time + wait + service_duration
    heapreplace[servers, service_completed]

print[f'Mean wait: {mean[waits]:.1f}   Max wait: {max[waits]:.1f}']
print['Quartiles:', [round[q, 1] for q in quantiles[waits]]]

Nếu kích thước mẫu lớn hơn kích thước dân số, thì

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

Đã thay đổi trong phiên bản 3.9: Đã thêm tham số Counts.Added the counts parameter.

Thay đổi trong phiên bản 3.11: Dân số phải là một chuỗi. Tự động chuyển đổi các bộ thành danh sách không còn được hỗ trợ.The population must be a sequence. Automatic conversion of sets to lists is no longer supported.

Phân phối có giá trị thực

Các chức năng sau đây tạo ra các phân phối có giá trị thực cụ thể. Các tham số chức năng được đặt tên theo các biến tương ứng trong phương trình phân phối, như được sử dụng trong thực tiễn toán học thông thường; Hầu hết các phương trình này có thể được tìm thấy trong bất kỳ văn bản thống kê.

Trả về số điểm nổi ngẫu nhiên tiếp theo trong phạm vi [0,0, 1.0].

Trả về số điểm nổi ngẫu nhiên n sao cho

>>> # 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:  ten, jack, queen, or king.
>>> dealt = sample[['tens', 'low cards'], counts=[16, 36], k=20]
>>> dealt.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.
>>> def trial[]:
...     return choices['HT', cum_weights=[0.60, 1.00], k=7].count['H'] >= 5
...
>>> sum[trial[] for i in range[10_000]] / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial[]:
...     return 2_500 > sum[trial[] for i in range[10_000]] / 10_000
0.7958

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify[servers]
for i in range[1_000_000]:
    arrival_time += expovariate[1.0 / average_arrival_interval]
    next_server_available = servers[0]
    wait = max[0.0, next_server_available - arrival_time]
    waits.append[wait]
    service_duration = max[0.0, gauss[average_service_time, stdev_service_time]]
    service_completed = arrival_time + wait + service_duration
    heapreplace[servers, service_completed]

print[f'Mean wait: {mean[waits]:.1f}   Max wait: {max[waits]:.1f}']
print['Quartiles:', [round[q, 1] for q in quantiles[waits]]]

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify[servers]
for i in range[1_000_000]:
    arrival_time += expovariate[1.0 / average_arrival_interval]
    next_server_available = servers[0]
    wait = max[0.0, next_server_available - arrival_time]
    waits.append[wait]
    service_duration = max[0.0, gauss[average_service_time, stdev_service_time]]
    service_completed = arrival_time + wait + service_duration
    heapreplace[servers, service_completed]

print[f'Mean wait: {mean[waits]:.1f}   Max wait: {max[waits]:.1f}']
print['Quartiles:', [round[q, 1] for q in quantiles[waits]]]

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify[servers]
for i in range[1_000_000]:
    arrival_time += expovariate[1.0 / average_arrival_interval]
    next_server_available = servers[0]
    wait = max[0.0, next_server_available - arrival_time]
    waits.append[wait]
    service_duration = max[0.0, gauss[average_service_time, stdev_service_time]]
    service_completed = arrival_time + wait + service_duration
    heapreplace[servers, service_completed]

print[f'Mean wait: {mean[waits]:.1f}   Max wait: {max[waits]:.1f}']
print['Quartiles:', [round[q, 1] for q in quantiles[waits]]]

Giá trị điểm cuối

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify[servers]
for i in range[1_000_000]:
    arrival_time += expovariate[1.0 / average_arrival_interval]
    next_server_available = servers[0]
    wait = max[0.0, next_server_available - arrival_time]
    waits.append[wait]
    service_duration = max[0.0, gauss[average_service_time, stdev_service_time]]
    service_completed = arrival_time + wait + service_duration
    heapreplace[servers, service_completed]

print[f'Mean wait: {mean[waits]:.1f}   Max wait: {max[waits]:.1f}']
print['Quartiles:', [round[q, 1] for q in quantiles[waits]]]

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify[servers]
for i in range[1_000_000]:
    arrival_time += expovariate[1.0 / average_arrival_interval]
    next_server_available = servers[0]
    wait = max[0.0, next_server_available - arrival_time]
    waits.append[wait]
    service_duration = max[0.0, gauss[average_service_time, stdev_service_time]]
    service_completed = arrival_time + wait + service_duration
    heapreplace[servers, service_completed]

print[f'Mean wait: {mean[waits]:.1f}   Max wait: {max[waits]:.1f}']
print['Quartiles:', [round[q, 1] for q in quantiles[waits]]]

Trả về một số điểm nổi ngẫu nhiên n sao cho

def random_product[*args, repeat=1]:
    "Random selection from itertools.product[*args, **kwds]"
    pools = [tuple[pool] for pool in args] * repeat
    return tuple[map[random.choice, pools]]

def random_permutation[iterable, r=None]:
    "Random selection from itertools.permutations[iterable, r]"
    pool = tuple[iterable]
    r = len[pool] if r is None else r
    return tuple[random.sample[pool, r]]

def random_combination[iterable, r]:
    "Random selection from itertools.combinations[iterable, r]"
    pool = tuple[iterable]
    n = len[pool]
    indices = sorted[random.sample[range[n], r]]
    return tuple[pool[i] for i in indices]

def random_combination_with_replacement[iterable, r]:
    "Random selection from itertools.combinations_with_replacement[iterable, r]"
    pool = tuple[iterable]
    n = len[pool]
    indices = sorted[random.choices[range[n], k=r]]
    return tuple[pool[i] for i in indices]

Phân phối beta. Điều kiện trên các tham số là

def random_product[*args, repeat=1]:
    "Random selection from itertools.product[*args, **kwds]"
    pools = [tuple[pool] for pool in args] * repeat
    return tuple[map[random.choice, pools]]

def random_permutation[iterable, r=None]:
    "Random selection from itertools.permutations[iterable, r]"
    pool = tuple[iterable]
    r = len[pool] if r is None else r
    return tuple[random.sample[pool, r]]

def random_combination[iterable, r]:
    "Random selection from itertools.combinations[iterable, r]"
    pool = tuple[iterable]
    n = len[pool]
    indices = sorted[random.sample[range[n], r]]
    return tuple[pool[i] for i in indices]

def random_combination_with_replacement[iterable, r]:
    "Random selection from itertools.combinations_with_replacement[iterable, r]"
    pool = tuple[iterable]
    n = len[pool]
    indices = sorted[random.choices[range[n], k=r]]
    return tuple[pool[i] for i in indices]

def random_product[*args, repeat=1]:
    "Random selection from itertools.product[*args, **kwds]"
    pools = [tuple[pool] for pool in args] * repeat
    return tuple[map[random.choice, pools]]

def random_permutation[iterable, r=None]:
    "Random selection from itertools.permutations[iterable, r]"
    pool = tuple[iterable]
    r = len[pool] if r is None else r
    return tuple[random.sample[pool, r]]

def random_combination[iterable, r]:
    "Random selection from itertools.combinations[iterable, r]"
    pool = tuple[iterable]
    n = len[pool]
    indices = sorted[random.sample[range[n], r]]
    return tuple[pool[i] for i in indices]

def random_combination_with_replacement[iterable, r]:
    "Random selection from itertools.combinations_with_replacement[iterable, r]"
    pool = tuple[iterable]
    n = len[pool]
    indices = sorted[random.choices[range[n], k=r]]
    return tuple[pool[i] for i in indices]

Phân phối theo cấp số nhân. Lambd là 1,0 chia cho giá trị trung bình mong muốn. Nó nên là khác nhau. .

Phân phối Gamma. [Không phải hàm gamma!] Điều kiện trên các tham số là

def random_product[*args, repeat=1]:
    "Random selection from itertools.product[*args, **kwds]"
    pools = [tuple[pool] for pool in args] * repeat
    return tuple[map[random.choice, pools]]

def random_permutation[iterable, r=None]:
    "Random selection from itertools.permutations[iterable, r]"
    pool = tuple[iterable]
    r = len[pool] if r is None else r
    return tuple[random.sample[pool, r]]

def random_combination[iterable, r]:
    "Random selection from itertools.combinations[iterable, r]"
    pool = tuple[iterable]
    n = len[pool]
    indices = sorted[random.sample[range[n], r]]
    return tuple[pool[i] for i in indices]

def random_combination_with_replacement[iterable, r]:
    "Random selection from itertools.combinations_with_replacement[iterable, r]"
    pool = tuple[iterable]
    n = len[pool]
    indices = sorted[random.choices[range[n], k=r]]
    return tuple[pool[i] for i in indices]