random --- Tạo số giả ngẫu nhiên

Source code: Lib/random.py

---

Mô-đun này triển khai các trình tạo số giả ngẫu nhiên cho các phân phối khác nhau.

Đối với số nguyên, có sự 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 một phần tử ngẫu nhiên, một hàm tạo ra hoán vị ngẫu nhiên của một danh sách tại chỗ và một hàm 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 đồng nhất, bình thường (Gaussian), logic chuẩn, hàm mũ âm, gamma và beta. Để tạo ra sự phân bố các góc, có thể sử dụng phân bố von Mises.

Hầu hết tất cả các chức năng mô-đun đều phụ thuộc vào chức năng cơ bản random(), chức năng này tạo ra sự nổi ngẫu nhiên thống nhất trong phạm vi nửa mở 0.0 <= X < 1.0. Python sử dụng Mersenne Twister làm trình tạo lõi. Nó tạo ra các số float chính xác 53 bit và có chu kỳ 2**19937-1. Việc triển khai cơ bản trong C vừa nhanh vừa an toàn theo luồng. Mersenne Twister là một trong những máy tạo số ngẫu nhiên được thử nghiệm rộng rãi nhất hiện nay. Tuy nhiên, hoàn toàn mang tính xác định nên 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 hàm do mô-đun này cung cấp thực chất là các phương thức được liên kết của một phiên bản ẩn của lớp random.Random. Bạn có thể khởi tạo các phiên bản Random của riêng mình để có được các trình tạo không chia sẻ trạng thái.

Lớp Random 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 chính bạn nghĩ ra: xem tài liệu về lớp đó để biết thêm chi tiết.

Mô-đun random cũng cung cấp lớp SystemRandom sử dụng hàm hệ thống os.urandom() để tạo các 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 trình tạo giả ngẫu nhiên của mô-đun này cho mục đích bảo mật. Để biết cách sử dụng bảo mật hoặc mật mã, hãy xem mô-đun secrets.

Xem thêm

M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-dimensionally equidistributed uniform pseudorandom number generator", ACM Transactions on Modeling and Computer Simulation Vol. 8, No. 1, January pp.3--30 1998.

Complementary-Multiply-with-Carry recipe để có một 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.

Ghi chú

Trình tạo số ngẫu nhiên toàn cầu và các phiên bản của Random đều an toàn theo luồng. Tuy nhiên, trong bản dựng theo luồng tự do, các lệnh gọi đồng thời tới trình tạo chung hoặc tới cùng một phiên bản của Random có thể gặp phải sự tranh chấp và hiệu suất kém. Thay vào đó, hãy xem xét sử dụng các phiên bản Random riêng biệt cho mỗi luồng.

Chức năng kế toán

random.seed(a=None, version=2)

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

Nếu a bị bỏ qua hoặc None, thời gian hệ thống hiện tại sẽ được sử dụng. Nếu các nguồn ngẫu nhiên được hệ điều hành cung cấp, chúng sẽ được sử dụng thay vì thời gian của hệ thống (xem hàm os.urandom() để biết chi tiết về tính khả dụng).

Nếu a là int, giá trị tuyệt đối của nó sẽ được sử dụng trực tiếp.

Với phiên bản 2 (mặc định), đối tượng str, bytes hoặc bytearray được chuyển đổi thành int và tất cả các bit của nó đều đượ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 str và bytes tạo ra phạm vi hạt giống hẹp hơn.

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 chuỗi hạt giống.

Thay đổi trong phiên bản 3.11: Zz006zz phải là một trong các loại sau: None, int, float, str, bytes hoặc bytearray.

random.getstate()

Trả về một đối tượng ghi lại 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 tới setstate() để khôi phục trạng thái.

random.setstate(state)

state đáng lẽ phải được lấy từ lệnh gọi trước tới getstate() và setstate() khôi phục trạng thái bên trong của trình tạo về trạng thái như lúc getstate() được gọi.

Các hàm dành cho byte

random.randbytes(n)

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

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. Thay vào đó hãy sử dụng secrets.token_bytes().

Added in version 3.9.

Hàm cho số nguyên

random.randrange(stop)

