Hướng dẫn how do you use math random in python? - làm thế nào để bạn sử dụng ngẫu nhiên toán học trong python?

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

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

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

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

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

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

Đã 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.

Đã không dùng từ phiên bản 3.9: Trong tương lai, hạt giống phải là một trong các loại sau: Nonetype,

>>> # 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}']

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

# //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}']

>>> # 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 đố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[]                             # 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]

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

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

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

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

# 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.9.

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

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

# 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.']

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

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

Các mẫu đối số vị trí phù hợp vớ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]]]

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

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

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

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

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

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

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ư

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

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 random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

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ố nguyên ngẫu nhiên n sao cho

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

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

Đã 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

>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544

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

>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544

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

>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544

>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544

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

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ọ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ị

# //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}']

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

Đối với một hạt giống nhất định, hàm random[]5 với trọng số bằng nhau thường tạo ra một chuỗi khác với các cuộc gọi lặp lại đến random[]6. Thuật toán được sử dụng bởi random[]5 sử dụng số học điểm nổi cho tính nhất quán và tốc độ bên trong. Thuật toán được sử dụng bởi random[]6 mặc định cho số học số nguyên với các lựa chọn lặp đi lặp lại để tránh các độ lệch nhỏ khỏi lỗi làm tròn.

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

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

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]

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

Đối số tùy chọn ngẫu nhiên là một hàm 0 đối tượng trả về một bản nổi ngẫu nhiên trong [0,0, 1.0]; Theo mặc định, đây là chức năng random[].

Để xáo trộn một chuỗi bất biến và trả lại một danh sách được xáo trộn mới, hãy sử dụng random.Random3 thay thế.

Lưu ý rằng ngay cả đối với random.Random4 nhỏ, tổng số hoán vị của X có thể nhanh chóng phát triển lớn hơn thời gian của hầu hết các máy phát số ngẫu nhiên. Điều này ngụ ý rằng hầu hết các hoán vị của một chuỗi dài không bao giờ có thể được tạo ra. Ví dụ, một chuỗi độ dài 2080 là lớn nhất có thể phù hợp trong khoảng thời gian của bộ tạo số ngẫu nhiên Mersenne Twister.

Không dùng nữa kể từ phiên bản 3.9, sẽ 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ừ trình tự hoặc bộ 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ụ, random.Random7 tương đương với random.Random8.

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

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

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

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

from random import Random
from math import ldexp

class FullRandom[Random]:

    def random[self]:
        mantissa = 0x10_0000_0000_0000 | self.getrandbits[52]
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits[32]
            exponent += x.bit_length[] - 32
        return ldexp[mantissa, exponent]