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

Kod źródłowy: Lib/random.py

---

Цей модуль реалізує генератори псевдовипадкових чисел для різних розподілів.

Для цілих чисел існує рівномірний вибір із діапазону. Для послідовностей існує рівномірний вибір випадкового елемента, функція для створення випадкової перестановки списку на місці та функція для випадкової вибірки без заміни.

На реальній лінії існують функції для обчислення рівномірного, нормального (гауссового), логарифмічного нормального, від’ємного експоненціального, гамма- та бета-розподілу. Для генерації розподілу кутів доступний розподіл фон Мізеса.

Почти все функции модуля зависят от базовой функции random(), которая равномерно генерирует случайное число с плавающей запятой в полуоткрытом диапазоне 0.0 <= X < 1.0. Python использует Mersenne Twister в качестве основного генератора. Он производит 53-битные числа с плавающей запятой и имеет период 2**19937-1. Базовая реализация на C является одновременно быстрой и потокобезопасной. Mersenne Twister — один из наиболее тщательно протестированных существующих генераторов случайных чисел. Однако, будучи полностью детерминированным, он подходит не для всех целей и совершенно непригоден для криптографических целей.

Функції, які надає цей модуль, насправді є зв’язаними методами прихованого екземпляра класу random.Random. Ви можете створити власні екземпляри Random, щоб отримати генератори, які не мають спільного стану.

Класс Random также может быть подклассом, если вы хотите использовать другой базовый генератор собственной разработки: более подробную информацию см. в документации по этому классу.

Модуль random також надає клас SystemRandom, який використовує системну функцію os.urandom() для генерування випадкових чисел із джерел, наданих операційною системою.

Ostrzeżenie

Псевдовипадкові генератори цього модуля не слід використовувати з метою безпеки. Щоб отримати відомості про безпеку чи криптографію, перегляньте модуль secrets.

Zobacz także

M. Matsumoto and T. Nishimura, „Mersenne Twister: 623-dimensionally equidistributed uniform pseudorandom number generator”, ACM Transactions on Modeling and Computer Simulation Vol. 8, № 1, січень 3-30 1998.

Рецепт Complementary-Multiply-with-Carry для совместимого альтернативного генератора случайных чисел с длительным периодом и сравнительно простые операции обновления.

Informacja

Глобальный генератор случайных чисел и экземпляры Random являются потокобезопасными. Однако в сборке со свободным потоком одновременные вызовы глобального генератора или одного и того же экземпляра Random могут столкнуться с конфликтами и низкой производительностью. Вместо этого рассмотрите возможность использования отдельных экземпляров Random для каждого потока.

Бухгалтерські функції

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

Ініціалізуйте генератор випадкових чисел.

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

Якщо a є int, воно використовується безпосередньо.

У версії 2 (за замовчуванням) об’єкт str, bytes або bytearray перетворюється на int і використовуються всі його біти.

У версії 1 (надається для відтворення випадкових послідовностей зі старих версій Python) алгоритм для str і bytes генерує вужчий діапазон початкових значень.

Zmienione w wersji 3.2: Перенесено на схему версії 2, яка використовує всі біти початкового рядка.

Zmienione w wersji 3.11: Seed должно быть одного из следующих типов: None, int, float, str, bytes или :class: bytearray.

random.getstate()

Повертає об’єкт, що фіксує поточний внутрішній стан генератора. Цей об’єкт можна передати setstate() для відновлення стану.

random.setstate(state)

state мав бути отриманий з попереднього виклику getstate(), а setstate() відновлює внутрішній стан генератора до того, яким він був на момент виклику getstate().

Функції для байтів

random.randbytes(n)

Згенерувати n випадкових байтів.

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

Dodane w wersji 3.9.

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

random.randrange(stop)

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

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

Это примерно эквивалентно choice(range(start, stop, Step)), но поддерживает сколь угодно большие диапазоны и оптимизировано для распространенных случаев.

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

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

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

Zmienione w wersji 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() обрабатывать произвольно большие диапазоны.

Zmienione w wersji 3.9: Цей метод тепер приймає нуль для k.

Функції для послідовностей

random.choice(seq)

Повертає випадковий елемент із непорожньої послідовності seq. Якщо seq порожній, викликає IndexError.

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

Повертає список елементів розміром k, вибраних із популяції із заміною. Якщо популяція порожня, викликає IndexError.

Якщо вказано послідовність ваг, вибір робиться відповідно до відносних ваг. Крім того, якщо вказано послідовність cum_weights, вибір робиться відповідно до кумулятивних ваг (можливо, обчислених за допомогою itertools.accumulate()). Наприклад, відносні ваги [10, 5, 30, 5] еквівалентні кумулятивним вагам [10, 15, 45, 50]. Внутрішньо відносні ваги перетворюються на кумулятивні ваги перед вибором, тому надання кумулятивних ваг економить роботу.

Якщо ані weights, ані cum_weights не вказано, вибір робиться з рівною ймовірністю. Якщо надається послідовність ваг, вона має бути такої ж довжини, що й послідовність населеності. Це TypeError, якщо вказати weights і cum_weights.

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

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

Dodane w wersji 3.6.

Zmienione w wersji 3.9: Викликає ValueError, якщо всі ваги дорівнюють нулю.

random.shuffle(x)

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

Щоб перетасувати незмінну послідовність і повернути новий перетасований список, замість цього використовуйте sample(x, k=len(x)).