random.randrange(start, stop[, step])

Trả về phần tử được chọn ngẫu nhiên từ range(start, stop, step).

Điều này gần tương đương với choice(range(start, stop, step)) nhưng hỗ trợ phạm vi lớn tùy ý và được tối ưu hóa cho các trường hợp thông thường.

Mẫu đối số vị trí khớp với hàm range().

Không nên sử dụng đối số từ khóa vì chúng có thể được hiểu theo những cách không mong muốn. Ví dụ randrange(start=100) được hiểu là randrange(0, 100, 1).

Thay đổi trong phiên bản 3.2: randrange() phức tạp hơn trong việc tạo ra các giá trị được phân bổ đồng đều. Trước đây nó sử dụng kiểu như int(random()*n) có thể tạo ra sự phân bố hơi không đồng đều.

Thay đổi trong phiên bản 3.12: Tự động chuyển đổi các loại không nguyên không còn được hỗ trợ. Các lệnh gọi như randrange(10.0) và randrange(Fraction(10, 1)) hiện tạo ra TypeError.

random.randint(a, b)

Trả về một số nguyên ngẫu nhiên N sao cho a <= N <= b. Bí danh cho randrange(a, b+1).

random.getrandbits(k)

Trả về số nguyên Python không âm với các bit ngẫu nhiên k. Phương pháp này được cung cấp cùng với trình tạo Mersenne Twister 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, getrandbits() cho phép randrange() xử lý các phạm vi lớn tùy ý.

Thay đổi trong phiên bản 3.9: Phương pháp này hiện chấp nhận số 0 cho k.

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

random.choice(seq)

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 IndexError.

