random — Генерация псевдослучайных чисел

Функции управления состоянием

random.seed(a=None, version=2)

Инициализировать генератор случайных чисел.

Если a не указано или равно None, используется текущее системное время. Если операционная система предоставляет источники случайных чисел, они используются вместо системного времени (подробные сведения о доступности см. в описании функции os.urandom()).

Если a — целое число, напрямую используется его абсолютное значение.

При версии 2 (используется по умолчанию) объект str, bytes или bytearray преобразуется в int, и используются все его биты.

При версии 1 (предоставлена для воспроизведения последовательностей случайных чисел из старых версий Python) алгоритм для str и bytes генерирует более узкий диапазон начальных значений.

Изменено в версии 3.2: Переключено на схему версии 2, которая использует все биты строкового начального значения.

Изменено в версии 3.11: seed должно иметь один из следующих типов: None, int, float, str, bytes или bytearray.

random.getstate()

Вернуть объект, содержащий текущее внутреннее состояние генератора. Этот объект можно передать в setstate(), чтобы восстановить состояние.

random.setstate(state)

state должно быть получено предыдущим вызовом getstate(); setstate() восстанавливает внутреннее состояние генератора таким, каким оно было на момент вызова getstate().

Функции для байтов

random.randbytes(n)

Сгенерировать n случайных байтов.

Этот метод не следует использовать для генерации токенов безопасности. Вместо него используйте secrets.token_bytes().

Добавлено в версии 3.9.

Функции для целых чисел

random.randrange(stop)

random.randrange(start, stop[, step])

Вернуть случайно выбранный элемент из range(start, stop, step).

Примерно эквивалентно choice(range(start, stop, step)), но поддерживает диапазоны произвольной длины и оптимизировано для распространённых случаев.

Шаблон позиционных аргументов соответствует функции range().

Не следует использовать именованные аргументы, поскольку они могут интерпретироваться неожиданным образом. Например, randrange(start=100) интерпретируется как randrange(0, 100, 1).

Изменено в версии 3.2: randrange() использует более совершенный алгоритм для получения равномерно распределённых значений. Ранее применялся метод типа int(random()*n), который мог приводить к слегка неравномерному распределению.

Изменено в версии 3.12: Автоматическое преобразование типов, отличных от целочисленных, больше не поддерживается. Вызовы, такие как randrange(10.0) и randrange(Fraction(10, 1)), теперь вызывают исключение TypeError.

random.randint(a, b)

Вернуть случайное целое число N, такое что a <= N <= b. Псевдоним для randrange(a, b+1).

random.getrandbits(k)

Возвращает неотрицательное целое число Python, содержащее k случайных битов. Этот метод предоставляется генератором «вихрь Мерсенна»; некоторые другие генераторы также могут предоставлять его как необязательную часть API. Если этот метод доступен, getrandbits() позволяет функции randrange() обрабатывать диапазоны произвольной длины.

Изменено в версии 3.9: Теперь этот метод принимает ноль в качестве значения k.

Функции для последовательностей

random.choice(seq)

Вернуть случайный элемент непустой последовательности seq. Если seq пуста, вызывается исключение IndexError.

random.choices(population, weights=None, *, cum_weights=None, k=1)

Вернуть список длины k из элементов, выбранных из population с возвращением. Если population пуст, вызывается исключение IndexError.

Если задана последовательность weights, выбор производится с учётом относительных весов. Если вместо неё задана последовательность cum_weights, выбор производится с учётом накопленных весов (которые, возможно, вычислены с помощью itertools.accumulate()). Например, относительные веса [10, 5, 30, 5] эквивалентны накопленным весам [10, 15, 45, 50]. Перед выбором относительные веса внутри преобразуются в накопленные, поэтому передача накопленных весов позволяет сэкономить вычисления.

Если не указаны ни weights, ни cum_weights, элементы выбираются с одинаковой вероятностью. Если указана последовательность весов, её длина должна совпадать с длиной последовательности population. Одновременное указание weights и cum_weights вызывает исключение TypeError.