Зауважте, що навіть для невеликого len(x) загальна кількість перестановок x може швидко зрости більше, ніж період більшості генераторів випадкових чисел. Це означає, що більшість перестановок довгої послідовності ніколи не можуть бути згенеровані. Наприклад, послідовність довжиною 2080 є найбільшою, яка може поміститися в період генератора випадкових чисел Мерсенна Твістера.

Zmienione w wersji 3.11: Удален необязательный параметр random.

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

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

Повертає новий список, що містить елементи з сукупності, залишаючи вихідну сукупність без змін. Отриманий список складається в порядку відбору, тому всі підзрізи також будуть дійсними випадковими вибірками. Це дозволяє розділити переможців розіграшу (зразок) на головний приз і переможців, які посідають друге місце (підрозділи).

Члени сукупності не повинні бути hashable або унікальними. Якщо популяція містить повтори, то кожен випадок є можливим вибором у вибірці.

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

Щоб вибрати вибірку з діапазону цілих чисел, використовуйте об’єкт range() як аргумент. Це особливо швидко та ефективно для вибірки з великої сукупності: sample(range(10000000), k=60).

Якщо розмір вибірки більший за розмір сукупності, виникає помилка ValueError.

Zmienione w wersji 3.9: Додано параметр counts.

Zmienione w wersji 3.11: Популяция должна быть последовательностью. Автоматическое преобразование наборов в списки больше не поддерживается.

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

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

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.

Dodane w wersji 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 + (ba) * random().

random.triangular(low, high, mode)

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

random.betavariate(alpha, beta)

Бета-розповсюдження. Умови параметрів: альфа > 0 і бета > 0. Діапазон повернених значень від 0 до 1.

random.expovariate(lambd=1.0)

Експоненціальний розподіл. lambd дорівнює 1,0, поділеному на бажане середнє. Воно повинно бути відмінним від нуля. (Параметр мав би назву „лямбда”, але це зарезервоване слово в Python.) Повернені значення варіюються від 0 до нескінченності, якщо lambd додатне, і від нескінченності до 0, якщо lambd є від’ємним.

Zmienione w wersji 3.12: Добавлено значение по умолчанию для lambd.

random.gammavariate(alpha, beta)

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

Функція розподілу ймовірностей:

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

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

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

Примітка щодо багатопоточності: коли два потоки викликають цю функцію одночасно, можливо, вони отримають однакове повернуте значення. Цього можна уникнути трьома способами. 1) Нехай кожен потік використовує окремий екземпляр генератора випадкових чисел. 2) Заблокуйте всі дзвінки. 3) Натомість використовуйте повільнішу, але потокобезпечну функцію normalvariate().

Zmienione w wersji 3.11: mu и sigma теперь имеют аргументы по умолчанию.

random.lognormvariate(mu, sigma)

Лог нормального розподілу. Якщо взяти натуральний логарифм цього розподілу, ви отримаєте нормальний розподіл із середнім mu і стандартним відхиленням sigma. mu може мати будь-яке значення, а sigma має бути більше нуля.

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

Нормальний розподіл. mu — середнє, а sigma — стандартне відхилення.

Zmienione w wersji 3.11: mu и sigma теперь имеют аргументы по умолчанию.

random.vonmisesvariate(mu, kappa)

mu — середній кут, виражений у радіанах між 0 і 2*pi, а kappa — параметр концентрації, який має бути більшим або дорівнювати нулю. Якщо kappa дорівнює нулю, цей розподіл зменшується до рівномірного випадкового кута в діапазоні від 0 до 2*pi.

random.paretovariate(alpha)

Розподіл Парето. альфа — це параметр форми.

random.weibullvariate(alpha, beta)

Розподіл Вейбулла. альфа — параметр масштабу, а бета — параметр форми.

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

class random.Random([seed])

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

Zmienione w wersji 3.11: Раньше сид мог быть любым хешируемым объектом. Теперь оно ограничено: 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)

Override this method in subclasses to customise the randbytes() behaviour of Random instances.

class random.SystemRandom([seed])

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

Примітки щодо відтворюваності

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

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

• Якщо додано новий метод посіву, буде запропоновано зворотно сумісний сівалка.

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

Przykłady

Основні приклади:

>>> 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]

Symulacje:

>>> # 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)])

Zobacz także

Statistics for Hackers відеоурок від Jake Vanderplas зі статистичного аналізу з використанням лише кількох фундаментальних концепцій, включаючи моделювання, вибірку, перетасування та перехресну перевірку.

Экономическое моделирование моделирование рынка Питера Норвига это показывает эффективное использование многих инструментов и распределений, предоставляемых этим модулем (гауссовое, равномерное, выборочное, бета-вариация, выбор, треугольное и рандомизированное).

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

рецепти

Эти рецепты показывают, как эффективно делать случайный выбор из комбинаторных итераторов в модуле 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."
    # 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)

За умовчанням random() повертає кратні 2⁻⁵³ у діапазоні 0,0 ≤ x < 1,0. Усі такі числа розташовані на рівних інтервалах і точно представлені як плаваючі числа Python. Однак багато інших репрезентованих плаваючих значень у цьому інтервалі не є можливим вибором. Наприклад, 0,05954861408025609 не є цілим числом, кратним 2⁻⁵³.

Наступний рецепт передбачає інший підхід. Усі плаваючі значення в інтервалі є можливими виборами. Мантиса походить від рівномірного розподілу цілих чисел у діапазоні 2⁵² ≤ мантиса < 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).)

Zobacz także

Generating Pseudo-random Floating-Point Values стаття Аллена Б. Дауні, яка описує способи генерації більш дрібнозернистих значень з плаваючою комою, ніж зазвичай генерує random().

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

Dodane w wersji 3.13.

Модуль 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: то же, что и --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