Hướng dẫn why random is used in python? - tại sao ngẫu nhiên được sử dụng trong python?

Mô-đun

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
4 là một mô-đun tích hợp để tạo các biến giả ngẫu nhiên. Nó có thể được sử dụng thực hiện một số hành động một cách ngẫu nhiên như để có được một số ngẫu nhiên, chọn một phần tử ngẫu nhiên từ danh sách, các yếu tố xáo trộn một cách ngẫu nhiên, v.v.

Tạo phao ngẫu nhiên

Phương pháp

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
5 trả về số nổi ngẫu nhiên trong khoảng 0,0 đến 1,0. Hàm không cần bất kỳ đối số nào.

>>> import random
>>> random.random()
0.645173684807533

Tạo số nguyên ngẫu nhiên

Phương thức

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
6 trả về một số nguyên ngẫu nhiên giữa các số nguyên được chỉ định.

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49

Tạo các số ngẫu nhiên trong phạm vi

Phương thức

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
7 trả về một phần tử được chọn ngẫu nhiên từ phạm vi được tạo bởi các đối số bắt đầu, dừng và bước. Giá trị của bắt đầu là 0 theo mặc định. Tương tự, giá trị của bước là 1 theo mặc định.

>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80

Chọn các yếu tố ngẫu nhiên

Phương thức

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
8 trả về một phần tử được chọn ngẫu nhiên từ một chuỗi không trống. Một chuỗi trống khi đối số làm tăng chỉ số.

>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67

Các yếu tố xáo trộn ngẫu nhiên

Phương thức

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
9 sắp xếp lại ngẫu nhiên các phần tử trong danh sách.

>>> numbers=[12,23,45,67,65,43]
>>> random.shuffle(numbers)
>>> numbers
[23, 12, 43, 65, 67, 45]
>>> random.shuffle(numbers)
>>> numbers
[23, 43, 65, 45, 12, 67]

Tìm hiểu thêm về mô -đun ngẫu nhiên trong tài liệu Python.

Mã nguồn: lib/ngẫu nhiên.py Lib/random.py


Mô-đun này thực hiện các trình tạo số giả giả cho các phân phối khác nhau.

Đố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 hàm để 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 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 đồng nhất, bình thường (Gaussian), phân phối theo cấp số nhân, gamma và beta âm. Để 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 hàm mô-đun phụ thuộc vào hàm cơ bản

>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
0, tạo ra một phao ngẫu nhiên đồng đều trong phạm vi bán mở [0,0, 1.0). Python sử dụng Mersenne Twister làm trình tạo cốt lõi. Nó tạo ra phao chính xác 53 bit và có thời gian 2 ** 19937-1. Việc triển khai cơ bản trong C là cả nhanh và sleadSafe. Mersenne Twister là một trong những bộ tạo số ngẫu nhiên được thử nghiệm rộng rãi nhất đang tồn tại. Tuy nhiên, hoàn toàn quyết định, nó không phù hợp cho tất cả các mục đích và hoàn toàn không phù hợp cho mục đích mật mã.

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 trường hợp ẩn của lớp

>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
1. Bạn có thể khởi tạo các trường hợp
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
2 của riêng bạn để có được các trình tạo mà không chia sẻ trạng thái.

Lớp

>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
2 cũng có thể được phân nhóm nếu bạn muốn sử dụng một trình tạo cơ bản khác của sự phát minh của riêng bạn: trong trường hợp đó, ghi đè các phương thức
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
0,
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
5,
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
6 và
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
7. Tùy chọn, một trình tạo mới có thể cung cấp một phương thức
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
8 - điều này cho phép
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
9 tạo ra các lựa chọn trên một phạm vi lớn tùy ý.

Mô -đun

>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
0 cũng cung cấp lớp
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
1 sử dụng chức năng hệ thống
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
2 để tạo các số ngẫu nhiên từ các nguồn được cung cấp bởi hệ điều hành.

Cảnh báo

Không nên sử dụng các trình 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 sử dụng mật mã, hãy xem mô -đun

>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
3.

Xem thêm

M. Matsumoto và T. Nishimura, Hồi Mersenne Twister: Một trình tạo số giả đồng nhất được phân phối đồng nhất 623 chiều, Giao dịch ACM về mô hình hóa và mô phỏng máy tính Vol. 8, Số 1, tháng 1 Trang 3 Điện30 1998.

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

Chức năng kế toán