В weights или cum_weights можно использовать любой числовой тип, совместимый со значениями float, возвращаемыми функцией random() (включая целые числа, числа с плавающей точкой и дроби, но не десятичные числа). Предполагается, что веса неотрицательны и конечны. Если все веса равны нулю, вызывается исключение ValueError.

При одинаковом начальном значении функция choices() с равными весами обычно генерирует последовательность, отличающуюся от последовательности, полученной многократными вызовами choice(). Алгоритм, используемый choices(), применяет арифметику с плавающей точкой для единообразия и скорости. Алгоритм, используемый choice(), по умолчанию применяет целочисленную арифметику с повторными выборами, чтобы избежать небольшого смещения из-за ошибок округления.

Добавлено в версии 3.6.

Изменено в версии 3.9: Если все веса равны нулю, вызывается исключение ValueError.

random.shuffle(x)

Перемешать последовательность x на месте.

Чтобы перемешать неизменяемую последовательность и вернуть новый перемешанный список, используйте sample(x, k=len(x)).

Обратите внимание: даже для небольших значений len(x) общее число перестановок x может быстро превысить период большинства генераторов случайных чисел. Это означает, что многие перестановки длинной последовательности невозможно сгенерировать. Например, последовательность длиной 2080 — самая длинная последовательность, которая укладывается в период генератора случайных чисел «вихрь Мерсенна».

Изменено в версии 3.11: Удалён необязательный параметр random.

random.sample(population, k, *, counts=None)

Вернуть список длины k из уникальных элементов, выбранных из последовательности генеральной совокупности. Используется для случайной выборки без возвращения.

Возвращает новый список с элементами из генеральной совокупности, оставляя исходную совокупность без изменений. Полученный список упорядочен в порядке выбора, поэтому любые его срезы также будут корректными случайными выборками. Это позволяет разделить победителей розыгрыша (выборку) на обладателей главного и вторых призов (срезы).

Элементы генеральной совокупности не обязаны быть хешируемыми или уникальными. Если в генеральной совокупности есть повторяющиеся элементы, каждое их вхождение может быть выбрано в выборку.

Повторяющиеся элементы можно указать по отдельности или с помощью необязательного параметра только для именованных аргументов counts. Например, sample(['red', 'blue'], counts=[4, 2], k=5) эквивалентно sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5).

Чтобы выбрать выборку из диапазона целых чисел, передайте в качестве аргумента объект range(). Это особенно быстро и экономно по памяти при выборке из большой генеральной совокупности: sample(range(10000000), k=60).

Если размер выборки превышает размер генеральной совокупности, вызывается исключение ValueError.

Изменено в версии 3.9: Добавлен параметр counts.

Изменено в версии 3.11: population должна быть последовательностью. Автоматическое преобразование множеств в списки больше не поддерживается.

Дискретные распределения

Следующая функция генерирует дискретное распределение.

random.binomialvariate(n=1, p=0.5)

Биномиальное распределение. Возвращает число успешных исходов в n независимых испытаниях, вероятность успеха в каждом из которых равна p:

Математически эквивалентно:

sum(random() < p for i in range(n))

Число испытаний n должно быть неотрицательным целым числом. Вероятность успеха p должна находиться в диапазоне 0.0 <= p <= 1.0. Результат — целое число в диапазоне 0 <= X <= n.

Добавлено в версии 3.12.

Распределения действительных значений

Следующие функции генерируют конкретные распределения действительных значений. Параметры функций названы в соответствии с соответствующими переменными в уравнениях распределений, как принято в математике; большинство этих уравнений можно найти в любом учебнике по статистике.

random.random()

Вернуть следующее случайное число с плавающей точкой в диапазоне 0.0 <= X < 1.0

random.uniform(a, b)

Вернуть случайное число с плавающей точкой N, такое что a <= N <= b при a <= b и b <= N <= a при b < a.

Конечное значение b может включаться или не включаться в диапазон в зависимости от округления с плавающей точкой в выражении a + (b-a) * random().

