Cách tạo câu hỏi toán học ngẫu nhiên trong python

Trình tạo bài toán, được tạo ra với mục đích cung cấp cho giáo viên và học sinh phương tiện để dễ dàng tiếp cận các bài tập toán ngẫu nhiên phù hợp với nhu cầu của họ

Để dùng thử trình tạo, hãy truy cập https. //mathgenerator-demo. netlify. ứng dụng

Xem ĐÓNG GÓP. md để biết thông tin về cách đóng góp

Mục lục

Cài đặt

Dự án có thể được cài đặt qua pip

pip install mathgenerator

Cách sử dụng

Đây là một ví dụ về cách bạn sẽ tạo ra một vấn đề bổ sung

import mathgenerator

#generate an addition problem
problem, solution = mathgenerator.addition[]

#another way to generate an addition problem using genById[]
problem, solution = mathgenerator.genById[0]

Bạn có thể thích sử dụng import mathgenerator as mg và chạy các chức năng như mg.addition[] để không phải gõ nhiều

Đối với số nguyên, có lựa chọn thống nhất từ ​​một phạm vi. Đối với các chuỗi, có sự lựa chọn thống nhất của một phần tử ngẫu nhiên, một chức năng để tạo ra một hoán vị ngẫu nhiên của một danh sách tại chỗ và một chức năng để lấy mẫu ngẫu nhiên mà không cần thay thế

Trên dòng thực, có các hàm để tính toán các phân phối thống nhất, bình thường [Gaussian], logic, hàm mũ âm, gamma và beta. Để tạo phân phối các góc, phân phối von Mises có sẵn

Hầu như tất cả các chức năng của mô-đun đều phụ thuộc vào chức năng cơ bản, chức năng này tạo ra một số float ngẫu nhiên đồng đều trong phạm vi nửa mở

>>> 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]
1. Python sử dụng Mersenne Twister làm trình tạo lõi. Nó tạo ra số float chính xác 53 bit và có khoảng thời gian là 2**19937-1. Việc triển khai cơ bản trong C vừa nhanh vừa an toàn. Mersenne Twister là một trong những trình tạo số ngẫu nhiên được thử nghiệm rộng rãi nhất hiện có. Tuy nhiên, hoàn toàn xác định, nó không phù hợp cho mọi mục đích và hoàn toàn không phù hợp cho mục đích mã hóa

Các chức năng được cung cấp bởi mô-đun này thực sự là các phương thức ràng buộc của một thể hiện ẩn của lớp. Bạn có thể khởi tạo các phiên bản của riêng mình để nhận các trình tạo không chia sẻ trạng thái

Lớp cũng có thể được phân lớp nếu bạn muốn sử dụng một trình tạo cơ bản khác do bạn nghĩ ra. trong trường hợp đó, hãy ghi đè các phương thức

>>> 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]
0,
>>> 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]
6,
>>> 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]
7 và
>>> 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]
8. Theo tùy chọn, trình tạo mới có thể cung cấp phương thức
>>> 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]
9 — điều này cho phép tạo ra các lựa chọn trên một phạm vi lớn tùy ý

Mô-đun này cũng cung cấp lớp sử dụng chức năng hệ thống để tạo số ngẫu nhiên từ các nguồn do hệ điều hành cung cấp

Cảnh báo

Không nên sử dụng bộ tạo giả ngẫu nhiên của mô-đun này cho mục đích bảo mật. Để sử dụng bảo mật hoặc mật mã, hãy xem mô-đun

Xem thêm

M. Matsumoto và T. Nishimura, “Mersenne Twister. Trình tạo số giả ngẫu nhiên thống nhất được phân bổ đều theo 623 chiều”, ACM Transactions on Modeling and Computer Simulation Vol. 8, Không. 1, tháng 1 trang. 3–30 1998

Công thức bổ sung-nhân-với-thực cho trình tạo số ngẫu nhiên thay thế tương thích với thời gian dài và các thao tác cập nhật tương đối đơn giản

chức năng kế toán