random.choices(population, weights=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ừ population có thay thế. Nếu population trống, tăng IndexError.

Nếu chuỗi weights được chỉ định, các lựa chọn sẽ được thực hiện theo trọng số tương đối. Ngoài ra, nếu chuỗi cum_weights được đưa ra, các lựa chọn sẽ được thực hiện theo trọng số tích lũy (có thể được tính bằng itertools.accumulate()). Ví dụ: trọng số tương đối [10, 5, 30, 5] tương đương với trọng số tích lũy [10, 15, 45, 50]. Trong nội bộ, các trọng số tương đối được chuyển đổi thành các trọng số tích lũy trước khi thực hiện các lựa chọn, do đó, việc cung cấp các trọng số tích lũy sẽ giúp tiết kiệm công việc.

Nếu cả weights và cum_weights đều không được chỉ định thì các lựa chọn sẽ đượ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 thì nó phải có cùng độ dài với chuỗi population. Đó là TypeError để chỉ định cả weights và cum_weights.

weights 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ị float được trả về bởi random() (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 coi là không âm và hữu hạn. Một ValueError được nâng lên nếu tất cả trọng số bằng 0.

Đối với một hạt giống nhất định, hàm choices() 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 choice(). Thuật toán được choices() sử dụng sử dụng số học dấu phẩy động để đảm bảo tính nhất quán và tốc độ bên trong. Thuật toán được choice() sử dụng mặc định là số học số nguyên với các lựa chọn lặp đi lặp lại để tránh những sai lệch nhỏ do lỗi làm tròn.

Added in version 3.6.

Thay đổi trong phiên bản 3.9: Tăng ValueError nếu tất cả trọng số bằng 0.

random.shuffle(x)

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

Để xáo trộn một chuỗi bất biến và trả về một danh sách được xáo trộn mới, thay vào đó hãy sử dụng sample(x, k=len(x)).

Lưu ý rằng ngay cả đối với len(x) nhỏ, tổng số hoán vị của x có thể nhanh chóng tă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ụ: một chuỗi có độ dài 2080 là chuỗi lớn nhất có thể vừa với chu kỳ của bộ tạo số ngẫu nhiên Mersenne Twister.

Thay đổi trong phiên bản 3.11: Đã xóa tham số tùy chọn random.

random.sample(population, 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 tổng thể. Đượ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 vẫn giữ nguyên tập hợp ban đầu. Danh sách kết quả được sắp xếp theo thứ tự lựa chọn sao cho tất cả các lát cắt 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 người chiến thắng 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 quần thể không cần phải là hashable 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 lần lượt hoặc bằng tham số counts chỉ có từ khóa tùy chọn. Ví dụ: sample(['red', 'blue'], counts=[4, 2], k=5) tương đương với sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5).

Để chọn một mẫu từ một dãy số nguyên, hãy sử dụng đối tượng range() 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: sample(range(10000000), k=60).

Nếu kích thước mẫu lớn hơn kích thước tổng thể thì ValueError sẽ tăng lên.

Thay đổi trong phiên bản 3.9: Đã thêm tham số counts.

Thay đổi trong phiên bản 3.11: Zz000zz 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ợ.

Phân phối rời rạc

Hàm sau đây tạo ra một phân phối rời rạc.

random.binomialvariate(n=1, p=0.5)

Binomial distribution. Trả về số lần thành công cho các lần thử độc lập n với xác suất thành công trong mỗi lần thử là p:

Về mặt toán học tương đương với:

sum(random() < p for i in range(n))

Số lần thử n phải là số nguyên không âm. Xác suất thành công của p phải nằm trong khoảng 0.0 <= p <= 1.0. Kết quả là một số nguyên trong phạm vi 0 <= X <= n.

Added in version 3.12.

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

Các hàm sau đây tạo ra các phân phối có giá trị thực cụ thể. Các tham số của hàm đượ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ê nào.

random.random()

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

random.uniform(a, b)

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

Giá trị điểm cuối b có thể được bao gồm hoặc không trong phạm vi tùy thuộc vào việc làm tròn dấu phẩy động trong biểu thức a + (b-a) * random().

random.triangular(low, high, mode)

Trả về một số dấu phẩy động ngẫu nhiên N sao cho low <= N <= high và với mode được chỉ định giữa các giới hạn đó. Giới hạn low và high mặc định là 0 và 1. Đối số mode mặc định là điểm giữa giữa các giới hạn, tạo ra sự phân bố đối xứng.

random.betavariate(alpha, beta)

Phân phối beta. Điều kiện trên các tham số là alpha > 0 và beta > 0. Giá trị trả về nằm trong khoảng từ 0 đến 1.

random.expovariate(lambd=1.0)

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ó 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ị trả về nằm trong khoảng từ 0 đến vô cực dương nếu lambd là dương và từ vô cực âm đến 0 nếu lambd là âm.

Thay đổi trong phiên bản 3.12: Đã thêm giá trị mặc định cho lambd.

random.gammavariate(alpha, beta)

Phân bố gamma. (Not hàm gamma!) Các tham số hình dạng và tỷ lệ, alpha và beta, phải có giá trị dương. (Quy ước gọi khác nhau và một số nguồn định nghĩa 'beta' là nghịch đảo của thang đo).

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

random.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 hàm normalvariate() được xác định bên dưới.

Lưu ý đa luồng: Khi hai luồng gọi hàm này cùng lúc, 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 bằng 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 normalvariate() chậm hơn nhưng an toàn theo luồng.

Thay đổi trong phiên bản 3.11: mu và sigma hiện có đối số mặc định.

random.lognormvariate(mu, sigma)

Đăng nhập phân phối bình thường. Nếu bạn 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 trung bình mu và độ lệch chuẩn sigma. mu có thể có bất kỳ giá trị nào và sigma phải lớn hơn 0.

random.normalvariate(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.

random.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, and kappa là tham số nồng độ, phải lớn hơn hoặc bằng 0. Nếu kappa bằng 0, thì phân bố 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.

random.paretovariate(alpha)

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

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

class random.Random([seed])

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

Thay đổi trong phiên bản 3.11: Trước đây seed có thể là bất kỳ đối tượng có thể băm nào. Bây giờ nó được giới hạn ở: None, int, float, str, bytes hoặc bytearray.

Các lớp con của Random nên ghi đè các phương thức sau nếu chúng muốn sử dụng một trình tạo cơ bản khác:

seed(a=None, version=2)

Ghi đè phương thức này trong các lớp con để tùy chỉnh hành vi seed() của các phiên bản Random.

getstate()

Ghi đè phương thức này trong các lớp con để tùy chỉnh hành vi getstate() của các phiên bản Random.

setstate(state)

Ghi đè phương thức này trong các lớp con để tùy chỉnh hành vi setstate() của các phiên bản Random.

random()

Ghi đè phương thức này trong các lớp con để tùy chỉnh hành vi random() của các phiên bản Random.

Tùy chọn, một lớp con trình tạo tùy chỉnh cũng có thể cung cấp phương thức sau:

getrandbits(k)

Ghi đè phương thức này trong các lớp con để tùy chỉnh hành vi getrandbits() của các phiên bản Random.

randbytes(n)

Ghi đè phương thức này trong các lớp con để tùy chỉnh hành vi randbytes() của các phiên bản Random.

class random.SystemRandom([seed])

Lớp sử dụng hàm os.urandom() để 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à các chuỗi không thể tái tạo được. Theo đó, phương pháp seed() không có tác dụng và bị bỏ qua. Các phương thức getstate() và setstate() sẽ tăng NotImplementedError nếu được gọi.

Lưu ý về độ tái lập

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

Hầu hết các thuật toán và chức năng gieo mầm của mô-đun ngẫu nhiên có thể thay đổi giữa 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 máy gieo hạt tương thích ngược sẽ được cung cấp.

• Phương pháp random() của trình tạo sẽ tiếp tục tạo ra trình tự tương tự khi máy gieo hạt tương thích được cấp cùng một hạt giống.

Ví dụ

Ví dụ cơ bản:

>>> ngẫu nhiên() # Random float: 0,0 <= x < 1,0
0.37444887175646646

>>> thống nhất(2.5, 10.0) # Random float: 2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5) # Interval giữa các lần đến trung bình 5 giây
5.148957571865031

>>> randrange(10) # Integer bao gồm từ 0 đến 9
7

>>> randrange(0, 101, 2) # Even số nguyên từ 0 đến 100
26

>>> lựa chọn(['thắng', 'thua', 'hòa']) phần tử ngẫu nhiên # Single từ một chuỗi
'vẽ'

>>> deck = 'át hai ba bốn'.split()
>>> xáo trộn(bộ bài) # Shuffle một danh sách
>>> sàn
['bốn', 'hai', 'át', 'ba']

>>> sample([10, 20, 30, 40, 50], k=4) mẫu # Four không thay thế
[40, 10, 50, 30]

Mô phỏng:

>>> Vòng quay bánh xe roulette # Six (lấy mẫu có trọng số kèm theo thay thế)
>>> lựa chọn(['đỏ', 'đen', 'xanh'], [18, 18, 2], k=6)
['đỏ', 'xanh', 'đen', 'đen', 'đỏ', 'đen']

>>> # Deal 20 lá bài không cần thay thế từ bộ bài
>>> # of 52 bài chơi và xác định tỷ lệ bài
>>> # with một giá trị mười: mười, jack, nữ hoàng hoặc vua.
>>> chia = sample(['tens', 'thẻ thấp'], count=[16, 36], k=20)
>>> deal.count('tens') / 20
0,15

>>> # Estimate xác suất nhận được 5 mặt ngửa trở lên từ 7 lần quay
>>> # of một đồng xu có xu hướng nghiêng về mặt ngửa 60% thời gian.
>>> sum(binomialvariate(n=7, p=0.6) >= 5 cho i trong phạm vi(10_000)) / 10_000
0,4169

>>> # Probability trung vị của 5 mẫu nằm ở hai phần tư giữa
>>> thử nghiệm chắc chắn():
... trả về 2_500 <= đã sắp xếp(lựa chọn(phạm vi(10_000), k=5))[2] < 7_500
...
>>> sum(trial() cho i trong phạm vi(10_000)) / 10_000
0,7958

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

# zz000zz
từ số liệu thống kê nhập fmean làm giá trị trung bình
từ các lựa chọn nhập ngẫu nhiên

dữ liệu = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
có nghĩa là = được sắp xếp (trung bình (lựa chọn (dữ liệu, k=len(dữ liệu))) cho i trong phạm vi (100))
print(f'Giá trị trung bình mẫu của {mean(data):.1f} có độ tin cậy 90% '
      f'khoảng từ {means[5]:.1f} đến {means[94]:.1f}')

Ví dụ về resampling permutation test để xác định ý nghĩa thống kê hoặc p-value 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 từ "Thống kê thật dễ dàng" của Dennis Shasha và Manda Wilson
từ số liệu thống kê nhập fmean làm giá trị trung bình
từ ngẫu nhiên nhập khẩu ngẫu nhiên

thuốc = [54, 73, 53, 70, 73, 68, 52, 65, 65]
giả dược = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
quan sát_diff = trung bình(thuốc) - trung bình(giả dược)

n = 10_000
đếm = 0
kết hợp = thuốc + giả dược
cho tôi trong phạm vi (n):
    xáo trộn (kết hợp)
    new_diff = Mean(combined[:len(thuốc)]) - Mean(combined[len(thuốc):])
    đếm += (new_diff >= quan sát_diff)

print(f'{n} việc xáo trộn lại nhãn chỉ tạo ra {count} trường hợp có sự khác biệt')
print(f'ít nhất cũng bằng mức chênh lệch quan sát được của {observed_diff:.1f}.')
print(f'Giá trị p một phía của {count / n:.4f} khiến chúng ta bác bỏ giá trị null')
print(f'giả thuyết rằng không có sự khác biệt giữa thuốc và giả dược.')

Mô phỏng thời gian đến và cung cấp dịch vụ cho hàng đợi nhiều máy chủ:

từ heapq nhập heapify, heapreplace
từ nhập ngẫu nhiên expovariate, gauss
từ số liệu thống kê nhập trung bình, lượng tử

trung bình_đến_khoảng = 5,6
trung bình_service_time = 15,0
stdev_service_time = 3,5
num_server = 3

chờ đợi = []
thời gian đến = 0,0
máy chủ = [0,0] * num_servers # time khi mỗi máy chủ có sẵn
tăng cường(máy chủ)
cho tôi trong phạm vi (1_000_000):
    thời gian đến += expovariate(1,0 / Average_arrival_interval)
    next_server_available = máy chủ[0]
    chờ = tối đa (0,0, next_server_available - Arrival_time)
    chờ đợi.append(chờ)
    service_duration = max(0,0, gauss(average_service_time, stdev_service_time))
    dịch vụ_đã hoàn thành = thời gian đến + chờ + thời gian phục vụ
    heapreplace(máy chủ, service_completed)

print(f'Mean chờ: {mean(waits):.1f} Chờ tối đa: {max(waits):.1f}')
print('Quartiles:', [round(q, 1) for q in quantiles(wait)])

Xem thêm

Statistics for Hackers video hướng dẫn của Jake Vanderplas về phân tích thống kê chỉ sử dụng một số 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.

Economics Simulation 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, betavariate, lựa chọn, tam giác và ngẫu nhiên).

A Concrete Introduction to Probability (using Python) hướng dẫn của Peter Norvig bao gồm các kiến thức 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 itertools:

nhập khẩu ngẫu nhiên

def Random_product(*iterables, Repeat=1):
    "Lựa chọn ngẫu nhiên từ itertools.product(*iterables, Repeat=repeat)"
    pool = tuple(map(tuple, iterables)) * lặp lại
    trả về tuple(map(random.choice,pools))

def Random_permutation(iterable, r=None):
    "Lựa chọn ngẫu nhiên từ itertools.permutations(iterable, r)"
    pool = tuple(lặp lại)
    r = len(pool) nếu r là Không có gì khác r
    trả về tuple(random.sample(pool, r))

def Random_combination(iterable, r):
    "Lựa chọn ngẫu nhiên từ itertools.combinations(iterable, r)"
    pool = tuple(lặp lại)
    n = len(pool)
    chỉ số = được sắp xếp(random.sample(range(n), r))
    trả về tuple(pool[i] cho i trong chỉ mục)

def Random_combination_with_replacement(iterable, r):
    "Chọn r phần tử có thể thay thế. Sắp xếp kết quả sao cho khớp với phần tử có thể lặp lại."
    # Result sẽ được thiết lập (itertools.combinations_with_replacement(iterable, r)).
    pool = tuple(lặp lại)
    n = len(pool)
    chỉ số = được sắp xếp(random.choices(range(n), k=r))
    trả về tuple(pool[i] cho i trong chỉ mục)

def Random_derangement (lặp lại):
    "Chọn một hoán vị trong đó không có phần tử nào giữ nguyên vị trí ban đầu."
    seq = tuple(lặp lại)
    nếu len(seq) < 2:
        nếu không phải seq:
            trở lại ()
        raise IndexError('Không có sự xáo trộn nào để lựa chọn')
    perm = danh sách (phạm vi (len (seq)))
    bắt đầu = tuple(perm)
    trong khi Đúng:
        ngẫu nhiên.shuffle(perm)
        if all(p != q for p, q in zip(start, perm)):
            trả về tuple([seq[i] for i in perm])

random() 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 dưới dạng số float của Python. Tuy nhiên, nhiều số float có thể biểu thị khác trong khoảng đó không thể được lựa chọn. Ví dụ: 0.05954861408025609 không phải là bội số nguyên của 2⁻⁵³.

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

từ nhập ngẫu nhiên
từ nhập toán học ldexp

lớp FullRandom (Ngẫu nhiên):

    def ngẫu nhiên (tự):
        lớp phủ = 0x10_0000_0000_0000 | self.getrandbits(52)
        số mũ = -53
        x = 0
        trong khi không x:
            x = self.getrandbits(32)
            số mũ += x.bit_length() - 32
        trả về ldexp(mantissa, số mũ)

Tất cả real valued distributions trong lớp sẽ sử dụng phương thức mới:

>>> fr = FullRandom()
>>> fr.random()
0,05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

Công thức này về mặt khái niệm tương đương với một thuật toán chọn từ tất 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 math.ulp(0.0).)

Xem thêm

Generating Pseudo-random Floating-Point Values một bài báo của Allen B. Downey mô tả các cách tạo ra nhiều phao chi tiết hơn so với thông thường do random() tạo ra.

Sử dụng dòng lệnh

Added in version 3.13.

Mô-đun random có thể được thực thi từ dòng lệnh.

python -m ngẫu nhiên [-h] [-c CHOICE [CHOICE ...] | -i N | -f N] [đầu vào ...]

Các tùy chọn sau được chấp nhận:

-h, --help

Hiển thị thông báo trợ giúp và thoát.

-c CHOICE [CHOICE ...]

--choice CHOICE [CHOICE ...]

In một lựa chọn ngẫu nhiên, sử dụng choice().

-i <N>

--integer <N>

In một số nguyên ngẫu nhiên từ 1 đến N, sử dụng randint().

-f <N>

--float <N>

In một số dấu phẩy động ngẫu nhiên trong khoảng từ 0 đến N, sử dụng uniform().

Nếu không có tùy chọn nào được đưa ra, đầu ra sẽ phụ thuộc vào đầu vào:

• Chuỗi hoặc nhiều chuỗi: giống như --choice.

• Số nguyên: giống như --integer.

• Nổi: giống như --float.

Ví dụ dòng lệnh

Dưới đây là một số ví dụ về giao diện dòng lệnh random:

$ # Choose một cái ngẫu nhiên
$ python -m spam xúc xích trứng ngẫu nhiên thịt xông khói "Tôm hùm Thermidor aux crevettes với sốt Mornay"
Tôm hùm Thermidor aux crevettes với sốt Mornay

$# Random số nguyên
$ trăn -m ngẫu nhiên 6
6

$ # Random số dấu phẩy động
$ trăn -m ngẫu nhiên 1,8
1.7080016272295635

$ # With đối số rõ ràng
$ python -m ngẫu nhiên --choice trứng xúc xích thịt xông khói thư rác "Tôm hùm Thermidor aux crevettes với sốt Mornay"
quả trứng

$ python -m ngẫu nhiên -- số nguyên 6
3

$ python -m ngẫu nhiên --float 1.8
1.5666339105010318

$ python -m ngẫu nhiên -- số nguyên 6
5

$ python -m ngẫu nhiên --float 6
3.1942323316565915