Working with Loops

A New Value on Every Pass

A loop can call random.random() repeatedly so that each iteration receives a new pseudorandom float. The loop controls how many calls occur; random.random() supplies the value for each call. The values may look unpredictable, but they come from a deterministic sequence controlled by the random module's internal state.

import random

for _ in range(3):
    print(random.random())

This loop makes three calls to random.random(), one during each iteration. It therefore prints three floating-point values. The exact values are not specified in advance because they depend on the random module's current internal state.

Tracing the Loop State

The important state change is not a variable shown in the loop body. The random module maintains internal state. Each call advances that state, and the changed state determines the next value. The function does not remember previous calls itself; the module's internal state controls the sequence.

The Half-Open Output Range

The upper bound is exclusive: random.random() will not return exactly 1.0. This half-open range is useful when scaling the result. Multiplying by 100 produces a float in [0.0, 100.0). Multiplying by 6 and converting to an integer produces one of 0, 1, 2, 3, 4, or 5.

A Three-Iteration Trace

A useful trace records two things for every iteration: the iteration number and the value returned by that iteration's call. Do not expect a fixed list of literal values unless the seed and the number of earlier random calls are controlled.

Finding the Divergence Point

Suppose you expected the five-value sequence [0.1, 0.2, 0.3, 0.4, 0.5], but the loop produced [0.7, 0.8, 0.9, 0.6, 0.5]. The first divergence is at the first call: the generated value is 0.7 instead of 0.1. The divergence occurs at random.random(), where the pseudorandom value is generated, not elsewhere in the loop.

Reproducible Loop Runs

Use random.seed() before the loop when testing or debugging requires the same sequence to be reproduced. Setting the same seed before the same sequence of calls produces identical sequences. Without resetting the seed, repeated runs can produce different sequences.

import random

random.seed(10)
for _ in range(3):
    print(random.random())

The important behavior in this example is that the seed is set before the loop begins. If the same seed is set again before the same three calls, the sequence is reproducible. The code still generates pseudorandom floats, but the starting internal state is controlled.

Common Loop Mistakes

• Expecting random.random() to return the same fixed sequence on every run without setting a seed.

  Different runs can begin with different internal states, so they can produce different pseudorandom sequences.

  Fix: Call random.seed() before the loop when you need reproducible output.

• Treating 1.0 as a possible result.

  The interval is [0.0, 1.0): 0.0 is included, but 1.0 is excluded.

  Fix: Read the square bracket and parenthesis separately before reasoning about possible values.

• Looking for the divergence somewhere after the random call.

  The divergence begins at the random.random() call that generated the unexpected value.

  Fix: Compare expected and actual values starting with the first call, then check the seed and the number of earlier calls.

• Assuming a loop reuses one random value automatically.

  Each iteration calls random.random() again, and each call returns the next value in the sequence.

  Fix: Count the calls: one call per iteration produces one new value per iteration.

Check Your Prediction

Key Takeaways

1. Each call to random.random() returns a pseudorandom float in [0.0, 1.0).
2. The range includes 0.0 but excludes 1.0.
3. A loop calling random.random() once per iteration produces one new value per iteration.
4. The random module's internal state advances with each call and determines the next value.
5. Use random.seed() before the loop to reproduce a sequence for testing or debugging.