ngẫu nhiên. hạt[a=Không, version=2]

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
5, thời gian hệ thống hiện tại được sử dụng. Nếu các nguồn ngẫu nhiên được cung cấp bởi hệ điều hành, chúng sẽ được sử dụng thay vì thời gian hệ thống [xem chức năng để biết chi tiết về tính khả dụng]

Nếu a là một số nguyên, nó được sử dụng trực tiếp

Với phiên bản 2 [mặc định], một , hoặc đối tượng được chuyển đổi thành một và tất cả các bit của nó được sử dụng

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 và tạo phạm vi hạt giống hẹp hơn

Đã thay đổi trong phiên bản 3. 2. Đã chuyển sang lược đồ phiên bản 2 sử dụng tất cả các bit trong chuỗi gốc.

Đã thay đổi trong phiên bản 3. 11. Hạt giống phải thuộc một trong các loại sau. Không có Loại, , , , , hoặc.

ngẫu nhiên. getstate[]

Trả về một đối tượng nắm bắt 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 đến để khôi phục trạng thái

ngẫu nhiên. trạng thái thiết lập[trạng thái]

trạng thái lẽ ra phải được lấy từ một lệnh gọi trước đó tới và khôi phục trạng thái bên trong của trình tạo về trạng thái tại thời điểm được gọi

Hàm cho byte

ngẫu nhiên. randbyte[n]

Tạo n byte ngẫu nhiên

Không nên sử dụng phương pháp này để tạo mã thông báo bảo mật. sử dụng thay thế

Mới trong phiên bản 3. 9

Các hàm cho số nguyên

ngẫu nhiên. sắp xếp[dừng]ngẫu nhiên. sắp xếp[bắt đầu , dừng[, step]]

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

# 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.']
3. Điều này tương đương 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.']
4, nhưng không thực sự xây dựng một đối tượng phạm vi

Mẫu đối số vị trí khớp với mẫu của. Không nên sử dụng các đối số từ khóa vì hàm có thể sử dụng chúng theo những cách không mong muốn

Đã thay đổi trong phiên bản 3. 2. phức tạp hơn trong việc tạo ra các giá trị phân bổ đều. Trước đây, nó sử dụng một kiểu như

# 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.']
7 có thể tạo ra các bản phân phối hơi không đồng đều.

Không dùng nữa kể từ phiên bản 3. 10. Tính năng tự động chuyển đổi các loại không phải số nguyên thành số nguyên tương đương không được dùng nữa. Hiện tạ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.']
8 được chuyển đổi dễ dàng thành
# 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.']
9. Trong tương lai, điều này sẽ nâng cao.

Không dùng nữa kể từ phiên bản 3. 10. Ngoại lệ được đưa ra cho các giá trị không tách rời như

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]]]
1 hoặc
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]]]
2 sẽ được thay đổi từ thành.

ngẫu nhiên. randint[a , b]

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

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]]]
5. Bí danh cho
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]]]
6

ngẫu nhiên. getrandbits[k]

Trả về một số nguyên Python không âm với k bit ngẫu nhiên. Phương thức này được cung cấp cùng 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 khả dụng, cho phép xử lý các phạm vi lớn tùy ý

Đã thay đổi trong phiên bản 3. 9. Phương thức này hiện chấp nhận 0 cho k.

Hàm cho chuỗi

ngẫu nhiên. lựa chọn[seq]

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

ngẫu nhiên. lựa chọn[dân số , trọng số=None, *, cum_weights=None, k=1]

Trả về danh sách các phần tử có kích thước k được chọn từ dân số có thay thế. Nếu dân số trống, tăng

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 trọng số tích lũy [có thể được tính bằng ]. Ví dụ: trọng số tương đối

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]
2 tương đương với trọng số tích lũy
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]
3. Bên trong, trọng số tương đối được chuyển đổi thành trọng số tích lũy trước khi thực hiện lựa chọn, vì vậy việc cung cấp trọng số tích lũy giúp tiết kiệm công việc