random.triangular(low, high, mode)

Вернуть случайное число с плавающей точкой N, такое что low <= N <= high, с указанной mode между этими границами. По умолчанию границы low и high равны нулю и единице. По умолчанию аргумент mode равен середине между границами, что задаёт симметричное распределение.

random.betavariate(alpha, beta)

Бета-распределение. Условия для параметров: alpha > 0 и beta > 0. Возвращаемые значения находятся в диапазоне от 0 до 1.

random.expovariate(lambd=1.0)

Экспоненциальное распределение. lambd — это 1,0, делённое на требуемое среднее значение. Оно должно быть ненулевым. (Параметр назывался бы «lambda», но это зарезервированное слово в Python.) Если lambd положительно, возвращаемые значения находятся в диапазоне от 0 до плюс бесконечности; если отрицательно — от минус бесконечности до 0.

Изменено в версии 3.12: Добавлено значение по умолчанию для lambd.

random.gammavariate(alpha, beta)

Гамма-распределение. (Не гамма-функция!) Параметры формы и масштаба alpha и beta должны быть положительными. (Соглашения о вызове различаются, и в некоторых источниках «beta» определяется как величина, обратная масштабу.)

Функция плотности вероятности:

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha

random.gauss(mu=0.0, sigma=1.0)

Нормальное распределение, также называемое распределением Гаусса. mu — среднее значение, а sigma — стандартное отклонение. Эта функция немного быстрее, чем описанная ниже функция normalvariate().

Примечание о многопоточности: если два потока одновременно вызывают эту функцию, они могут получить одинаковое возвращаемое значение. Этого можно избежать тремя способами. 1) Пусть каждый поток использует отдельный экземпляр генератора случайных чисел. 2) Используйте блокировки вокруг всех вызовов. 3) Вместо этого используйте более медленную, но потокобезопасную функцию normalvariate().

Изменено в версии 3.11: Для mu и sigma теперь заданы аргументы по умолчанию.

random.lognormvariate(mu, sigma)

Логнормальное распределение. Если взять натуральный логарифм от этого распределения, получится нормальное распределение со средним значением mu и стандартным отклонением sigma. mu может иметь любое значение, а sigma должно быть больше нуля.

random.normalvariate(mu=0.0, sigma=1.0)

Нормальное распределение. mu — среднее значение, а sigma — стандартное отклонение.

Изменено в версии 3.11: Для mu и sigma теперь заданы аргументы по умолчанию.

random.vonmisesvariate(mu, kappa)

mu — средний угол, выраженный в радианах в диапазоне от 0 до 2*pi, а kappa — параметр концентрации, который должен быть не меньше нуля. Если kappa равен нулю, это распределение сводится к равномерному распределению случайного угла в диапазоне от 0 до 2*pi.

random.paretovariate(alpha)

Распределение Парето. alpha — параметр формы.

random.weibullvariate(alpha, beta)

Распределение Вейбулла. alpha — параметр масштаба, а beta — параметр формы.

Альтернативный генератор

class random.Random([seed])

Класс, реализующий используемый по умолчанию генератор псевдослучайных чисел модуля random.

Изменено в версии 3.11: Ранее seed могло быть любым хешируемым объектом. Теперь допустимы только: None, int, float, str, bytes или bytearray.

Чтобы использовать другой базовый генератор, подклассы Random должны переопределить следующие методы:

seed(a=None, version=2)

Переопределите этот метод в подклассах, чтобы настроить поведение seed() экземпляров Random.

getstate()

Переопределите этот метод в подклассах, чтобы настроить поведение getstate() экземпляров Random.

setstate(state)

Переопределите этот метод в подклассах, чтобы настроить поведение setstate() экземпляров Random.

random()

Переопределите этот метод в подклассах, чтобы настроить поведение random() экземпляров Random.

При желании подкласс пользовательского генератора также может предоставить следующий метод:

getrandbits(k)