ngẫu nhiên.seed (a = none, phiên bản = 2) ¶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

>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
4, 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 được sử dụng thay vì thời gian hệ thống (xem hàm
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
2 để biết chi tiết về tính khả dụng).

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

>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
6,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
7 hoặc
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
8 được chuyển đổi thành
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
9 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

>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
6 và
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
7 tạo ra phạm vi hạt 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 hạt giống.Moved to the version 2 scheme which uses all of the bits in a string seed.

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

>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
9,
>>> numbers=[12,23,45,67,65,43]
>>> random.shuffle(numbers)
>>> numbers
[23, 12, 43, 65, 67, 45]
>>> random.shuffle(numbers)
>>> numbers
[23, 43, 65, 45, 12, 67]
3,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
6,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
7 hoặc
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
8.The seed must be one of the following types: NoneType,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
9,
>>> numbers=[12,23,45,67,65,43]
>>> random.shuffle(numbers)
>>> numbers
[23, 12, 43, 65, 67, 45]
>>> random.shuffle(numbers)
>>> numbers
[23, 43, 65, 45, 12, 67]
3,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
6,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
7, or
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
8.

ngẫu nhiên.getstate () ¶getstate()

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.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
7 để khôi phục trạng thái.

ngẫu nhiên.setstate (trạng thái) ¶setstate(state)

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

>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
6 và
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
7 khôi phục trạng thái bên trong của trình tạo về những gì nó đã được gọi là
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
6 được gọi.

Chức năng cho byte¶

ngẫu nhiên.randbytes (n) ¶randbytes(n)

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

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
1 thay thế.

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

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

ngẫu nhiên.randrange (dừng) ¶ ngẫu nhiên.randrange (bắt đầu, dừng [, bước])randrange(stop)random.randrange(start, stop[, step])

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

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
2. Điều này tương đương với
          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
3, nhưng không thực sự xây dựng một đối tượng phạm vi.

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

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
4. Không nên sử dụng đố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:

>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
9 tinh vi hơn về việc tạo ra các giá trị phân phối đều nhau. Trước đây, nó đã sử dụng một phong cách như
          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
6 có thể tạo ra các phân phối hơi không đồng đều.
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
9 is more sophisticated about producing equally distributed values. Formerly it used a style like
          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
6 which could produce slightly uneven distributions.

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

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
7 được chuyển đổi không mất khỏi
          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
8. Trong tương lai, điều này sẽ tăng
          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
9.The automatic conversion of non-integer types to equivalent integers is deprecated. Currently
          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
7 is losslessly converted to
          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
8. In the future, this will raise a
          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
9.

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ư

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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 hoặc
>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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 sẽ được thay đổi từ
>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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]
2 thành
          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
9.The exception raised for non-integral values such as
>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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 or
>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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 will be changed from
>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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]
2 to
          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
9.

ngẫu nhiên.randint (a, b) ¶randint(a, b)

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

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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]
4. Bí danh cho
>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

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

ngẫu nhiên.getrandbits (k) ¶getrandbits(k)

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.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
8 cho phép
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
9 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 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

Random.Choice (SEQ) ¶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

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

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

ngẫu nhiên.choices (dân số, trọng lượng = không, *, cum_weights = none, k = 1) ¶choices(population, weights=None, *, cum_weights=None, k=1)

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

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

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

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

>>> # 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 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958
0). Ví dụ, trọng số tương đối
>>> # Six roulette wheel spins (weighted sampling with replacement)
>>> choices(['red', 'black', 'green'], [18, 18, 2], k=6)
['red', 'green', 'black', 'black', 'red', 'black']

>>> # Deal 20 cards without replacement from a deck
>>> # of 52 playing cards, and determine the proportion of cards
>>> # with a ten-value:  ten, jack, queen, or king.
>>> dealt = sample(['tens', 'low cards'], counts=[16, 36], k=20)
>>> dealt.count('tens') / 20
0.15

>>> # Estimate the probability of getting 5 or more heads from 7 spins
>>> # of a biased coin that settles on heads 60% of the time.
>>> def trial():
...     return choices('HT', cum_weights=(0.60, 1.00), k=7).count('H') >= 5
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial():
...     return 2_500 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958
1 tương đương với trọng số tích lũy
>>> # 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 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958
2. Trong nội bộ, các 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 các lựa chọn, do đó, việc cung cấp các trọng số tích lũy tiết kiệm công việc.

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

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
9 để chỉ định cả trọng số và cum_ weights.

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ị

>>> numbers=[12,23,45,67,65,43]
>>> random.shuffle(numbers)
>>> numbers
[23, 12, 43, 65, 67, 45]
>>> random.shuffle(numbers)
>>> numbers
[23, 43, 65, 45, 12, 67]
3 được trả về bởi
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
0 (bao gồm số nguyên, phao và phân số nhưng không bao gồm số thập phân). Trọng lượng được coi là không âm và hữu hạn. A
>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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]
2 đượ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

>>> # 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 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958
7 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
>>> # 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 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958
8. Thuật toán được sử dụng bởi
>>> # Six roulette wheel spins (weighted sampling with replacement)
>>> choices(['red', 'black', 'green'], [18, 18, 2], k=6)
['red', 'green', 'black', 'black', 'red', 'black']

>>> # Deal 20 cards without replacement from a deck
>>> # of 52 playing cards, and determine the proportion of cards
>>> # with a ten-value:  ten, jack, queen, or king.
>>> dealt = sample(['tens', 'low cards'], counts=[16, 36], k=20)
>>> dealt.count('tens') / 20
0.15

>>> # Estimate the probability of getting 5 or more heads from 7 spins
>>> # of a biased coin that settles on heads 60% of the time.
>>> def trial():
...     return choices('HT', cum_weights=(0.60, 1.00), k=7).count('H') >= 5
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial():
...     return 2_500 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958
7 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
>>> # 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 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958
8 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

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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]
2 nếu tất cả các trọng số bằng không.Raises a
>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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]
2 if all weights are zero.

ngẫu nhiên.shuffle (x) ¶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ả lại một danh sách được xáo trộn mới, hãy sử dụng

# https://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}')
2 thay thế.

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

# https://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}')
3 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, bị xóa trong phiên bản 3.11: Tham số tùy chọn ngẫu nhiên.The optional parameter random.

ngẫu nhiên.sample (dân số, k, *, số lượng = không) ¶sample(population, k, *, counts=None)

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

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

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

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

# https://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}')
4 tương đương với
# https://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}')
5.

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

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha
4 làm đối số. Điều này đặc biệt nhanh chóng và hiệu quả không gian để lấy mẫu từ một dân số lớn:
# https://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}')
7.

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

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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]
2 sẽ được nâng lên.

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

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

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

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

ngẫu nhiên.random () ¶random()

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

ngẫu nhiên.uniform (a, b) ¶uniform(a, b)

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

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> 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]
4 cho
# 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.')
0 và
# 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.')
1 cho
# 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.')
2.

Giá trị điểm cuố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.')
3 có thể hoặc không được đưa vào phạm vi tùy thuộc vào việc làm tròn điểm nổi trong phương trì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.')
4.

ngẫu nhiên.triangular (thấp, cao, chế độ) ¶triangular(low, high, mode)

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

# 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.')
5 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 đến điểm giữa giữa các giới hạn, đưa ra phân phối đối xứng.

ngẫu nhiên.betavariate (alpha, beta) ¶betavariate(alpha, beta)

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

# 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.')
6 và
# 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. Giá trị trả về nằm trong khoảng từ 0 đến 1.

ngẫu nhiên.expovariate (Lambd) ¶expovariate(lambd)

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

ngẫu nhiên.gammavariate (alpha, beta) ¶gammavariate(alpha, beta)

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

# 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.')
6 và
# 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.

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) ¶gauss(mu=0.0, sigma=1.0)

Phân phối bình thường, còn được gọi là phân phối Gaussian. MU là 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

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
00 được xác định dưới đây.

Lưu ý đa luồng: Khi hai luồng gọi chức năng này đồng thời, có thể họ 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) Có mỗi luồng sử dụng một thể hiệ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 đó, sử dụng chức năng chậm hơn, nhưng an toàn

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
00.

Đã thay đổi trong phiên bản 3.11: MU và Sigma hiện có các đối số mặc định.mu and sigma now have default arguments.

Random.LognorMvariate (MU, Sigma) ¶lognormvariate(mu, sigma)

Phân phối lognormal. Nếu bạn lấy logarit tự nhiên của phân phối này, bạn sẽ nhận được một phân phối bình thường với MU trung bình và độ 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ênnormalvariate(mu=0.0, sigma=1.0)

Phân phối bình thường. MU là 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ó các đối số mặc định.mu and sigma now have default arguments.

Random.LognorMvariate (MU, Sigma) ¶vonmisesvariate(mu, kappa)