Nếu cả trọng số và cum_weights đều không được chỉ định, thì 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 độ dài với chuỗi dân số. Đó là để chỉ định cả trọng số và cum_weights

Trọng số 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ị được trả về bởi [bao gồm số nguyên, số thực và phân số nhưng không bao gồm số thập phân]. Trọng số được giả định là không âm và hữu hạn. A được nâng lên nếu tất cả các trọng số bằng không

Đối với một hạt giống nhất định, hàm có trọng số bằng nhau thường tạo ra một chuỗi khác với các lệnh gọi lặp lại tới. Thuật toán được sử dụng bằng cách sử dụng số học dấu chấm động cho tính nhất quán bên trong và tốc độ. Thuật toán được sử dụng theo mặc định cho số học số nguyên với các lựa chọn lặp lại để tránh sai số nhỏ do 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 a nếu tất cả trọng số bằng 0.

ngẫu nhiên. xáo trộn[x]

Xáo trộn dãy x tại chỗ

Để xáo trộn một chuỗi bất biến và trả về một danh sách đã xáo trộn mới, thay vào đó hãy sử dụ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]
3

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

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]
4 nhỏ, tổng số hoán vị của x có thể nhanh chóng lớn hơn khoảng thời gian của hầu hết các trình tạo 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ụ: chuỗi có độ dài 2080 là chuỗi lớn nhất có thể nằm trong khoảng thời gian của trình tạo số ngẫu nhiên Mersenne Twister

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.

ngẫu nhiên. mẫu[dân số , k, *, counts=None]

Trả về danh sách độ dài k gồm các phần 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 phần tử từ tập hợp trong khi không thay đổi tập hợp ban đầu. Danh sách kết quả theo thứ tự lựa chọn để tất cả các lát cắt con cũng sẽ là các mẫu ngẫu nhiên hợp lệ. Điều này cho phép những người chiến thắng cuộc 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ần phụ]

Các thành viên của dân số không cần phải hoặc duy nhất. Nếu quần thể chứa các lần lặp lại, thì mỗi lần xuất hiện là một lựa chọn có thể có trong mẫu

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

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]
5 tương đương với
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]
6

Để chọn một mẫu từ một dải số nguyên, hãy sử dụng một đối tượng làm đối số. Điều này đặc biệt nhanh và tiết kiệm không gian để lấy mẫu từ một quần thể lớn.

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

Nếu cỡ mẫu lớn hơn cỡ dân số thì a tăng

Đã thay đổi trong phiên bản 3. 9. Đã thêm tham số đếm.

Đã thay đổi trong phiên bản 3. 11. Quần thể phải là một dãy. Tự động chuyển đổi bộ thành danh sách không còn được hỗ trợ.

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

Các chức năng sau tạo phân phối 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 của phân phối, như được sử dụng trong thực tế toán học phổ biến;

ngẫu nhiên. ngẫu nhiên[]

Trả về số dấu phẩy động ngẫu nhiên tiếp theo trong phạm vi

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

ngẫu nhiên. đồng phục[a , b]

Trả về một số dấu phẩy động ngẫu nhiên N sao cho

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]]]
5 cho
>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544
2 và
>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544
3 cho
>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544
4

Giá trị điểm cuối

>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544
5 có thể có hoặc không được bao gồm trong phạm vi tùy thuộc vào cách làm tròn dấu phẩy động trong phương trình
>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544
6

ngẫu nhiên. hình tam giác[thấp , cao, mode]

Trả về một số dấu phẩy động ngẫu nhiên N sao cho

>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544
7 và với chế độ được chỉ định giữa các giới hạn đó. Giới hạn thấp và cao mặc định là 0 và một. Đối số chế độ mặc định là điểm giữa giữa các giới hạn, tạo ra phân phối đối xứng

ngẫu nhiên. betavariate[alpha , beta]

phân phối beta. Điều kiện đối với các tham số là

>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544
8 và
>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544
9. Giá trị trả về nằm trong khoảng từ 0 đến 1

ngẫu nhiên. exovariate[lambd]

phân phối theo cấp số nhân. lambda là 1. 0 chia cho giá trị trung bình mong muốn. Nó phải khác không. [Tham số sẽ được gọi là “lambda”, nhưng đó là một từ dành riêng trong Python. ] Các giá trị được trả về nằm trong khoảng từ 0 đến vô cùng dương nếu lambda dương và từ vô cực âm thành 0 nếu lambda âm

ngẫu nhiên. biến thiên gam[alpha , beta]

phân phối gamma. [Không phải chức năng gamma. ] Điều kiện đối với các tham số là

>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544
8 và
>>> fr = FullRandom[]
>>> fr.random[]
0.05954861408025609
>>> fr.expovariate[0.25]
8.87925541791544
9

Hàm phân phối xác suất là

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

ngẫu nhiên. gauss[mu=0. 0 , sigma=1. 0]

Phân phối chuẩn, còn được gọi là phân phối Gaussian. mu là giá trị trung bình và sigma là độ lệch chuẩn. Điều này nhanh hơn một chút so với chức năng được xác định bên dưới

ghi chú đa luồng. Khi hai luồng gọi hàm này đồng thời, có thể chúng sẽ nhận được cùng một giá trị trả về. Điều này có thể tránh được theo ba cách. 1] Yêu cầu mỗi luồng sử dụng một phiên bản khác nhau của trình tạo số ngẫu nhiên. 2] Đặt khóa xung quanh tất cả các cuộc gọi. 3] Thay vào đó, hãy sử dụng chức năng chậm hơn nhưng an toàn cho luồng

Đã thay đổi trong phiên bản 3. 11. mu và sigma hiện có đối số mặc định.

ngẫu nhiên. lognormvariate[mu , sigma]

Phân phối lognormal. Nếu lấy logarit tự nhiên của phân phối này, bạn sẽ nhận được phân phối chuẩn với mu trung bình và sigma độ lệch chuẩn. mu có thể có bất kỳ giá trị nào và sigma phải lớn hơn 0

ngẫu nhiên. biến bình thường[mu=0. 0 , sigma=1. 0]

Phân phối bình thường. mu là giá trị trung bình và sigma là độ lệch chuẩn

Đã thay đổi trong phiên bản 3. 11. mu và sigma hiện có đối số mặc định.

ngẫu nhiên. vonmisesvariate[mu , kappa]

mu là góc trung bình, được biểu thị bằng radian trong khoảng từ 0 đến 2*pi và kappa là tham số nồng độ, giá trị này phải lớn hơn hoặc bằng 0. Nếu kappa bằng 0, phân phối này giảm xuống một góc ngẫu nhiên đồng nhất trong phạm vi từ 0 đến 2*pi

ngẫu nhiên. biến phụ[alpha]

phân phối Pareto. alpha là tham số hình dạng

ngẫu nhiên. weibullvariate[alpha , beta]

phân phối Weibull. alpha là tham số tỷ lệ và beta là tham số hình dạng

Máy phát điện thay thế

lớp ngẫu nhiên. Ngẫu nhiên[[hạt]]

Lớp triển khai trình tạo số giả ngẫu nhiên mặc định được sử dụng bởi mô-đun

Không dùng nữa kể từ phiên bản 3. 9. Trong tương lai, hạt giống phải thuộc một trong các loại sau. random5, , , , , hoặc.

lớp ngẫu nhiên. SystemRandom[[hạt]]

Lớp sử dụng chức năng tạo số ngẫu nhiên từ các nguồn do hệ điều hành cung cấp. Không có sẵn trên tất cả các hệ thống. Không phụ thuộc vào trạng thái phần mềm và trình tự không thể lặp lại. Theo đó, phương pháp không có hiệu lực và bị bỏ qua. Phương thức và raise nếu được gọi

Lưu ý về khả năng tái sản xuất

