A pseudo-random number generator can be modelled as an infinite stream of bits. Every time you generate a number using the pseudo-random number generator, it shifts the stream along, returning and discarding the bits at the beginning. Seeding the PRNG discards the current stream and selects the one specified by the seed.

Each time you generate a number from the PRNG, _that many bits are removed from it_. This means that the PRNG states changes each time you generate a number from it. If you don't reset the PRNG's state by re-seeding it, it'll be a while (centuries) before its output repeats.

There is a workaround: create a new PRNG each time.

    import numpy as np
    
    np.random.RandomSeed(43).normal(0, 1, 20)

You could create a convenience function:

    def pseudorandom(seed):
        return np.random.RandomSeed(seed)
    
    pseudorandom(43).normal(0, 1, 20)

Note that if you are repeatedly re-seeding your PRNG, it will **not give you secure numbers** (not that this PRNG is secure _anyway_). They might _look_ random, but they're very predictable; all you need to guess is the seed. To be on the safe side, treat them like they are _entirely_ predictable.

I would like to tie up the answer from WizzWizz 4, with the example from NumPy documentation.

So, the preferred method to seed the sequence is the following:


```
from numpy.random import MT19937
from numpy.random import RandomState, SeedSequence

def seed(x):
    return RandomState(MT19937(SeedSequence(x)))
seed(42).normal(0,1,10)
```

I still don't know what's MT19937, but from a practical POV, I think I'm satisfied. That's not to say that if you know more, you don't need to share... You're welcome to share. Thanks ;)

If you're using this for testing purposes, then a _terrible_ **never use in production ever** solution:

```python
@getattr((lambda TODO: TODO("FIXME: Delete me _")), '__call__')
def DebugOnly_prng_OVERRIDE(comment_me_out_please):
    # BUG: Will completely break randomness
    # FIXME: Render this code non-functional
    # HACK: Monkeypatches numpy.random, breaking it
    # XXX: considered harmful
    """This code should not run. Delete it if it does.

    >>> 2 + 2
    5
    """
    from functools import wraps
    from numpy import random
    exec("random._RESEED_VALUE = 0")

    real_seed = random.seed

    def override(f):
        @wraps(f)
        def g(*args, **kwargs):
            real_seed(random._RESEED_VALUE)
            return f(*args, **kwargs)
        return g

    if type(real_seed) is type(override):
        # This has already run (or it's not CPython)
        return

    if not __debug__:
        raise RuntimeError("Bad code made it to optimisation.")
    for name in set(dir(random.RandomState)) & set(dir(random)):
        if name[0] != comment_me_out_please[-1]:
            setattr(random, name, override(getattr(random, name)))

    @wraps(real_seed)
    def seed(seed):
        random._RESEED_VALUE = seed
        real_seed(seed)
    random.seed = seed
```

This monkeypatches the `numpy.random` module, letting you use your original code _verbatim_ with the behaviour you expect. This is _not the behaviour any other code expects_, and this is a _global override_, so things will break in subtle ways if you put this in production. (I've tried to make it break more explicitly, but don't rely on that.)