我可以用 python 生成真实的随机数吗？

Question

I'm learning random module of python. And I know it generates pseudo random number. Which its core idea is to use a high-frequency clock as a seed and then use a function to produce a 'looking-like random number.

As I know it's even impossible to produce authentic random number in the real world.

But I know Unix random producer has introduced some other factors such as the parameter of mouse-movement track, the IO response time, to introduce uncertainty to its random number producer function. Through which we can get a better random number than normal pseudo random number. It's much more harder to predict.

So, is there a way that in python we can produce such a random number, or maybe import a good third party library?

Answer 1

The documentation for the random module has this to say:

Warning : The pseudo-random generators of this module should not be used for security purposes. Use os.urandom() or SystemRandom if you require a cryptographically secure pseudo-random number generator.

Answer 2

Truly random numbers can be generated from

https://pypi.python.org/pypi/quantumrandom/

pip install quantumrandom

Currently you are limited to blocks of 1024 but with a bit of simple programming and a little bit of time you will be able to extend this limit to a large enough sample for most applications.

Answer 3

https://www.random.org/integers/
https://api.random.org/json-rpc/1/

This website generates random numbers through atmospheric white noise, which is better than pseudo random numbers for use with development, You can also use there API for automated random numbers (Though it won't be free for long as it's currently in beta.)

Another method of obtaining true random numbers is through the quantum random number generator, http://photonics.anu.edu.au/qoptics/Research/qrng.php .

To reiterate what someone said earlier, you should avoid using computationally made pseudo random numbers for security purposes.

Answer 4

Python has nothing that allows you to generate "truly random" or "authentic random" numbers, in the sense that they are uniformly distributed and independent of everything else (especially the latter).

In any case, the distinction between "pseudorandom" and "truly random" numbers is not what applications care about. Rather, the requirements for randomness depend on the application, and you didn't really specify what kind of application you have in mind. For example, in general:

• Security applications care whether the numbers are hard to guess; in this case, only a cryptographic RNG can achieve this requirement (even one that relies on a pseudorandom number generator). A Python example is the secrets module or random.SystemRandom .
• Scientific simulations care whether the numbers behave like independent uniform random numbers, and often care whether the numbers are reproducible at a later time. A Python example is numpy.random.Generator or random.Random .

See also these questions:

• Checking noise in binary sequence for randomness
• How to get truly random data, not random data fed into a PRNG seed like CSRNG's do?

Answer 5

I think this works:

def get_truly_random_seed_through_os() -> int:
    """
    Usually the best random sample you could get in any programming language is generated through the operating system. 
    In Python, you can use the os module.

    source: https://stackoverflow.com/questions/57416925/best-practices-for-generating-a-random-seeds-to-seed-pytorch/57416967#57416967
    """
    RAND_SIZE = 4
    random_data = os.urandom(
        RAND_SIZE
    )  # Return a string of size random bytes suitable for cryptographic use.
    random_seed: int = int.from_bytes(random_data, byteorder="big")
    return int(random_seed)

if you only want different seeds you can do:

def get_different_pseudo_random_seed_every_time_using_time() -> int:
    import random
    import time

    # random.seed(int(time.time()))
    seed: int = int(time.time())
    return seed