Mô-đun và công cụ dòng lệnh
$ vc2-pseudocode-to-python input.pc output.py21 tự động dịch danh sách mã giả sang Python hợp lệ
Nói chung, bản dịch giữa mã giả và Python là 'hiển nhiên'. Có lẽ, phần không rõ ràng duy nhất là các nhãn được dịch sang chuỗi ký tự Python. Đầu ra được in đẹp theo kiểu tương tự như kiểu Mã đen với các nhận xét và khoảng trắng dọc được giữ lại [theo kiểu bán chuẩn hóa]
Ví dụ, đoạn mã giả sau
add[a, b, c]: # A function which adds three numbers together total = 0 # An accumulator for each n in a, b, c: total += n return total update_state[state]: state[count] += 1
Được dịch trong Python sau
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1
Tiện ích dòng lệnh
Tiện ích dòng lệnh
$ vc2-pseudocode-to-python input.pc output.py21 được cung cấp có thể chuyển đổi danh sách mã giả thành Python
Ví dụ sử dụng
$ vc2-pseudocode-to-python input.pc output.py
API Python
Chức năng tiện ích có thể được sử dụng để dịch trực tiếp mã giả sang Python
$ vc2-pseudocode-to-python input.pc output.py23 [pseudocode_source , thụt lề=' ', generate_docstrings=True, add_translation_note=False]
Chuyển đổi danh sách mã giả thành Python
Sẽ đưa ra hoặc nếu mã giả được cung cấp có lỗi cú pháp
Tham sốpseudocode_source strMã nguồn mã giả để dịch
thụt lề strChuỗi sử dụng để thụt đầu dòng trong mã nguồn Python đã tạo. Mặc định là bốn khoảng trắng
generate_docstrings boolNếu True, khối nhận xét đầu tiên trong tệp và từng chức năng sẽ được chuyển đổi thành chuỗi tài liệu. Nếu không, họ sẽ để lại như bình luận bình thường. Mặc định là True
add_translation_note boolNếu Đúng, hãy thêm nhận xét vào đầu kết quả được tạo cho biết rằng tệp này được dịch tự động từ mã giả. Mặc định là Sai
Ngẫu nhiên là ngẫu nhiên như thế nào? . Bất cứ khi nào bạn đang tạo dữ liệu, chuỗi hoặc số ngẫu nhiên trong Python, bạn nên có ít nhất một ý tưởng sơ bộ về cách dữ liệu đó được tạo
Tại đây, bạn sẽ đề cập đến một số tùy chọn khác nhau để tạo dữ liệu ngẫu nhiên trong Python, sau đó xây dựng để so sánh từng tùy chọn về mức độ bảo mật, tính linh hoạt, mục đích và tốc độ của nó
Tôi hứa rằng hướng dẫn này sẽ không phải là một bài học về toán học hay mật mã, những thứ mà ngay từ đầu tôi đã không được trang bị tốt để giảng bài. Bạn sẽ học toán nhiều như cần thiết, và không còn nữa
Ngẫu nhiên là ngẫu nhiên như thế nào?
Đầu tiên, một tuyên bố từ chối trách nhiệm nổi bật là cần thiết. Hầu hết dữ liệu ngẫu nhiên được tạo bằng Python không hoàn toàn ngẫu nhiên theo nghĩa khoa học của từ này. Thay vào đó, nó là giả ngẫu nhiên. được tạo bằng trình tạo số giả ngẫu nhiên [PRNG], về cơ bản là bất kỳ thuật toán nào để tạo dữ liệu có vẻ ngẫu nhiên nhưng vẫn có thể tái tạo
Các số ngẫu nhiên “đúng” có thể được tạo bởi, bạn đoán xem, một bộ tạo số ngẫu nhiên thực [TRNG]. Một ví dụ là liên tục nhặt một con súc sắc trên sàn, tung nó lên không trung và để nó tiếp đất theo cách nó có thể.
Giả sử rằng cú tung của bạn không thiên vị, bạn thực sự không biết con súc sắc sẽ rơi vào số nào. Tung xúc xắc là một hình thức sử dụng phần cứng thô sơ để tạo ra một con số không mang tính quyết định. [Hoặc, bạn có thể nhờ xúc xắc làm việc này cho bạn. ] TRNG nằm ngoài phạm vi của bài viết này nhưng dù sao cũng đáng được đề cập để so sánh
PRNG, thường được thực hiện bằng phần mềm thay vì phần cứng, hoạt động hơi khác một chút. Đây là một mô tả ngắn gọn
Họ bắt đầu với một số ngẫu nhiên, được gọi là hạt giống, sau đó sử dụng thuật toán để tạo chuỗi bit giả ngẫu nhiên dựa trên nó. [Nguồn]
Bạn có thể đã được yêu cầu “đọc tài liệu. " tại một số điểm. Chà, những người đó không sai. Đây là một đoạn đặc biệt đáng chú ý từ tài liệu của mô-đun
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 mà bạn không muốn bỏ lỡ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. [Nguồn]
Bạn có thể đã thấy
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
3, >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
4 hoặc tương tự như vậy trong Python. Lệnh gọi hàm này đang khởi tạo trình tạo số ngẫu nhiên cơ bản được sử dụng bởi mô-đun >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 của Python. Đó là những gì làm cho các cuộc gọi tiếp theo để tạo các số ngẫu nhiên mang tính xác định. đầu vào A luôn tạo ra đầu ra B. Phước lành này cũng có thể là một lời nguyền nếu nó được sử dụng ác ýCó lẽ thuật ngữ “ngẫu nhiên” và “tất định” dường như không thể tồn tại cạnh nhau. Để làm cho điều đó rõ ràng hơn, đây là một phiên bản rút gọn của
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
6 lặp đi lặp lại tạo ra một số "ngẫu nhiên" bằng cách sử dụng >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
7. >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
8 ban đầu được định nghĩa là một giá trị hạt giống và sau đó biến thành một chuỗi số xác định dựa trên hạt giống đódef add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 10
Đừng lấy ví dụ này theo nghĩa đen, vì nó chủ yếu nhằm minh họa khái niệm. Nếu bạn sử dụng giá trị khởi đầu 1234, chuỗi lệnh gọi tiếp theo tới
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
6 phải luôn giống hệt nhau>>>
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 12
Bạn sẽ sớm thấy một minh họa nghiêm túc hơn về điều này
Loại bỏ các quảng cáo“Bảo mật bằng mật mã” là gì?
Nếu bạn chưa có đủ với các từ viết tắt của RNG RNG, hãy thêm một từ nữa vào hỗn hợp. CSPRNG hoặc PRNG bảo mật bằng mật mã. CSPRNG phù hợp để tạo dữ liệu nhạy cảm như mật khẩu, trình xác thực và mã thông báo. Đưa ra một chuỗi ngẫu nhiên, thực tế không có cách nào để Malicious Joe xác định chuỗi nào xuất hiện trước hoặc sau chuỗi đó trong một chuỗi các chuỗi ngẫu nhiên
Một thuật ngữ khác mà bạn có thể thấy là entropy. Tóm lại, điều này đề cập đến mức độ ngẫu nhiên được giới thiệu hoặc mong muốn. Ví dụ: một Python mà bạn sẽ đề cập ở đây xác định
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 130, số byte sẽ trả về theo mặc định. Các nhà phát triển cho rằng đây là byte "đủ" để tạo ra đủ tiếng ồn
Ghi chú. Thông qua hướng dẫn này, tôi giả sử rằng một byte đề cập đến 8 bit, như nó đã có từ những năm 1960, chứ không phải là một số đơn vị lưu trữ dữ liệu khác. Bạn có thể gọi đây là một octet nếu bạn thích
Một điểm quan trọng về CSPRNG là chúng vẫn là giả ngẫu nhiên. Chúng được thiết kế theo cách nào đó mang tính tất định nội bộ, nhưng chúng thêm một số biến khác hoặc có một số thuộc tính khiến chúng “đủ ngẫu nhiên” để cấm sao lưu vào bất kỳ chức năng nào thực thi thuyết tất định
Những gì bạn sẽ trình bày ở đây
Về mặt thực tế, điều này có nghĩa là bạn nên sử dụng PRNG đơn giản để lập mô hình thống kê, mô phỏng và để tái tạo dữ liệu ngẫu nhiên. Chúng cũng nhanh hơn đáng kể so với CSPRNG, như bạn sẽ thấy ở phần sau. Sử dụng CSPRNG cho các ứng dụng bảo mật và mật mã khi bắt buộc phải có độ nhạy của dữ liệu
Ngoài việc mở rộng các trường hợp sử dụng ở trên, trong hướng dẫn này, bạn sẽ đi sâu vào các công cụ Python để sử dụng cả PRNG và CSPRNG
- Các tùy chọn PRNG bao gồm mô-đun
2 từ thư viện chuẩn của Python và đối tác NumPy dựa trên mảng của nó,>>> random.seed[444] >>> random.random[] 0.3088946587429545 >>> random.random[] 0.01323751590501987 >>> random.seed[444] # Re-seed >>> random.random[] 0.3088946587429545 >>> random.random[] 0.01323751590501987
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1
32 - Các mô-đun
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1
33,def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1
34 vàdef add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1
35 của Python chứa các hàm để tạo các đối tượng bảo mật bằng mật mã
Bạn sẽ chạm vào tất cả những điều trên và kết thúc bằng một so sánh cấp cao
PRNG trong Python
Mô-đun >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
Có lẽ công cụ được biết đến rộng rãi nhất để tạo dữ liệu ngẫu nhiên trong Python là mô-đun
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 của nó, sử dụng thuật toán Mersenne Twister PRNG làm trình tạo cốt lõi của nóTrước đó, bạn đã chạm nhẹ vào
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 138 và bây giờ là thời điểm tốt để xem nó hoạt động như thế nào. Trước tiên, hãy xây dựng một số dữ liệu ngẫu nhiên mà không cần gieo hạt. Hàm
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 139 trả về một số float ngẫu nhiên trong khoảng [0. 0, 1. 0]. Kết quả sẽ luôn nhỏ hơn điểm cuối bên phải [1. 0]. Đây còn được gọi là phạm vi bán mở
>>>
$ vc2-pseudocode-to-python input.pc output.py3
Nếu bạn tự chạy mã này, tôi cá rằng số tiền tiết kiệm cả đời của tôi sẽ được trả về trên máy của bạn sẽ khác. Khi bạn không khởi tạo trình tạo là sử dụng thời gian hệ thống hiện tại của bạn hoặc "nguồn ngẫu nhiên" từ hệ điều hành của bạn nếu có sẵn
Với
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 138, bạn có thể tái tạo kết quả và chuỗi cuộc gọi sau
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 138 sẽ tạo ra cùng một chuỗi dữ liệu
>>>
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
Lưu ý sự lặp lại của các số "ngẫu nhiên". Chuỗi số ngẫu nhiên trở nên xác định hoặc hoàn toàn được xác định bởi giá trị hạt giống, 444
Chúng ta hãy xem một số chức năng cơ bản hơn của
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2. Ở trên, bạn đã tạo một số float ngẫu nhiên. Bạn có thể tạo một số nguyên ngẫu nhiên giữa hai điểm cuối trong Python bằng hàm $ vc2-pseudocode-to-python input.pc output.py83. Điều này kéo dài toàn bộ khoảng thời gian [x, y] và có thể bao gồm cả hai điểm cuối
>>>
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 13
Với
$ vc2-pseudocode-to-python input.pc output.py84, bạn có thể loại trừ phía bên phải của khoảng, nghĩa là số được tạo luôn nằm trong [x, y] và sẽ luôn nhỏ hơn điểm cuối bên phải
>>>
$ vc2-pseudocode-to-python input.pc output.py8
Nếu bạn cần tạo số float ngẫu nhiên nằm trong khoảng [x, y] cụ thể, bạn có thể sử dụng
$ vc2-pseudocode-to-python input.pc output.py85, lấy từ phân phối đồng đều liên tục
>>>
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
3Để chọn một phần tử ngẫu nhiên từ một chuỗi không trống [như danh sách hoặc bộ dữ liệu], bạn có thể sử dụng
$ vc2-pseudocode-to-python input.pc output.py86. Ngoài ra còn có
$ vc2-pseudocode-to-python input.pc output.py87 để chọn nhiều phần tử từ một chuỗi có thay thế [có thể trùng lặp]
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
6Để bắt chước lấy mẫu mà không cần thay thế, hãy sử dụng
$ vc2-pseudocode-to-python input.pc output.py88
>>>
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
8Bạn có thể chọn ngẫu nhiên một chuỗi tại chỗ bằng cách sử dụng
$ vc2-pseudocode-to-python input.pc output.py89. Điều này sẽ sửa đổi đối tượng trình tự và ngẫu nhiên hóa thứ tự của các phần tử
>>>
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
0Nếu bạn không muốn thay đổi danh sách ban đầu, trước tiên bạn cần tạo một bản sao và sau đó xáo trộn bản sao. Bạn có thể tạo các bản sao của danh sách Python bằng mô-đun
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
30 hoặc chỉ >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
31 hoặc >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
32, trong đó >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
8 là danh sáchTrước khi chuyển sang tạo dữ liệu ngẫu nhiên với NumPy, hãy xem xét thêm một ứng dụng có liên quan một chút. tạo ra một chuỗi các chuỗi ngẫu nhiên duy nhất có độ dài đồng đều
Nó có thể giúp suy nghĩ về thiết kế của chức năng đầu tiên. Bạn cần chọn từ một “nhóm” các ký tự như chữ cái, số và/hoặc dấu chấm câu, kết hợp chúng thành một chuỗi duy nhất, sau đó kiểm tra xem chuỗi này chưa được tạo chưa. Python
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
34 hoạt động tốt cho loại thử nghiệm thành viên nàydef add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 120
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
35 nối các chữ cái từ $ vc2-pseudocode-to-python input.pc output.py87 thành một mã Python duy nhất
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
37 có độ dài >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
38. Mã thông báo này được thêm vào tập hợp, không được chứa các bản sao và vòng lặp >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
39 thực thi cho đến khi tập hợp có số phần tử mà bạn chỉ địnhNguồn. Mô-đun
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
60 của Python chứa một số hằng số hữu ích. >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
61, >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
62, >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
63, >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
64, và một số ít người khácHãy thử chức năng này
>>>
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 121
Đối với phiên bản tinh chỉnh của chức năng này, câu trả lời Stack Overflow này sử dụng các hàm tạo, liên kết tên và một số thủ thuật nâng cao khác để tạo phiên bản
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
65 nhanh hơn, an toàn bằng mật mã ở trênLoại bỏ các quảng cáoPRNG cho mảng. def add[a, b, c]:
"""
A function which adds three numbers together
"""
total = 0 # An accumulator
for n in [a, b, c]:
total += n
return total
def update_state[state]:
state["count"] += 1
32
Một điều bạn có thể nhận thấy là phần lớn các hàm từ
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 trả về một giá trị vô hướng [một ________ 368, ________ 369 hoặc đối tượng khác]. Nếu bạn muốn tạo một chuỗi các số ngẫu nhiên, một cách để đạt được điều đó là hiểu danh sách Python>>>
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 122
Nhưng có một tùy chọn khác được thiết kế riêng cho việc này. Bạn có thể nghĩ gói
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 132 của riêng NumPy giống như gói
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 của thư viện chuẩn, nhưng đối với mảng NumPy. [Nó cũng được tải với khả năng rút ra từ nhiều phân phối thống kê hơn. ]Hãy lưu ý rằng
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 132 sử dụng PRNG của riêng nó, tách biệt với
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 cũ đơn giản. Bạn sẽ không tạo ra các mảng NumPy ngẫu nhiên một cách xác định bằng một lệnh gọi tới def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 138 của chính Python
>>>
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 123
Không có gì khó chịu, đây là một vài ví dụ để kích thích sự thèm ăn của bạn
>>>
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 124
Trong cú pháp của
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
85, các tham số >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
86 là tùy chọn và cho biết hình dạng của đối tượng cuối cùng. Ở đây, >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
87 tạo một mảng 2d với 3 hàng và 4 cột. dữ liệu sẽ là tôi. i. d. , nghĩa là mỗi điểm dữ liệu được vẽ độc lập với các điểm khácMột thao tác phổ biến khác là tạo một chuỗi các giá trị Boolean ngẫu nhiên,
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
88 hoặc >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
89. Một cách để làm điều này là với >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
00. Tuy nhiên, thực tế nhanh hơn khoảng 4 lần để chọn từ >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
01 và sau đó xem-truyền các số nguyên này thành các giá trị Boolean tương ứng của chúng>>>
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 125
Còn việc tạo dữ liệu tương quan thì sao? . Một cách để giải quyết vấn đề này là sử dụng chức năng của NumPy, tính đến ma trận hiệp phương sai. Nói cách khác, để rút ra từ một biến ngẫu nhiên phân phối bình thường, bạn cần chỉ định giá trị trung bình và phương sai [hoặc độ lệch chuẩn] của nó
Để lấy mẫu từ phân phối chuẩn đa biến, bạn chỉ định ma trận phương tiện và hiệp phương sai, và bạn sẽ có nhiều chuỗi dữ liệu tương quan, mỗi chuỗi được phân phối xấp xỉ chuẩn
Tuy nhiên, thay vì hiệp phương sai, tương quan là thước đo quen thuộc và trực quan hơn đối với hầu hết mọi người. Đó là hiệp phương sai được chuẩn hóa bằng tích của các độ lệch chuẩn và do đó bạn cũng có thể xác định hiệp phương sai theo tương quan và độ lệch chuẩn
Vì vậy, bạn có thể lấy các mẫu ngẫu nhiên từ phân phối chuẩn đa biến bằng cách chỉ định ma trận tương quan và độ lệch chuẩn không? . Ở đây, S là một vectơ của độ lệch chuẩn, P là ma trận tương quan của chúng và C là ma trận hiệp phương sai [hình vuông] kết quả
Điều này có thể được thể hiện bằng NumPy như sau
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 126
Bây giờ, bạn có thể tạo hai chuỗi thời gian tương quan nhưng vẫn ngẫu nhiên
>>>
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 127
Bạn có thể coi
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
03 là 500 cặp điểm dữ liệu tương quan nghịch. Dưới đây là kiểm tra độ chính xác mà bạn có thể quay lại các đầu vào ban đầu, xấp xỉ >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
04, >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
05 và >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
06 từ phía trên>>>
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 128
Trước khi chúng tôi chuyển sang CSPRNG, có thể hữu ích khi tóm tắt một số chức năng
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 và các đối tác def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 132 của chúng
Python
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 ModuleNumPy Đối tácSử dụng>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
6Trôi ngẫu nhiên trong [0. 0, 1. 0]______1202Số nguyên ngẫu nhiên trong [a, b]def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1204Số nguyên ngẫu nhiên trong [a,b]
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1206Số float ngẫu nhiên trong [a,b]
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1208Phần tử ngẫu nhiên từ
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1210
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1211Phần tử
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
38 ngẫu nhiên từ def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1210 có thay thế
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1215 với
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1217Phần tử ngẫu nhiên
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
38 từ def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1210 không thay thế
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 12202 hoặc xáo trộn
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 12202
Ghi chú. NumPy chuyên dùng để xây dựng và thao tác với các mảng lớn, đa chiều. Nếu bạn chỉ cần một giá trị duy nhất, thì
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 là đủ và có thể sẽ nhanh hơn nữa. Đối với các chuỗi nhỏ, >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 thậm chí có thể nhanh hơn, vì NumPy đi kèm với một số chi phíBây giờ bạn đã đề cập đến hai tùy chọn cơ bản cho PRNG, hãy chuyển sang một vài tùy chọn thích ứng an toàn hơn
Loại bỏ các quảng cáoCSPRNG trong Python
def add[a, b, c]:
"""
A function which adds three numbers together
"""
total = 0 # An accumulator
for n in [a, b, c]:
total += n
return total
def update_state[state]:
state["count"] += 1
230. Giới thiệu ngẫu nhiên như nó có được
Chức năng của Python được sử dụng bởi cả hai và [cả hai chức năng này bạn sẽ thấy ngay sau đây]. Không đi vào quá nhiều chi tiết,
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1230 tạo các byte ngẫu nhiên phụ thuộc vào hệ điều hành có thể được gọi là bảo mật bằng mật mã một cách an toàn
Trên các hệ điều hành Unix, nó đọc các byte ngẫu nhiên từ tệp đặc biệt
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1
235, từ đó “cho phép truy cập vào tiếng ồn môi trường được thu thập từ trình điều khiển thiết bị và các nguồn khác. ” [Cảm ơn, Wikipedia. ] Đây là thông tin bị cắt xén dành riêng cho trạng thái hệ thống và phần cứng của bạn tại một thời điểm nhất định nhưng đồng thời cũng đủ ngẫu nhiênTrên Windows, hàm C++
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1
236 được sử dụng. Hàm này về mặt kỹ thuật vẫn là giả ngẫu nhiên, nhưng nó hoạt động bằng cách tạo giá trị gốc từ các biến như ID tiến trình, trạng thái bộ nhớ, v.v.
Với
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1230, không có khái niệm gieo thủ công. Mặc dù về mặt kỹ thuật vẫn là giả ngẫu nhiên, chức năng này phù hợp hơn với cách chúng ta nghĩ về tính ngẫu nhiên. Đối số duy nhất là số lượng để trả về
>>>
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 129
Trước khi chúng ta tiếp tục, đây có thể là thời điểm tốt để đi sâu vào một bài học nhỏ về mã hóa ký tự. Nhiều người, bao gồm cả tôi, có một số phản ứng dị ứng khi họ nhìn thấy các đối tượng
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1238 và một hàng dài các ký tự
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1239. Tuy nhiên, thật hữu ích khi biết các chuỗi như
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
8 ở trên cuối cùng được chuyển thành chuỗi hoặc số như thế nàodef add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1230 trả về một chuỗi các byte đơn
>>>
$ vc2-pseudocode-to-python input.pc output.py30
Nhưng làm thế nào mà điều này cuối cùng lại biến thành một Python
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
37 hoặc một dãy số?Đầu tiên, hãy nhớ lại một trong những khái niệm cơ bản của điện toán, đó là một byte được tạo thành từ 8 bit. Bạn có thể coi một bit là một chữ số duy nhất là 0 hoặc 1. Một byte chọn một cách hiệu quả giữa 0 và 1 tám lần, vì vậy cả
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1243 và
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1244 đều có thể đại diện cho byte. Hãy thử điều này, sử dụng chuỗi f Python được giới thiệu trong Python 3. 6, trong thông dịch viên của bạn
>>>
$ vc2-pseudocode-to-python input.pc output.py31
Điều này tương đương với
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1245, với một số định dạng đặc biệt. chuyển đổi một số nguyên thành biểu diễn nhị phân của nó dưới dạng một chuỗi
Điều đó để chúng ta ở đâu? . [Không có ý định chơi chữ. ] Cho rằng chúng tôi được phép có 8 bit, mỗi bit có 2 lựa chọn, có thể có các tổ hợp _______1248 byte. ”
Điều này có nghĩa là mỗi byte ánh xạ tới một số nguyên từ 0 đến 255. Nói cách khác, chúng ta sẽ cần nhiều hơn 8 bit để biểu diễn số nguyên 256. Bạn có thể xác minh điều này bằng cách kiểm tra xem
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1249 hiện là 9 chứ không phải 8
Được rồi, bây giờ hãy quay lại kiểu dữ liệu
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1238 mà bạn đã thấy ở trên, bằng cách xây dựng một chuỗi các byte tương ứng với các số nguyên từ 0 đến 255
>>>
$ vc2-pseudocode-to-python input.pc output.py32
Nếu bạn gọi
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1251, bạn sẽ quay lại danh sách Python chạy từ 0 đến 255. Nhưng nếu bạn chỉ in
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1252, bạn sẽ nhận được một chuỗi trông xấu xí với đầy dấu gạch chéo ngược
>>>
$ vc2-pseudocode-to-python input.pc output.py33
Các dấu gạch chéo ngược này là các chuỗi thoát và
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1253 ký tự có giá trị hex
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1254. Một số thành phần của
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1252 được hiển thị theo nghĩa đen [các ký tự có thể in được như chữ cái, số và dấu chấm câu]. Hầu hết được thể hiện với lối thoát.
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1256 đại diện cho khoảng lùi của bàn phím, trong khi
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1257 là dấu xuống dòng [một phần của dòng mới, trên hệ thống Windows]
Nếu bạn cần xem lại hệ thập lục phân, Charles Petzold's Code. The Hidden Language là một nơi tuyệt vời cho điều đó. Hex là một hệ thống đánh số cơ số 16, thay vì sử dụng từ 0 đến 9, sử dụng từ 0 đến 9 và a đến f làm các chữ số cơ bản của nó
Cuối cùng, hãy quay lại nơi bạn đã bắt đầu, với chuỗi byte ngẫu nhiên
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
8. Hy vọng rằng điều này có ý nghĩa hơn một chút bây giờ. Gọi def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1259 trên một đối tượng
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1238 sẽ cho một
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
37 số thập lục phân, với mỗi số tương ứng với một số thập phân từ 0 đến 255>>>
$ vc2-pseudocode-to-python input.pc output.py34
Một câu hỏi cuối cùng. làm thế nào là
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1262 dài 12 ký tự ở trên, mặc dù
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
8 chỉ có 6 byte? . Phiên bản >>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
37 của def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1238 sẽ luôn dài gấp đôi tầm mắt của chúng ta
Ngay cả khi byte [chẳng hạn như
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1266] không cần biểu diễn đủ 8 bit, thì
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1262 sẽ luôn sử dụng hai chữ số hex trên mỗi byte, do đó, số 1 sẽ được biểu thị là
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1268 thay vì chỉ
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1269. Tuy nhiên, về mặt toán học, cả hai đều có cùng kích thước
Chi tiết kỹ thuật. Điều bạn chủ yếu mổ xẻ ở đây là làm thế nào một đối tượng
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1238 trở thành một
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
37 Python. Một tính kỹ thuật khác là làm thế nào def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1238 được tạo bởi
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1230 được chuyển đổi thành
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
69 trong khoảng thời gian [0. 0, 1. 0], như trong def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 139. Nếu bạn muốn khám phá thêm điều này, đoạn mã này sẽ minh họa cách
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1276 thực hiện chuyển đổi ban đầu thành số nguyên, sử dụng hệ thống đánh số cơ sở 256
Với điều đó trong vành đai của bạn, hãy chạm vào một mô-đun được giới thiệu gần đây,
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 134, mô-đun này giúp tạo mã thông báo bảo mật thân thiện hơn nhiều với người dùngLoại bỏ các quảng cáo
Python được giữ tốt nhất def add[a, b, c]:
"""
A function which adds three numbers together
"""
total = 0 # An accumulator
for n in [a, b, c]:
total += n
return total
def update_state[state]:
state["count"] += 1
34
Được giới thiệu trong Python 3. 6 bởi một trong những PEP nhiều màu sắc hơn hiện có, mô-đun
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 134 được dự định là mô-đun Python trên thực tế để tạo các chuỗi và byte ngẫu nhiên được bảo mật bằng mật mã
Bạn có thể kiểm tra mã nguồn của mô-đun, mã này ngắn và dễ hiểu với khoảng 25 dòng mã.
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 134 về cơ bản là một trình bao bọc xung quanh
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1230. Nó chỉ xuất một số hàm để tạo số, byte và chuỗi ngẫu nhiên. Hầu hết các ví dụ này nên khá tự giải thích
>>>
$ vc2-pseudocode-to-python input.pc output.py35
Bây giờ, làm thế nào về một ví dụ cụ thể? . com hay bit. ly biến một URL khó sử dụng thành một cái gì đó như https. //chút. ly/2IcCp9u. Hầu hết các trình rút gọn không thực hiện bất kỳ thao tác băm phức tạp nào từ đầu vào đến đầu ra;
Giả sử rằng sau khi xem Cơ sở dữ liệu vùng gốc, bạn đã đăng ký trang web ngắn. ly. Đây là một chức năng giúp bạn bắt đầu với dịch vụ của mình
$ vc2-pseudocode-to-python input.pc output.py36
Đây có phải là một minh họa thực tế đầy đủ? . Tôi sẽ đặt cược chút đó. ly thực hiện mọi thứ theo cách nâng cao hơn một chút so với việc lưu trữ mỏ vàng của nó trong từ điển Python toàn cầu không liên tục giữa các phiên
Ghi chú. Nếu bạn muốn xây dựng một công cụ rút ngắn URL chính thức của riêng mình, thì hãy xem Xây dựng một công cụ rút ngắn URL với FastAPI và Python
Tuy nhiên, nó gần như chính xác về mặt khái niệm
>>>
$ vc2-pseudocode-to-python input.pc output.py37
Giữ lấy. Một điều bạn có thể nhận thấy là cả hai kết quả này đều có độ dài 7 khi bạn yêu cầu 5 byte. Đợi đã, tôi nghĩ rằng bạn nói rằng kết quả sẽ dài gấp đôi? . Có một điều nữa đang xảy ra ở đây.
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1282 sử dụng mã hóa base64, trong đó mỗi ký tự là 6 bit dữ liệu. [Đó là từ 0 đến 63 và các ký tự tương ứng. Các ký tự là A-Z, a-z, 0-9 và +/. ]
Nếu ban đầu bạn chỉ định một số byte nhất định
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1283, thì độ dài kết quả từ
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1284 sẽ là
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1285, bạn có thể chứng minh và điều tra thêm nếu tò mò
Điểm mấu chốt ở đây là, trong khi
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 134 thực sự chỉ là một trình bao bọc xung quanh các hàm Python hiện có, thì nó có thể là mục tiêu của bạn khi bảo mật là mối quan tâm hàng đầu của bạn
Một ứng cử viên cuối cùng. def add[a, b, c]:
"""
A function which adds three numbers together
"""
total = 0 # An accumulator
for n in [a, b, c]:
total += n
return total
def update_state[state]:
state["count"] += 1
35
Một tùy chọn cuối cùng để tạo mã thông báo ngẫu nhiên là hàm
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1288 từ mô-đun
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 135 của Python. UUID là Mã định danh duy nhất toàn cầu, một chuỗi 128 bit [
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
37 có độ dài 32] được thiết kế để “đảm bảo tính duy nhất trong không gian và thời gian. ” def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1288 là một trong những chức năng hữu ích nhất của mô-đun và chức năng này
>>>
$ vc2-pseudocode-to-python input.pc output.py38
Điều thú vị là tất cả các hàm của
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 135 đều tạo ra một thể hiện của lớp
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1294, lớp này đóng gói ID và có các thuộc tính như
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1295,
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1296 và
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1297
>>>
$ vc2-pseudocode-to-python input.pc output.py39
Bạn cũng có thể đã thấy một số biến thể khác.
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1298,
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1299 và
$ vc2-pseudocode-to-python input.pc output.py300. Sự khác biệt chính giữa những chức năng này và
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1288 là ba chức năng đó đều có một số dạng đầu vào và do đó không đáp ứng định nghĩa về “ngẫu nhiên” trong phạm vi mà UUID phiên bản 4 đáp ứng
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1
298 sử dụng ID máy chủ của máy và thời gian hiện tại theo mặc định. Do sự phụ thuộc vào thời gian hiện tại xuống độ phân giải nano giây, phiên bản này là nơi UUID đưa ra tuyên bố “tính duy nhất được đảm bảo theo thời gian. ”def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1
299 và$ vc2-pseudocode-to-python input.pc output.py
300 đều nhận một định danh không gian tên và một tên. Cái trước sử dụng hàm băm MD5 và cái sau sử dụng SHA-1
Ngược lại,
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1288 hoàn toàn là giả ngẫu nhiên [hoặc ngẫu nhiên]. Nó bao gồm nhận 16 byte thông qua
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1230, chuyển đổi số này thành số nguyên lớn cuối và thực hiện một số thao tác theo bit để tuân thủ
Hy vọng rằng đến giờ bạn đã hiểu rõ về sự khác biệt giữa các “loại” dữ liệu ngẫu nhiên khác nhau và cách tạo chúng. Tuy nhiên, một vấn đề khác có thể xuất hiện trong đầu là va chạm
Trong trường hợp này, một xung đột chỉ đơn giản đề cập đến việc tạo hai UUID phù hợp. Cơ hội của điều đó là gì? . có thể có các giá trị
$ vc2-pseudocode-to-python input.pc output.py307 hoặc 340 tỷ tỷ giá trị
$ vc2-pseudocode-to-python input.pc output.py308. Vì vậy, tôi sẽ để bạn tự đánh giá xem điều này có đủ đảm bảo để có một giấc ngủ ngon hay không.
Một cách sử dụng phổ biến của
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 135 là ở Django, nơi có khóa thường được sử dụng làm khóa chính trong cơ sở dữ liệu quan hệ cơ bản của mô hìnhLoại bỏ các quảng cáo
Tại sao không chỉ “Mặc định là” $ vc2-pseudocode-to-python input.pc output.py
311?
Ngoài các mô-đun bảo mật được thảo luận ở đây, chẳng hạn như
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 134, mô-đun
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 của Python thực sự có một lớp ít được sử dụng có tên là sử dụng def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1230. [
$ vc2-pseudocode-to-python input.pc output.py311, ngược lại, cũng được sử dụng bởi
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 134. Tất cả chỉ là một trang web có nguồn gốc từ
$ vc2-pseudocode-to-python input.pc output.py318. ]
Tại thời điểm này, bạn có thể tự hỏi tại sao bạn không chỉ "mặc định" phiên bản này?
Tôi đã đề cập đến một lý do. đôi khi bạn muốn dữ liệu của mình mang tính xác định và có thể tái tạo để người khác theo dõi cùng
Nhưng lý do thứ hai là CSPRNG, ít nhất là trong Python, có xu hướng chậm hơn đáng kể so với PRNG. Hãy kiểm tra điều đó bằng một tập lệnh,
$ vc2-pseudocode-to-python input.pc output.py320, so sánh các phiên bản PRNG và CSPRNG của
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 1205 bằng cách sử dụng
$ vc2-pseudocode-to-python input.pc output.py322 của Python
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
0Bây giờ để thực hiện điều này từ trình bao
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
1Sự khác biệt về thời gian gấp 5 lần chắc chắn là một sự cân nhắc hợp lệ bên cạnh bảo mật bằng mật mã khi lựa chọn giữa hai
Vụn vặt. băm
Một khái niệm chưa được chú ý nhiều trong hướng dẫn này là băm, có thể được thực hiện với mô-đun
$ vc2-pseudocode-to-python input.pc output.py323 của Python
Băm được thiết kế để trở thành ánh xạ một chiều từ giá trị đầu vào sang chuỗi có kích thước cố định mà hầu như không thể đảo ngược kỹ thuật. Như vậy, mặc dù kết quả của hàm băm có thể “trông giống” dữ liệu ngẫu nhiên, nhưng nó không thực sự đủ điều kiện theo định nghĩa ở đây
Tóm tắt lại
Bạn đã bao phủ rất nhiều nền tảng trong hướng dẫn này. Tóm lại, đây là so sánh cấp cao về các tùy chọn có sẵn cho bạn về tính ngẫu nhiên kỹ thuật trong Python
Gói/Mô-đun Mô tả Bảo mật bằng mật mã
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2Dữ liệu ngẫu nhiên nhanh chóng và dễ dàng bằng cách sử dụng Mersenne TwisterKhôngdef add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 132Giống như
>>> random.seed[444]
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
>>> random.seed[444] # Re-seed
>>> random.random[]
0.3088946587429545
>>> random.random[]
0.01323751590501987
2 nhưng đối với các mảng [có thể là đa chiều]Khôngdef add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 133Chứa
$ vc2-pseudocode-to-python input.pc output.py318, cơ sở của các chức năng khác được đề cập ở đâyCó
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 134Được thiết kế để trở thành mô-đun thực tế của Python để tạo các số, byte và chuỗi ngẫu nhiên an toànCó
def add[a, b, c]: """ A function which adds three numbers together """ total = 0 # An accumulator for n in [a, b, c]: total += n return total def update_state[state]: state["count"] += 135Trang chủ cho một số chức năng cho
Vui lòng để lại một số nhận xét hoàn toàn ngẫu nhiên bên dưới và cảm ơn vì đã đọc
Liên kết bổ sung
- Ngẫu nhiên. org cung cấp “số ngẫu nhiên thực sự cho bất kỳ ai trên Internet” bắt nguồn từ tiếng ồn trong khí quyển
- Phần từ mô-đun
2 có một số thủ thuật bổ sung>>> random.seed[444] >>> random.random[] 0.3088946587429545 >>> random.random[] 0.01323751590501987 >>> random.seed[444] # Re-seed >>> random.random[] 0.3088946587429545 >>> random.random[] 0.01323751590501987
- Bài báo chuyên đề về Mersienne Twister xuất hiện vào năm 1997, nếu bạn thích loại điều đó
- Các hàm xác định để chọn ngẫu nhiên từ một tập hợp tổ hợp, chẳng hạn như từ các tổ hợp hoặc hoán vị
- bao gồm các trình tạo mẫu ngẫu nhiên khác nhau có thể được sử dụng để xây dựng các bộ dữ liệu nhân tạo có kích thước và độ phức tạp được kiểm soát
- Eli Bendersky đào sâu vào
$ vc2-pseudocode-to-python input.pc output.py
83 trong bài báo của anh ấy - Giới thiệu cụ thể về Xác suất bằng Python của Peter Norvig cũng là một tài nguyên toàn diện
- Thư viện Pandas bao gồm một thư viện có thể được sử dụng để đặt trạng thái ngẫu nhiên tạm thời
- Từ tràn ngăn xếp
- Tạo ngày ngẫu nhiên trong một phạm vi nhất định
- Cách nhanh nhất để tạo một chuỗi duy nhất giống như ngẫu nhiên với độ dài ngẫu nhiên
- Cách sử dụng
$ vc2-pseudocode-to-python input.pc output.py
89 trên máy phát điện - Thay thế các phần tử ngẫu nhiên trong một mảng NumPy
- Lấy số từ/dev/ngẫu nhiên trong Python
Đánh dấu là đã hoàn thành
Xem ngay Hướng dẫn này có một khóa học video liên quan do nhóm Real Python tạo. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn. Tạo dữ liệu ngẫu nhiên bằng Python
🐍 Thủ thuật Python 💌
Nhận một Thủ thuật Python ngắn và hấp dẫn được gửi đến hộp thư đến của bạn vài ngày một lần. Không có thư rác bao giờ. Hủy đăng ký bất cứ lúc nào. Được quản lý bởi nhóm Real Python
Gửi cho tôi thủ thuật Python »
Giới thiệu về Brad Solomon
Brad là một kỹ sư phần mềm và là thành viên của Nhóm hướng dẫn Python thực sự
» Thông tin thêm về BradMỗi hướng dẫn tại Real Python được tạo bởi một nhóm các nhà phát triển để nó đáp ứng các tiêu chuẩn chất lượng cao của chúng tôi. Các thành viên trong nhóm đã làm việc trong hướng dẫn này là
Adriana
Geir Arne
Joanna
Bậc thầy Kỹ năng Python trong thế giới thực Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng nghìn hướng dẫn, khóa học video thực hành và cộng đồng các Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bậc thầy Kỹ năng Python trong thế giới thực
Với quyền truy cập không giới hạn vào Python thực
Tham gia với chúng tôi và có quyền truy cập vào hàng ngàn hướng dẫn, khóa học video thực hành và cộng đồng Pythonistas chuyên gia
Nâng cao kỹ năng Python của bạn »
Bạn nghĩ sao?
Đánh giá bài viết này
Tweet Chia sẻ Chia sẻ EmailBài học số 1 hoặc điều yêu thích mà bạn đã học được là gì?
Mẹo bình luận. Những nhận xét hữu ích nhất là những nhận xét được viết với mục đích học hỏi hoặc giúp đỡ các sinh viên khác. và nhận câu trả lời cho các câu hỏi phổ biến trong cổng thông tin hỗ trợ của chúng tôi