Переопределите этот метод в подклассах, чтобы настроить поведение getrandbits() экземпляров Random.

randbytes(n)

Переопределите этот метод в подклассах, чтобы настроить поведение randbytes() экземпляров Random.

class random.SystemRandom([seed])

Класс, использующий функцию os.urandom() для генерации случайных чисел из источников, предоставляемых операционной системой. Доступен не во всех системах. Не зависит от программного состояния, поэтому последовательности невозможно воспроизвести. Соответственно, метод seed() не оказывает никакого эффекта и игнорируется. При вызове методы getstate() и setstate() вызывают исключение NotImplementedError.

Примечания о воспроизводимости

Иногда полезно иметь возможность воспроизводить последовательности, генерируемые генератором псевдослучайных чисел. Повторное использование начального значения должно обеспечивать воспроизводимость одной и той же последовательности при каждом запуске, если одновременно не выполняются несколько потоков.

Большинство алгоритмов и функций задания начальных значений модуля random могут меняться между версиями Python, но два аспекта гарантированно останутся неизменными:

• Если будет добавлен новый метод задания начального значения, будет также предоставлен обратно совместимый метод.
• Метод генератора random() продолжит генерировать ту же последовательность, если совместимому методу задания начального значения передать то же значение.

Примеры

Базовые примеры:

>>> random()                          # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                     # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)              # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])   # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                     # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4) # Four samples without replacement
[40, 10, 50, 30]

Симуляции:

>>> # Six roulette wheel spins (weighted sampling with replacement)
>>> choices(['red', 'black', 'green'], [18, 18, 2], k=6)
['red', 'green', 'black', 'black', 'red', 'black']

>>> # Deal 20 cards without replacement from a deck
>>> # of 52 playing cards, and determine the proportion of cards
>>> # with a ten-value:  ten, jack, queen, or king.
>>> deal = sample(['tens', 'low cards'], counts=[16, 36], k=20)
>>> deal.count('tens') / 20
0.15

>>> # Estimate the probability of getting 5 or more heads from 7 spins
>>> # of a biased coin that settles on heads 60% of the time.
>>> sum(binomialvariate(n=7, p=0.6) >= 5 for i in range(10_000)) / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial():
...     return 2_500 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958

Пример статистического бутстрэппинга с использованием повторной выборки с возвращением для оценки доверительного интервала среднего значения выборки:

# https://www.thoughtco.com/example-of-bootstrapping-3126155
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted(mean(choices(data, k=len(data))) for i in range(100))
print(f'The sample mean of {mean(data):.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}')

Пример перестановочного теста на основе повторной выборки для определения статистической значимости или p-значения наблюдаемого различия между эффектами лекарственного препарата и плацебо:

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)

n = 10_000
count = 0
combined = drug + placebo
for i in range(n):
    shuffle(combined)
    new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
    count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')

Моделирование времени прибытия и оказания услуг в многоканальной системе массового обслуживания:

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify(servers)
for i in range(1_000_000):
    arrival_time += expovariate(1.0 / average_arrival_interval)
    next_server_available = servers[0]
    wait = max(0.0, next_server_available - arrival_time)
    waits.append(wait)
    service_duration = max(0.0, gauss(average_service_time, stdev_service_time))
    service_completed = arrival_time + wait + service_duration
    heapreplace(servers, service_completed)

print(f'Mean wait: {mean(waits):.1f}   Max wait: {max(waits):.1f}')
print('Quartiles:', [round(q, 1) for q in quantiles(waits)])

Рецепты

Эти рецепты показывают, как эффективно делать случайный выбор из комбинаторных итераторов модуля itertools:

import random

def random_product(*iterables, repeat=1):
    "Random selection from itertools.product(*iterables, repeat=repeat)"
    pools = tuple(map(tuple, iterables)) * repeat
    return tuple(map(random.choice, pools))

def random_permutation(iterable, r=None):
    "Random selection from itertools.permutations(iterable, r)"
    pool = tuple(iterable)
    r = len(pool) if r is None else r
    return tuple(random.sample(pool, r))