Phân phối lognormal. Nếu bạn lấy logarit tự nhiên của phân phối này, bạn sẽ nhận được một phân phối bình thường với MU trung bình và độ 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ênparetovariate(alpha)

Phân phối bình thường. MU là trung bình, và Sigma là độ lệch chuẩn.

ngẫu nhiên.vonmisevariate (MU, Kappa) ¶weibullvariate(alpha, beta)

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 độ, phải lớn hơn hoặc bằng không. Nếu kappa bằng 0, phân phối này sẽ giảm xuống góc ngẫu nhiên đồng đều trong phạm vi 0 đến 2*pi.

ngẫu nhiên.paretovariate (alpha) ¶

Phân phối Pareto. Alpha là tham số hình dạng. random.Random([seed])

ngẫu nhiên.weibullvariate (alpha, beta) ¶

Đã không dùng nữa kể 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:

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
03,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
9,
>>> numbers=[12,23,45,67,65,43]
>>> random.shuffle(numbers)
>>> numbers
[23, 12, 43, 65, 67, 45]
>>> random.shuffle(numbers)
>>> numbers
[23, 43, 65, 45, 12, 67]
3,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
6,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
7 hoặc
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
8.In the future, the seed must be one of the following types:
>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
03,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
9,
>>> numbers=[12,23,45,67,65,43]
>>> random.shuffle(numbers)
>>> numbers
[23, 12, 43, 65, 67, 45]
>>> random.shuffle(numbers)
>>> numbers
[23, 43, 65, 45, 12, 67]
3,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
6,
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
7, or
>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
8.

classRandom.SystemRandom ([hạt giống]) ¶ random.SystemRandom([seed])

Lớp sử dụng hàm

>>> import random
>>> random.choice('computer')
't'          
>>> random.choice([12,23,45,67,65,43])
45           
>>> random.choice((12,23,45,67,65,43))
67
2 để tạo số ngẫu nhiên từ các nguồn được cung cấp bởi hệ điều hành. Không có sẵn trên tất cả các hệ thống. Không dựa vào trạng thái phần mềm và các chuỗi không thể tái sản xuất. Theo đó, phương pháp
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
5 không có hiệu lực và bị bỏ qua. Các phương pháp
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
6 và
>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
7 tăng
>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
13 nếu được gọi.

Ghi chú về khả năng tái sản xuất

Đôi khi rất hữu ích để có thể tái tạo các chuỗi được đưa ra bởi một trình tạo số giả giả. Bằng cách sử dụng lại giá trị hạt giống, chuỗi tương tự phải được tái tạo từ chạy để chạy 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 ngẫu nhiên đều có thể thay đổi trên 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 của máy phát điện ____ ____ ____ sẽ tiếp tục tạo ra cùng một chuỗi khi máy gieo hạt 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 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

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

Simulations:

>>> # 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 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958

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

# https://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ề thử nghiệm hoán vị lấy mẫu để 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 các 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à giao hàng dịch vụ cho hàng đợi Multiserver:

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
0

Xem thêm

Thống kê cho tin tặc Hướng dẫn video 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ộ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, đồng phục, mẫu, betavariate, lựa chọn, hình tam giác và randrange).

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 của 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¶

Những 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 lặp kết hợp trong mô -đun

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
15:

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
1

>>> random.randrange(1, 10)
2
>>> random.randrange(1, 10, 2)
5            
>>> random.randrange(0, 101, 10)
80
0 mặc định trả về bội số của 2⁻⁵³ trong phạm vi 0,0 x <1.0. Tất cả những con số như vậy đều có khoảng cách đồng đều và có thể thể hiện chính xác như những chiếc phao python. Tuy nhiên, nhiều chiếc phao có thể đại diện khác trong khoảng đó là không thể lựa chọn. Ví dụ,
>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
17 là một số nguyên của 2⁻⁵³.

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

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
2

Tất cả các phân phối có giá trị thực trong lớp sẽ sử dụng phương thức mới:real valued distributions in the class will use the new method:

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
3

Công thức tương đương về mặt khái niệm 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ả những con số như vậy đều cách đều nhau, nhưng hầu hết phải được làm tròn xuống phao python có thể đại diện gần nhất. (Giá trị 2⁻⁻ là phao không định kỳ dương nhỏ nhất và bằng

>>> import random
>>> random.randint(1, 100)
95           
>>> random.randint(1, 100)
49
18.)