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