random – Генерация псевдослучайных чисел¶random – Generate pseudo-random numbers

Учётные функции¶Bookkeeping functions

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().

Функции для байтов¶Functions for bytes

random.randbytes(n)¶

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

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

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

Функции для целых чисел¶Functions for integers

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 случайными битами. Этот метод предоставляется генератором Mersenne Twister, и некоторые другие генераторы также могут реализовывать его как опциональную часть API. Если он доступен, getrandbits() позволяет randrange() работать с произвольно большими диапазонами.

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

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

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 – это самая длинная, которая умещается в период генератора случайных чисел Mersenne Twister.

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

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

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

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

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

Повторяющиеся элементы можно указывать по одному или с помощью необязательного параметра 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 должен быть последовательностью. Автоматическое преобразование множеств в списки больше не поддерживается.

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

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

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.

Вещественные распределения¶Real-valued distributions

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

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 и с указанной модой между этими границами. Границы low и high по умолчанию равны нулю и единице. Аргумент mode по умолчанию равен середине между границами, что даёт симметричное распределение.

random.betavariate(alpha, beta)¶

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

random.expovariate(lambd=1.0)¶

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

Изменено в версии 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 – параметр формы.

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

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.

class random.SystemRandom([seed])¶

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

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

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

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

• Если будет добавлен новый метод инициализации, будет предложен обратно совместимый инициализатор.

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

Примеры¶Examples

Простые примеры:

>>> random()                          # Случайное число с плавающей точкой: 0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                # Случайное число с плавающей точкой: 2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                # Интервал между поступлениями в среднем 5 секунд
5.148957571865031

>>> randrange(10)                     # Целое число от 0 до 9 включительно
7

>>> randrange(0, 101, 2)              # Чётное целое число от 0 до 100 включительно
26

>>> choice(['win', 'lose', 'draw'])   # Один случайный элемент из последовательности
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                     # Перемешать список
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4) # Четыре выборки без возвращения
[40, 10, 50, 30]

Симуляции:

>>> # Шесть вращений колеса рулетки (взвешенная выборка с возвращением)
>>> choices(['red', 'black', 'green'], [18, 18, 2], k=6)
['red', 'green', 'black', 'black', 'red', 'black']

>>> # Раздать 20 карт без возвращения из колоды
>>> # из 52 игральных карт и определить долю карт
>>> # со значением десять: десятка, валет, дама или король.
>>> deal = sample(['tens', 'low cards'], counts=[16, 36], k=20)
>>> deal.count('tens') / 20
0.15

>>> # Оценить вероятность выпадения 5 или более орлов за 7 подбрасываний
>>> # несимметричной монеты, которая выпадает орлом в 60% случаев.
>>> sum(binomialvariate(n=7, p=0.6) >= 5 for i in range(10_000)) / 10_000
0.4169

>>> # Вероятность того, что медиана 5 выборок окажется в двух средних квартилях
>>> 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-значения наблюдаемого различия между эффектами препарата и плацебо:

# Пример из книги "Statistics is Easy" Денниса Шаши и Манды Уилсон
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  # время, когда каждый сервер становится доступным
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)])

Рецепты¶Recipes

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

def random_product(*args, repeat=1):
    "Random selection from itertools.product(*args, **kwds)"
    pools = [tuple(pool) for pool in args] * 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."
    # Результат будет в 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)

По умолчанию 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).)