Trình chuyển đổi python sang mã giả

Question

Mô-đun và công cụ dòng lệnh

$ vc2-pseudocode-to-python input.pc output.py

21 tự động dịch danh sách mã giả sang Python hợp lệ

Nội dung chính Show

Tiện ích dòng lệnh
Ngẫu nhiên là ngẫu nhiên như thế nào?
“Bảo mật bằng mật mã” là gì?
Những gì bạn sẽ trình bày ở đây
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
PRNG 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
CSPRNG 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
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
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
Tại sao không chỉ “Mặc định là” $ vc2-pseudocode-to-python input.pc output.py 311?
Vụn vặt. băm
Tóm tắt lại
Liên kết bổ sung

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

$ vc2-pseudocode-to-python input.pc output.py

21 đượ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.py

23 (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 str

Mã nguồn mã giả để dịch

thụt lề str

Chuỗ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 bool

Nế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 bool

Nế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"] += 1

0

Đừ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"] += 1

2

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"] += 1

30, 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

>>> 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 từ thư viện chuẩn của Python và đối tác NumPy dựa trên mảng của 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"] += 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

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"] += 1

38 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"] += 1

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

3

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"] += 1

38, 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"] += 1

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

83. Đ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"] += 1

3

Với

$ vc2-pseudocode-to-python input.pc output.py

84, 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.py

8

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

85, 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.py

86. Ngoài ra còn có

$ vc2-pseudocode-to-python input.pc output.py

87 để 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.py

88

>>>

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

Bạ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.py

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

0

Nế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ách

Trướ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à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"] += 1

20

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

87 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ỉ định

Nguồ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ác

Hã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"] += 1

21

Đố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ên

Loại bỏ các quảng cáo

PRNG 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"] += 1

22

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"] += 1

32 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"] += 1

32 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"] += 1

38 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"] += 1

23

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"] += 1

24

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ác

Mộ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"] += 1

25

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"] += 1

26

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"] += 1

27

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"] += 1

28

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"] += 1

32 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"] += 1

204Số 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"] += 1

206Số 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"] += 1

208Phầ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"] += 1

210

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

211Phầ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"] += 1

210 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"] += 1

215 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"] += 1

217Phầ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"] += 1

210 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"] += 1

2202 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"] += 1

2202

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áo

CSPRNG 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"] += 1

230 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ên

Trê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"] += 1

230, 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"] += 1

29

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"] += 1

238 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"] += 1

239. 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à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"] += 1

230 trả về một chuỗi các byte đơn

>>>

$ vc2-pseudocode-to-python input.pc output.py

30

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"] += 1

243 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

244 đề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.py

31

Đ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"] += 1

245, 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"] += 1

249 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"] += 1

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

32

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"] += 1

251, 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"] += 1

252, 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.py

33

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"] += 1

253 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"] += 1

254. 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"] += 1

252 đượ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"] += 1

256 đạ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"] += 1

257 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"] += 1

259 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"] += 1

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

34

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"] += 1

262 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"] += 1

238 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"] += 1

266) 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"] += 1

262 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"] += 1

268 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"] += 1

269. 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"] += 1

238 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"] += 1

238 đượ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"] += 1

230 đượ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"] += 1

39. 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"] += 1

276 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"] += 1

34, 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ùng

Loạ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"] += 1

34 đượ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"] += 1

34 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"] += 1

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

35

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

36

Đâ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.py

37

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"] += 1

282 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"] += 1

283, 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"] += 1

284 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"] += 1

285, 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"] += 1

34 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"] += 1

288 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"] += 1

35 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"] += 1

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

38

Đ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"] += 1

35 đề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"] += 1

294, 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"] += 1

295,

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

296 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

297

>>>

$ vc2-pseudocode-to-python input.pc output.py

39

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"] += 1

298,

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. 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"] += 1

288 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"] += 1

288 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"] += 1

230, 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.py

307 hoặc 340 tỷ tỷ giá trị

$ vc2-pseudocode-to-python input.pc output.py

308. 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"] += 1

35 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ình

Loạ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"] += 1

34, 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"] += 1

230. (

$ vc2-pseudocode-to-python input.pc output.py

311, 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"] += 1

34. Tất cả chỉ là một trang web có nguồn gốc từ

$ vc2-pseudocode-to-python input.pc output.py

318. )

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

320, 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"] += 1

205 bằng cách sử dụng

$ vc2-pseudocode-to-python input.pc output.py

322 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

0

Bâ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

1

Sự 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.py

323 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ô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

32Giố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ô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

33Chứa

$ vc2-pseudocode-to-python input.pc output.py

318, 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"] += 1

34Đượ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"] += 1

35Trang 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

>>> 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ó một số thủ thuật bổ sung

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ề Brad

Mỗ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ẻ Email

Bà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

programming python

Trình chuyển đổi python sang mã giả

Tiện ích dòng lệnh

API Python

Ngẫu nhiên là ngẫu nhiên như thế nào?

“Bảo mật bằng mật mã” là gì?

Những gì bạn sẽ trình bày ở đây

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

PRNG 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

CSPRNG 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

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

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

Tại sao không chỉ “Mặc định là” $ vc2-pseudocode-to-python input.pc output.py 311?

Vụn vặt. băm

Tóm tắt lại

Liên kết bổ sung

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội