Generating Random Floating-Point Numbers with random.random()

A Number That Changes Each Call

Random-number functions are useful when a program must make a choice that is not fixed in advance. Python's random.random() produces a pseudorandom floating-point number between 0.0 and 1.0. The value may look unpredictable, but each call produces the next value determined by the random module's internal state.

The Output Interval

A result can be exactly 0.0, but it will never be exactly 1.0. Other results lie between those boundaries. This half-open interval is useful when scaling the result: multiplying by 100 produces a float in [0.0, 100.0), while multiplying by 6 and converting to an integer can produce one of 0, 1, 2, 3, 4, or 5.

import random

value = random.random()
print(value)

The printed value is not fixed in advance. A valid run might display a value such as 0.37, but the exact result depends on the random module's internal state. The important check is that the result is at least 0.0 and less than 1.0.

Following the Internal State

Every call to random.random() is a separate event. The random module maintains internal state, and that state changes as calls are made. The next call uses the new state to determine the next pseudorandom float. The function does not need to remember the previous value as a variable; the module's internal state controls what comes next.

import random for step in range(3): value = random.random() print(value)

When Expected Output Diverges

When actual random output differs from a sequence you expected, the divergence occurs at the call to random.random() itself. The cause can be an unset seed, a different seed, or a different number of random calls made before the code under inspection runs. The surrounding loop may be working correctly; the pseudorandom value entering the loop's output is what differs.

Integer Boundaries with randint()

random.randint(low, high) generates a random integer in an inclusive range. Both endpoints are possible. For random.randint(5, 10), the possible results are 5, 6, 7, 8, 9, and 10, and each has a 1-in-6 chance on any given call.

import random

number = random.randint(5, 10)
print(number)

The same inclusive-boundary idea can represent a real-world integer choice. For example, random.randint(1, 100) can select an integer from 1 through 100, including both 1 and 100. Use randint() when the endpoints belong to the requested set of possible integer results.

Mistakes in Random Calls

• Forgetting to import the random module

  The name random is not available until the module has been imported.

  Fix: Write import random before calling random.randint() or random.random().

• Treating randint() like range() and excluding the high value

  randint() includes both its low and high endpoints.

  Fix: Expect 1, 2, 3, 4, 5, or 6 from random.randint(1, 6).

• Passing the boundaries in the wrong order

  The call does not express the intended low-to-high range.

  Fix: Place the lower integer first and the higher integer second.

• Passing non-integer arguments to randint()

  randint() requires integer parameters.

  Fix: Pass integer values such as random.randint(1, 6).

• Expecting random.random() to return exactly 1.0

  The upper boundary of random.random() is exclusive.

  Fix: Treat the result as a value in [0.0, 1.0), where 0.0 is included and 1.0 is not.

Practice and Recap

1. random.random() returns a pseudorandom float in [0.0, 1.0): 0.0 is possible, while 1.0 is excluded. Each call advances the random module's internal state and returns the next value in its pseudorandom sequence. Without resetting the seed, separate runs can produce different sequences; using the same seed makes sequences reproducible. When debugging, locate the first call whose result differs from your expectation. For integer choices, random.randint(low, high) includes both endpoints, unlike range(), which excludes its upper endpoint.