def random_combination(iterable, r):
    "Random selection from itertools.combinations(iterable, r)"
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.sample(range(n), r))
    return tuple(pool[i] for i in indices)

def random_combination_with_replacement(iterable, r):
    "Choose r elements with replacement.  Order the result to match the iterable."
    # Result will be in set(itertools.combinations_with_replacement(iterable, r)).
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.choices(range(n), k=r))
    return tuple(pool[i] for i in indices)

def random_derangement(iterable):
    "Choose a permutation where no element stays in its original position."
    seq = tuple(iterable)
    if len(seq) < 2:
        if not seq:
            return ()
        raise IndexError('No derangments to choose from')
    perm = list(range(len(seq)))
    start = tuple(perm)
    while True:
        random.shuffle(perm)
        if all(p != q for p, q in zip(start, perm)):
            return tuple([seq[i] for i in perm])

По умолчанию random() возвращает значения, кратные 2⁻⁵³, в диапазоне 0.0 ≤ x < 1.0. Все такие числа равномерно распределены и точно представимы в виде чисел с плавающей точкой Python. Однако многие другие представимые числа с плавающей точкой в этом интервале выбрать невозможно. Например, 0.05954861408025609 не является целым кратным 2⁻⁵³.

Следующий рецепт использует другой подход. Выбрать можно любое число с плавающей точкой в интервале. Мантисса берётся из равномерного распределения целых чисел в диапазоне 2⁵² ≤ mantissa < 2⁵³. Показатель берётся из геометрического распределения, в котором показатели меньше -53 встречаются вдвое реже, чем следующий больший показатель.

from random import Random
from math import ldexp

class FullRandom(Random):

    def random(self):
        mantissa = 0x10_0000_0000_0000 | self.getrandbits(52)
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits(32)
            exponent += x.bit_length() - 32
        return ldexp(mantissa, exponent)

Все распределения вещественных значений в классе будут использовать новый метод:

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

Концептуально этот рецепт эквивалентен алгоритму, который выбирает из всех чисел, кратных 2⁻¹⁰⁷⁴, в диапазоне 0.0 ≤ x < 1.0. Все такие числа равномерно распределены, но большинство из них необходимо округлить вниз до ближайшего представимого числа с плавающей точкой Python. (Значение 2⁻¹⁰⁷⁴ — это наименьшее положительное ненормализованное число с плавающей точкой, равное math.ulp(0.0).)

Использование командной строки

Модуль random можно запустить из командной строки.

python -m random [-h] [-c CHOICE [CHOICE ...] | -i N | -f N] [input ...]

Поддерживаются следующие параметры:

-h, --help

Показать справочное сообщение и выйти.

-c CHOICE [CHOICE ...]

--choice CHOICE [CHOICE ...]

Вывести случайный вариант, используя choice().

-i <N>

--integer <N>

Вывести случайное целое число от 1 до N включительно, используя randint().

-f <N>

--float <N>

Вывести случайное число с плавающей точкой от 0 до N включительно, используя uniform().

Если параметры не указаны, вывод зависит от входных данных:

• Строка или несколько значений: то же, что и --choice.
• Целое число: то же, что и --integer.
• Число с плавающей точкой: то же, что и --float.

Пример использования командной строки

Вот несколько примеров интерфейса командной строки random:

$ # Choose one at random
$ python -m random egg bacon sausage spam "Lobster Thermidor aux crevettes with a Mornay sauce"
Lobster Thermidor aux crevettes with a Mornay sauce

$ # Random integer
$ python -m random 6
6

$ # Random floating-point number
$ python -m random 1.8
1.7080016272295635

$ # With explicit arguments
$ python  -m random --choice egg bacon sausage spam "Lobster Thermidor aux crevettes with a Mornay sauce"
egg

$ python -m random --integer 6
3

$ python -m random --float 1.8
1.5666339105010318

$ python -m random --integer 6
5

$ python -m random --float 6
3.1942323316565915