Đôi khi, rất hữu ích khi có thể tái tạo các chuỗi được cung cấp bởi trình tạo số giả ngẫu nhiên. Bằng cách sử dụng lại một giá trị gốc, cùng một trình tự sẽ được tái tạo từ lần chạy này sang lần chạy khác miễn là nhiều luồng không chạy

Hầu hết các thuật toán và chức năng gieo hạt của mô-đun ngẫu nhiên có thể thay đổi qua các phiên bản Python, nhưng hai khía cạnh được đảm bảo không thay đổi

  • Nếu một phương pháp gieo hạt mới được thêm vào, thì một bộ gieo hạt tương thích ngược sẽ được cung cấp

  • Phương thức

    >>> 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]
    
    0 của trình tạo sẽ tiếp tục tạo ra cùng một chuỗi khi trình tạo tương thích được cung cấp cùng một hạt giống

ví dụ

ví dụ cơ bả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]

mô phỏng

________số 8_______

Ví dụ về bootstrapping thống kê sử dụng lấy mẫu lại có thay thế để ước tính khoảng tin cậy cho giá trị trung bình của mẫu

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

Ví dụ về a để xác định ý nghĩa thống kê hoặc giá trị p của sự khác biệt quan sát được giữa tác dụng của thuốc so với giả dược

# 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ô phỏng thời gian đến và cung cấp dịch vụ cho hàng đợi nhiều máy chủ

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

Xem thêm

Statistics for Hackers một video hướng dẫn của Jake Vanderplas về phân tích thống kê chỉ bằng một vài khái niệm cơ bản bao gồm mô phỏng, lấy mẫu, xáo trộn và xác thực chéo

Mô phỏng kinh tế Mô phỏng thị trường của Peter Norvig cho thấy việc sử dụng hiệu quả nhiều công cụ và phân phối được cung cấp bởi mô-đun này [gauss, thống nhất, mẫu, biến thiên beta, lựa chọn, tam giác và phạm vi]

Giới thiệu cụ thể về xác suất [sử dụng Python] hướng dẫn của Peter Norvig bao gồm những điều cơ bản về lý thuyết xác suất, cách viết mô phỏng và cách thực hiện phân tích dữ liệu bằng Python

Công thức nấu ăn

Các công thức này cho thấy cách thực hiện các lựa chọn ngẫu nhiên một cách hiệu quả từ các trình vòng lặp tổ hợp trong mô-đun

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]

Giá trị mặc định trả về bội số của 2⁻⁵³ trong phạm vi 0. 0 ≤ x < 1. 0. Tất cả các số như vậy đều cách đều nhau và có thể biểu diễn chính xác khi Python float. Tuy nhiên, nhiều số float có thể biểu diễn khác trong khoảng thời gian đó là không thể lựa chọn. Ví dụ:

>>> 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]
09 không phải là bội số nguyên của 2⁻⁵³

Công thức sau đây có một cách tiếp cận khác. Tất cả các số float trong khoảng thời gian là các lựa chọn có thể. Phần định trị xuất phát từ sự phân bố đều các số nguyên trong phạm vi 2⁵² ≤ phần định trị < 2⁵³. Số mũ xuất phát từ một phân phối hình học trong đó số mũ nhỏ hơn -53 xuất hiện bằng một nửa so với số mũ lớn hơn tiếp theo

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]

Tất cả trong lớp sẽ sử dụng phương pháp mới

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

Về mặt khái niệm, công thức này tương đương với một thuật toán chọn từ tất cả các bội số của 2⁻¹⁰⁷⁴ trong phạm vi 0. 0 ≤ x < 1. 0. Tất cả các số như vậy đều cách đều nhau, nhưng hầu hết phải được làm tròn xuống số float Python có thể biểu thị gần nhất. [Giá trị 2⁻¹⁰⁷⁴ là số float không chuẩn hóa dương nhỏ nhất và bằng 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]
10. ]

Xem thêm

Tạo các giá trị dấu phẩy động giả ngẫu nhiên một bài báo của Allen B. Downey mô tả các cách để tạo ra nhiều số float chi tiết hơn so với cách tạo thông thường bằng cách

Chủ Đề