Random в питоне: Примеры кода модуля random в Python

Примеры кода модуля random в Python

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

Содержание

Список методов модуля random в Python:

Цели данной статьи

Далее представлен список основных операций, которые будут описаны в руководстве:

• Генерация случайных чисел для различных распределений, которые включают целые и вещественные числа с плавающей запятой;
• Случайная выборка нескольких элементов последовательности population;
• Функции модуля random;
• Перемешивание элементов последовательности. Seed в генераторе случайных данных;
• Генерация случайных строки и паролей;
• Криптографическое обеспечение безопасности генератора случайных данных при помощи использования модуля secrets. Обеспечение безопасности токенов, ключей безопасности и URL;
• Способ настройки работы генератора случайных данных;
• Использование numpy.random для генерации случайных массивов;
• Использование модуля UUID для генерации уникальных ID.

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

Как использовать модуль random в Python

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

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

В самом начале работы необходимо импортировать модуль random в программу. Только после этого его можно будет полноценно использовать. Оператор для импорта модуля random выглядит следующим образом:

Теперь рассмотрим использование самого модуля random на простом примере:

import random


print(«Вывод случайного числа при помощи использования random.random()»)
print(random.random())

Вывод:

Вывод случайного числа при помощи использования random.random()
0.9461613475266107

Как видите, в результате мы получили 0.9461613475266107. У вас, конечно, выйдет другое случайно число.

• random() является базовой функцией модуля random;
• Почти все функции модуля random зависят от базовой функции random();
• random() возвращает следующее случайное число с плавающей запятой в промежутке [0.0, 1.0].

Перед разбором функций модуля random давайте рассмотрим основные сферы их применения.

Генерация случайных чисел в Python

Давайте рассмотрим самый популярный случай использования модуля random — генерацию случайного числа. Для получения случайного целого числа в Python используется функция randint().

Для генерации случайных целых чисел можно использовать следующие две функции:

В следующем примере показано, как получить случайно сгенерированное число в промежутке между 0 и 9.

from random import randint


print(«Вывод случайного целого числа «, randint(0, 9))
print(«Вывод случайного целого числа «, randrange(0, 10, 2))

Вывод:

Вывод случайного целого числа 5
Вывод случайного целого числа 2

В следующих разделах статьи будут рассмотрены некоторые другие способы генерации случайного числа в Python.

Выбор случайного элемента из списка Python

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

import random


city_list = [‘New York’, ‘Los Angeles’, ‘Chicago’, ‘Houston’, ‘Philadelphia’]
print(«Выбор случайного города из списка — «, random.choice(city_list))

Вывод:

Выбор случайного города из списка — Houston

Python функции модуля random

Рассмотрим разнообразные функции, доступные в модуле random.

Случайное целое число — randint(a, b) модуль random

• Возвращает случайное целое число Number, такое что a <= Number <= b;
• randint(a,b) работает только с целыми числами;
• Функция randint(a,b) принимает только два параметра, оба обязательны;
• Полученное в результате случайно число больше или равно a, а также меньше или равно b.

Пример использования random.randint() в Python:

import random


print(«Использование random.randint() для генерации случайного целого числа»)
print(random.randint(0, 5))
print(random.randint(0, 5))

Вывод:

Использование random.randint() для генерации случайного целого числа
4
2

Генерация случайного целого числа — randrange() модуль random

Метод random.randrange() используется для генерации случайного целого числа в пределах заданного промежутка. Скажем, для получения любого числа в диапазоне между 10 и 50.

Шаг показывает разницу между каждым числом заданной последовательности. Шаг по умолчанию равен 1, однако его значение можно изменить.

Пример использования random.randrange() в Python:

import random


print(«Генерация случайного числа в пределах заданного промежутка»)
print(random.randrange(10, 50, 5))
print(random.randrange(10, 50, 5))

Вывод:

Генерация случайного числа в пределах заданного промежутка
10
15

Выбор случайного элемента из списка choice() модуль random

Метод random.choice() используется для выбора случайного элемента из списка. Набор может быть представлен в виде списка или python строки. Метод возвращает один случайный элемент последовательности.

Пример использования random.choice() в Python:

import random


list = [55, 66, 77, 88, 99]
print(«random.choice используется для выбора случайного элемента из списка — «, random.choice(list))

Вывод:

random.choice используется для выбора случайного элемента из списка — 55

Метод sample(population, k) из модуля random

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

• Метод sample() возвращает список уникальных элементов, которые были выбраны из последовательности population. Итоговое количество элементов зависит от значения k;
• Значение в population может быть представлено в виде списка или любой другой последовательности.

Пример использования random.sample() в Python:

import random


list = [2, 5, 8, 9, 12]
print («random.sample() «, random.sample(list,3))

Вывод:

random.sample() [5, 12, 2]

Случайные элементы из списка — choices() модуль random

• random.choices(population, weights=None, *, cum_weights=None, k=1)
• Метод random.choices() используется, когда требуется выбрать несколько случайных элементов из заданной последовательности.
• Метод choices() был введен в версии Python 3.6. Он также позволяет повторять несколько раз один и тот же элемент.

Пример использования random.choices() в Python:

import random


# Выборка с заменой
list = [20, 30, 40, 50 ,60, 70, 80, 90]
sampling = random.choices(list, k=5)

print(«Выборка с методом choices «, sampling)

Вывод:

Выборка с методом choices [30, 20, 40, 50, 40]

Генератор псевдослучайных чисел —  seed() модуль random

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

Пример использования random.seed() в Python:

import random


random.seed(6)
print(«Случайное число с семенем «,random.random())

print(«Случайное число с семенем «,random.random())

Вывод:

Random number with seed 0.793340083761663
Random number with seed 0.793340083761663

Перемешивание данных — shuffle() из модуля random

Метод random.shuffle() используется для перемешивания данных списка или другой последовательности. Метод shuffle() смешивает элементы списка на месте. Самый показательный пример использования — тасование карт.

Пример использования random.shuffle() в Python:

list = [2, 5, 8, 9, 12]


random.shuffle(list)
print («Вывод перемешанного списка «, list)

Вывод:

Вывод перемешанного списка [8, 9, 2, 12, 5]

Генерации числа с плавающей запятой — uniform() модуль random

• random.uniform() используется для генерации числа с плавающей запятой в пределах заданного промежутка
• Значение конечной точки может включаться в диапазон, но это не обязательно. Все зависит от округления значения числа с плавающей запятой;
• Метод может, например, сгенерировать случайно вещественное число в промежутке между 10.5 и 25.5.

Пример использования random.uniform() в Python:

import random


print(«Число с плавающей точкой в пределах заданного промежутка»)
print(random.uniform(10.5, 25.5))

Вывод:

Число с плавающей точкой в пределах заданного промежутка
22.095283175159786

triangular(low, high, mode) из модуля random

Функция random.triangular() возвращает случайное вещественное число N с плавающей запятой, которое соответствует условию lower <= N <= upper, а также уточняющему значению mode.

Значение нижнего предела по умолчанию равно нулю, в верхнего — единице. Кроме того, пик аргумента по умолчанию установлен на середине границ, что обеспечивает симметричное распределение.

Функция random.triangular() используется в генерации случайных чисел для треугольного распределения с целью использования полученных значений в симуляции. Это значит, что в при генерации значения применяется треугольное распределение вероятности. 

Пример использования random.triangular() в Python:

import random


print(«Число с плавающей точкой через triangular»)
print(random.triangular(10.5, 25.5, 5.5))

Вывод:

Число с плавающей точкой через triangular
16.7421565549115

Генератор случайной строки в Python

В данном разделе будет подробно расписано, как сгенерировать случайную строку фиксированной длины в Python.

Основные аспекты раздела:

• Генерация случайной строки фиксированной длины;
• Получение случайной алфавитно-цифровой строки, среди элементов которой будут как буквы, так и числа;
• Генерация случайного пароля, который будет содержать буквы, цифры и специальный символы.

Криптографическая зашита генератора случайных данных в Python

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

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

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

Для обеспечения криптографической надежности генерации случайных чисел можно использовать следующие подходы:

• Применение модуля secrets для защиты случайных данных;
• Использование из модуля os os.urandom();
• Использование класса random.SystemRandom.

Пример криптографически надежной генерации данных в Python:

import random
import secrets


number = random.SystemRandom().random()
print(«Надежное число «, number)

print(«Надежный токен байтов», secrets.token_bytes(16))

Вывод:

Надежное число 0.11139538267693572

Надежный токен байтов b’\xae\xa0\x91*.\xb6\xa1\x05=\xf7+>\r;Y\xc3′

getstate() и setstate() в генераторе случайных данных Python

Функции getstate() и setstate() модуля random позволяют зафиксировать текущее внутреннее состояние генератора.

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

Состояние генератора getstate() модуль random

Функция getstate() возвращает определенный объект, зафиксировав текущее внутреннее состояние генератора случайных данных. Данное состояние передается методу setstate() для восстановления полученного состояния в качестве текущего.

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

Восстанавливает внутреннее состояние генератора — setstate() модуль random

Функция setstate() восстанавливает внутреннее состояние генератора и передает его состоянию объекта. Это значит, что вновь будет использован тот же параметр состояния state. Объект state может быть получен при помощи вызова функции getstate().

Зачем нужны функции getstate() и setstate() ?

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

Для закрепления понимания принципов работы getstate() и setstate() в генераторе случайных данных Python рассмотрим следующий пример:

import random


number_list = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]

print(«Первая выборка «, random.sample(number_list,k=5))

# хранит текущее состояние в объекте state
state = random.getstate()

print(«Вторая выборка «, random.sample(number_list,k=5))

# Восстанавливает состояние state, используя setstate
random.setstate(state)

#Теперь будет выведен тот же список второй выборки
print(«Третья выборка «, random.sample(number_list,k=5))

# Восстанавливает текущее состояние state
random.setstate(state)

# Вновь будет выведен тот же список второй выборки
print(«Четвертая выборка «, random.sample(number_list,k=5))

Вывод:

Первая выборка [18, 15, 30, 9, 6]
Вторая выборка [27, 15, 12, 9, 6]
Третья выборка [27, 15, 12, 9, 6]
Четвертая выборка [27, 15, 12, 9, 6]

Как можно заметить в результате вывода — мы получили одинаковые наборы данных. Это произошло из-за сброса генератора случайных данных.

Numpy.random — Генератор псевдослучайных чисел

PRNG является англоязычным акронимом, который расшифровывается как «pseudorandom number generator» — генератор псевдослучайных чисел. Известно, что в Python модуль random можно использовать для генерации случайных скалярных числовых значений и данных.

• Для генерации массива случайных чисел необходимо использовать numpy.random();
• В модуле numpy есть пакет numpy.random, который содержит обширный набор функций для генерации случайных n-мерных массивов для различных распределений.

Рассмотрим несколько примеров использования numpy.random в Python.

Генерация случайного n-мерного массива вещественных чисел

• Использование numpy.random.rand() для генерации n-мерного массива случайных вещественных чисел в пределах [0.0, 1.0)
• Использование numpy.random.uniform() для генерации n-мерного массива случайных вещественных чисел в пределах [low, high)

import numpy


random_float_array = numpy.random.rand(2, 2)
print(«2 X 2 массив случайных вещественных чисел в [0.0, 1.0] \n», random_float_array,»\n»)

random_float_array = numpy.random.uniform(25.5, 99.5, size=(3, 2))
print(«3 X 2 массив случайных вещественных чисел в [25.5, 99.5] \n», random_float_array,»\n»)

Вывод:

2 X 2 массив случайных вещественных чисел в [0.0, 1.0]
[[0.08938593 0.89085866]
[0.47307169 0.41401363]]

3 X 2 массив случайных вещественных чисел в [25.5, 99.5]
[[55.4057854 65.60206715]
[91.62185404 84.16144062]
[44.348252 27.28381058]]

Генерация случайного n-мерного массива целых чисел

Для генерации случайного n-мерного массива целых чисел используется numpy.random.random_integers():

import numpy


random_integer_array = numpy.random.random_integers(1, 10, 5)
print(«1-мерный массив случайных целых чисел \n», random_integer_array,»\n»)

random_integer_array = numpy.random.random_integers(1, 10, size=(3, 2))
print(«2-мерный массив случайных целых чисел \n», random_integer_array)

Вывод:

1-мерный массив случайных целых чисел
[10 1 4 2 1]

2-мерный массив случайных целых чисел
[[ 2 6]
[ 9 10]
[ 3 6]]

Выбор случайного элемента из массива чисел или последовательности

• Использование numpy.random.choice() для генерации случайной выборки;
• Использование данного метода для получения одного или нескольких случайных чисел из n-мерного массива с заменой или без нее.

Рассмотрим следующий пример:

import numpy


array =[10, 20, 30, 40, 50, 20, 40]
single_random_choice = numpy.random.choice(array, size=1)
print(«один случайный выбор из массива 1-D», single_random_choice)

multiple_random_choice = numpy.random.choice(array, size=3, replace=False)
print(«несколько случайных выборов из массива 1-D без замены», multiple_random_choice)

multiple_random_choice = numpy.random.choice(array, size=3, replace=True)
print(«несколько случайных выборов из массива 1-D с заменой», multiple_random_choice)

Вывод:

один случайный выбор из массива 1-D [40]
несколько случайных выборов из массива 1-D без замены [10 40 50]
несколько случайных выборов из массива 1-D с заменой [20 20 10]

В будущих статьях будут описаны другие функции пакета random из nympy и способы их использования.

Генерация случайных универсально уникальных ID

Модуль Python UUID предоставляет неизменяемые UUID объекты. UUID является универсально уникальным идентификатором.

У модуля есть функции для генерации всех версий UUID. Используя функцию uuid.uuid4(), можно получить случайно сгенерированное уникальное ID длиной в 128 битов, которое к тому же является криптографически надежным.

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

Пример использования uuid.uuid4() в Python:

import uuid


# получить уникальный UUID
safeId = uuid.uuid4()
print(«безопасный уникальный id «, safeId)

Вывод:

безопасный уникальный id fb62463a-cd93-4f54-91ab-72a2e2697aff

Игра в кости с использованием модуля random в Python

Далее представлен код простой игры в кости, которая поможет понять принцип работы функций модуля random. В игре два участника и два кубика.

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

Код программы для игры в кости Python:

import random


PlayerOne = «Анна»
PlayerTwo = «Алекс»

AnnaScore = 0
AlexScore = 0

# У каждого кубика шесть возможных значений
diceOne = [1, 2, 3, 4, 5, 6]
diceTwo = [1, 2, 3, 4, 5, 6]

def playDiceGame():
«»»Оба участника, Анна и Алекс, бросают кубик, используя метод shuffle»»»

for i in range(5):
#оба кубика встряхиваются 5 раз
random.shuffle(diceOne)
random.shuffle(diceTwo)
firstNumber = random.choice(diceOne) # использование метода choice для выбора случайного значения
SecondNumber = random.choice(diceTwo)
return firstNumber + SecondNumber

print(«Игра в кости использует модуль random\n»)

#Давайте сыграем в кости три раза
for i in range(3):
# определим, кто будет бросать кости первым
AlexTossNumber = random.randint(1, 100) # генерация случайного числа от 1 до 100, включая 100
AnnaTossNumber = random.randrange(1, 101, 1) # генерация случайного числа от 1 до 100, не включая 101

if( AlexTossNumber > AnnaTossNumber):
print(«Алекс выиграл жеребьевку.»)
AlexScore = playDiceGame()
AnnaScore = playDiceGame()
else:
print(«Анна выиграла жеребьевку.»)
AnnaScore = playDiceGame()
AlexScore = playDiceGame()

if(AlexScore > AnnaScore):
print («Алекс выиграл игру в кости. Финальный счет Алекса:», AlexScore, «Финальный счет Анны:», AnnaScore, «\n»)
else:
print(«Анна выиграла игру в кости. Финальный счет Анны:», AnnaScore, «Финальный счет Алекса:», AlexScore, «\n»)

Модуль random | Python 3 для начинающих и чайников

Модуль random предоставляет функции для генерации случайных чисел, букв, случайного выбора элементов последовательности.

random.seed([X], version=2) — инициализация генератора случайных чисел. Если X не указан, используется системное время.

random.getstate() — внутреннее состояние генератора.

random.setstate(state) — восстанавливает внутреннее состояние генератора. Параметр state должен быть получен функцией getstate().

random.getrandbits(N) — возвращает N случайных бит.

random.randrange(start, stop, step) — возвращает случайно выбранное число из последовательности.

random.randint(A, B) — случайное целое число N, A ≤ N ≤ B.

random.choice(sequence) — случайный элемент непустой последовательности.

random.shuffle(sequence, [rand]) — перемешивает последовательность (изменяется сама последовательность). Поэтому функция не работает для неизменяемых объектов.

random.sample(population, k) — список длиной k из последовательности population.

random.random() — случайное число от 0 до 1.

random.uniform(A, B) — случайное число с плавающей точкой, A ≤ N ≤ B (или B ≤ N ≤ A).

random.triangular(low, high, mode) — случайное число с плавающей точкой, low ≤ N ≤ high. Mode — распределение.

random.betavariate(alpha, beta) — бета-распределение. alpha>0, beta>0. Возвращает от 0 до 1.

random.expovariate(lambd) — экспоненциальное распределение. lambd равен 1/среднее желаемое. Lambd должен быть отличным от нуля. Возвращаемые значения от 0 до плюс бесконечности, если lambd положительно, и от минус бесконечности до 0, если lambd отрицательный.

random.gammavariate(alpha, beta) — гамма-распределение. Условия на параметры alpha>0 и beta>0.

random.gauss(значение, стандартное отклонение) — распределение Гаусса.

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

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

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

random.paretovariate(alpha) — распределение Парето.

random.weibullvariate(alpha, beta) — распределение Вейбулла.

Все довольно просто, и теперь вы можете генерировать случайные числа и последовательности. Удачи в ваших изысканиях!

функции библиотеки и примеры на Python 3

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

Что такое случайные числа?

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

Стоит заметить, что стандартные средства Python не способны предоставлять в программе истинно случайные значения. Они предоставляют псевдо случайную последовательность. Инициализируется она от какого либо случайного числа. То есть если мы будем инициализировать последовательность одним и тем же числом, то она будет каждый раз выдавать одинаковые данные. Чтобы этого не было, для инициализации берется значение системных часов.

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

Так что обычно используется метод генерации псевдослучайных величин с иницилизацией от системных часов.

Реализации случайных чисел в Python

Язык программирования Python содержит в себе несколько разных модулей, применяемых для генерации псевдослучайных величин. Все они, как правило, используют в своих целях текущее системное время, которое установлено на компьютере. Это гарантирует получение разных последовательностей значений при каждом новом обращении к генератору. Среди инструментов, которые предназначены для работы с псевдослучайными числами, находится довольно обширная библиотека random, а также функции numpy.random и os.urandom.

Особенности их применения:

• Стандартный модуль random в Python 3 включает множество методов для генерации как целых, так и вещественных чисел, а также последовательностей с определенными параметрами.
• Функция numpy.random используется для заполнения массивов случайными величинами.
• Функция os.urandom предоставляет набор из случайных байтов, что применимо в криптографии.

В модуле random есть класс SystemRandom, внутри реализации которого идет обращение как раз к os.urandom. В этом альтернативном генераторе реализованы те же функции, но их уже можно применять в криптографии.

Наиболее широкое применение получила в Python библиотека random. Поэтому далее мы ее и рассмотрим подробно.

Модуль random

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

Здесь хотелось бы описать функцию seed. Она как раз и применяется для задания инициализирующего числа псевдо случайной последовательности. При вызове seed без параметра, берется значение системного таймера. Эта функция вызывается в конструкторе класса Random.

В примерах мы рассмотрим, как применяются основные функции. А так же в конце рассмотрим как используется SystemRandom.

Примеры

Чтобы воспользоваться возможностями генерации случайных чисел в Python 3, следует произвести импорт библиотеки random, вынеся ее в начало исполняемого файла при помощи ключевого слова import.

Вещественные числа

В модуле есть одноименная функция random. В Python она используется чаще, чем другие функции этого модуля. Функция возвращает вещественное число в промежутке от 0 до 1. В следующем примере демонстрируется создание трех разных переменных a, b и c.

import random
a = random.random()
b = random.random()
print(a)
print(b)

0.547933286519
0.456436031781

Целые числа

Для получения случайных целых чисел в определенном диапазоне используется функция randint, принимающая два аргумента: минимальное и максимальное значение. Программа, показанная ниже отображает генерацию трех разных значений в промежутке от 0 до 9.

import random
a = random.randint(0, 9)
b = random.randint(0, 9)
print(a)
print(b)

4
7

Диапазоны целых

Метод randrange позволяет генерировать целочисленные значения, благодаря работе с тремя параметрами: минимальная и максимальная величина, а также длина шага. Вызвав функцию с одним аргументом, начальная граница получит значение 0, а интервал станет равен 1. Для двух аргументов автоматически инициализируется только длина шага. Работа данного метода с трема разными наборами параметров показана в следующем примере.

import random
a = random.randrange(10)
b = random.randrange(2, 10)
c = random.randrange(2, 10, 2)
print(a)
print(b)
print(c)

9
5
2

Диапазоны вещественных

Сгенерировать вещественное число поможет метод под названием uniform. Он принимает всего два аргумента, обозначающих минимальное и максимальное значения. Демонстрация его работы располагается в следующем примере кода, где создаются переменные a, b и c.

import random
a = random.uniform(0, 10)
b = random.uniform(0, 10)
print(a)
print(b)

4.85687375091
3.66695202551

Использование в генераторах

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

import random
a = [random.randint(0, 9) for i in range(random.randint(0, 9))]
print(a)

[4, 1, 8, 6, 6, 9, 7]

Перемешивание

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

import random
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
random.shuffle(a)
print(a)

[3, 9, 0, 7, 6, 2, 5, 1, 8, 4]

Случайный элемент списка

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

import random
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b = random.choice(a)
print(b)

7

Несколько элементов списка

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

import random
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = random.sample(a, 5)
print(a)

[8, 0, 9, 4, 6]

Генерация букв

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

import random
import string
a = random.choice(string.letters)
b = random.choice(string.letters)
c = random.choice(string.letters)
print(a)
print(b)
print(c)

J
i
L

Как можно заметить, отображаются буквы в разном регистре. Для того чтобы преобразовать их к общему виду, рекомендуется вызвать стандартные строковые методы upper или lower.

SystemRandom

Как уже говорилось ранее, SystemRandom основана на os.urandom. Она выдает так же псевдослучайные данные, но они зависят дополнительно и от операционной системы. Результаты используются в криптографии. Есть недостаток – то что функции SystemRandom отрабатывают в несколько раз дольше. Рассмотрим пример использования:

import random
sr = random.SystemRandom()
a = sr.random()
b = sr.randint(0, 9)
c = sr.randrange(2, 10, 2)
print(a)
print(b)
print(c)

0.36012464614815465
2
8

Заключение

Таким образом, язык программирования Python содержит массу встроенных методов для генерации и обработки случайных значений. Пользоваться ими можно при помощи разных библиотек, входящих в стандартный набор инструментов платформы. Благодаря данным функциям можно задавать различные условия, а также ограничения для своих генераторов.

Python random — модуль для генерации случайных чисел ~ PythonRu

Этот модуль реализует генераторы псевдослучайных чисел под различные потребности.

Для целых чисел есть выбор одного из диапазона. Для последовательностей — выбор случайного элемента, функция случайной сортировки списка и функция случайного выбора нескольких элементов из последовательности.

Есть функции для вычисления однородных, нормальных (Гауссовских), логнормальных, отрицательных экспоненциальных, гамма и бета распределений. Для генерации распределений углов доступно распределение фон Мизеса.

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

Функции, предоставляемые этим модулем, связанны методами скрытого экземпляра класса random.Random. Так же можно создавать собственные экземпляры Random, для получения генераторов.

Класс Random может быть подклассом. Если вы хотите использовать другой базовый генератор своего собственного проекта: переопределите методы random (), seed (), getstate() и setstate(). Новый генератор может предоставить метод getrandbits(), что позволяет получить выборку randrange() по любому диапазону.

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

Предупреждение
Псевдослучайные генераторы этого модуля не должны использоваться в целях безопасности. Для обеспечения безопасности или для криптографического использования ознакомьтесь с модулем secrets.

Функции бухгалтерского учета

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

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

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

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

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

random.getrandbits(k)
Возвращает Python int со случайными битами k. Этот метод поставляется вместе с генератором MersenneTwister, в то время как другие генераторы могут также предоставлять его как необязательную часть API.
При возможности, getrandbits() включает randrange() для обработки диапазонов величины.

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

random.randrange(stop)
random.randrange(start, stop[, step])
Возвращает случайно выбранный элемент из range(start, stop, step). Это эквивалентно choice(range(start, stop, step)), но не создает объект диапазона.

Шаблон позиционного аргумента совпадает с шаблоном range(). Аргументы не должны использоваться как ключевого слова(start, stop, step), потому что функция может использовать их неожиданными способами.

random.randint(a, b)
Возвращает случайное целое число N так, чтобы a <= N <= b.

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

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. TypeError возникает, если не правильно указан аргумент weights или cum_weights.

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

random.shuffle(x[, random])
Перемешивает последовательность x на месте.
Необязательный аргумент random — функция 0-аргумента, возвращающая случайное значение float в [0.0, 1.0]; по умолчанию это функция random().
Чтобы перемешать неизменяемую последовательность и вернуть новый перемешанный список, используйте sample(x, k=len(x)).

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

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

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

Участники не должны быть hashable или уникальными. Если последовательность содержит повторы, то каждое вхождение является возможным выбором в выборке.

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

Если размер выборки больше длины последовательности, возникает ошибка ValueError.

Вещественные распределения

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

random.random()
Возвращает случайное число с плавающей точкой в диапазоне [0.0, 1.0).

random.uniform(a, b)
Возвращает случайное число с плавающей точкой N таким образом, чтобы a <= N <= b для a <= b и b <= N <= a для b < a.

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

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

random.betavariate(alpha, beta)
Бета-распределение. Условиями для аргументов являются alpha > 0 и beta > 0. Возвращаемые значения варьируются от 0 до 1.

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

random.gammavariate(alpha, beta)
Гамма-распределение (Не гамма-функция!). Условиями для параметров являются alpha > 0 и beta > 0.

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

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

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

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

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

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

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

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

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

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

Примеры и инструкции

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

>>> random()                             
0.37444887175646646

>>> uniform(2.5, 10.0)                   
3.1800146073117523

>>> expovariate(1 / 5)                   
5.148957571865031

>>> randrange(10)                        
7

>>> randrange(0, 101, 2)                 
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']
>>> 
>>> 
>>> 
>>> deck = collections.Counter(tens=16, low_cards=36)
>>> seen = sample(list(deck.elements()), k=20)
>>> seen.count('tens') / 20
0.15
>>> 
>>> 
>>> trial = lambda: choices('HT', cum_weights=(0.60, 1.00), k=7).count('H') >= 5
>>> sum(trial() for i in range(10000)) / 10000
0.4169
>>> 
>>> trial = lambda : 2500 <= sorted(choices(range(10000), k=5))[2]  < 7500
>>> sum(trial() for i in range(10000)) / 10000
0.7958

Генерация случайных чисел (модуль random) — Документация Python Summary 1

«Генерация случайных чисел слишком важна, чтобы оставлять её на волю случая»

—  Роберт Кавью

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

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

random.random

random.random() — возвращает псевдослучайное число от 0.0 до 1.0

random.random()
0.07500815468466127

random.seed

random.seed(<Параметр>) — настраивает генератор случайных чисел на новую последовательность. По умолчанию используется системное время. Если значение параметра будет одиноким, то генерируется одинокое число:

random.seed(20)
random.random()
0.9056396761745207

random.random()
0.6862541570267026

random.seed(20)
random.random()
0.9056396761745207

random.random()
0.7665092563626442

random.uniform

random.uniform(<Начало>, <Конец>) — возвращает псевдослучайное вещественное число в диапазоне от <Начало> до <Конец>:

random.uniform(0, 20)
15.330185127252884

random.uniform(0, 20)
18.092324756265473

random.randint

random.randint(<Начало>, <Конец>) — возвращает псевдослучайное целое число в диапазоне от <Начало> до <Конец>:

random.randint(1,27)
9
random.randint(1,27)
22

random.choince

random.choince(<Последовательность>) — возвращает случайный элемент из любой последовательности (строки, списка, кортежа):

random.choice('Chewbacca')
'h'
random.choice([1,2,'a','b'])
2
random.choice([1,2,'a','b'])
'a'

random.randrange

random.randrange(<Начало>, <Конец>, <Шаг>) — возвращает случайно выбранное число из последовательности.

random.shuffle

random.shuffle(<Список>) — перемешивает последовательность (изменяется сама последовательность). Поэтому функция не работает для неизменяемых объектов.

List = [1,2,3,4,5,6,7,8,9]
List
[1, 2, 3, 4, 5, 6, 7, 8, 9]
random.shuffle(List)
List
[6, 7, 1, 9, 5, 8, 3, 2, 4]

Вероятностные распределения

random.triangular(low, high, mode) — случайное число с плавающей точкой, low ≤ N ≤ high. Mode — распределение.

random.betavariate(alpha, beta) — бета-распределение. alpha>0, beta>0. Возвращает от 0 до 1.

random.expovariate(lambd) — экспоненциальное распределение. lambd равен 1/среднее желаемое. Lambd должен быть отличным от нуля. Возвращаемые значения от 0 до плюс бесконечности, если lambd положительно, и от минус бесконечности до 0, если lambd отрицательный.

random.gammavariate(alpha, beta) — гамма-распределение. Условия на параметры alpha>0 и beta>0.

random.gauss(значение, стандартное отклонение) — распределение Гаусса.

random.lo

генерация псевдослучайных чисел в Python

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

Стандартная библиотека Python содержит модуль random, в котором есть различные функции для работы со случайными числами.

random.seed([initializer]) – этот метод инициализирует генератор случайных чисел. Когда модуль random импортируется, генератор инициализируется с помощью системного времени. Чтобы повторно запустить генератор, используйте любой объект int, str, byte или bytearray. При помощи этого метода можно воспроизводить одну и ту же последовательность чисел любое количество раз. В примере ниже генератор случайных чисел инициализируется с помощью числа 2 и при каждом запуске программы мы будем получать одну и ту же последовательность чисел.

import random

random.seed(2)
random_number_1 = random.randint(1, 10)
random_number_2 = random.randint(1, 10)

print(random_number_1, random_number_2) # 1 2

random.getstate() — эта функция вместе с функцией setstate() помогает воспроизводить одни и те же случайные данные снова и снова. Функция getstate() возвращает внутреннее состояние генератора случайных чисел. Больше информации вы можете найти по ссылке.

random.setstate(state) — эта функция восстанавливает внутреннее состояние генератора.

Следующие функции предназначены для генерации случайных целых чисел:

random.randrange() − эта функция генерирует случайное целое число в пределах заданного диапазона чисел. Может принимать три параметра.

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

Параметры start и step являются необязательными. Их значения по умолчанию равны 0 и 1 соответственно. Шаг (step) определяет интервал между последовательными числами.

>>> random.randrange(10)
5
>>> random.randrange(10, 20)
17
>>> random.randrange(100, 200, 2)
188

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

random.randint(start, stop) — эта функция генерирует случайное целое число x, такое что start ≤ x ≤ stop. Это похоже на функцию randrange() без параметра step.

>>> random.randint(1,10)
6
>>> random.randint(100, 200)
134

Следующие функции работают со случайными числами с плавающей запятой:

random.random() — эта функция генерирует случайное число с плавающей запятой в диапазоне от 0.0  до 1.0.

>>> random.random()
0.668544544081956

random.uniform(start, stop) — эта функция возвращает случайное число x с плавающей запятой, такое что start ≤ x ≤ stop для start ≤ stop и stop ≤ x ≤ start для stop < start.

>>> random.uniform(0.5,1.5)
1.2760281470664903
>>> random.uniform(1,10)
7.336985794193224
>>> random.uniform(10,5)
7.817794757786727

Следующие функции работают c последовательностями, а именно — со строками, списками или кортежами:

random.choice() − эта функция выбирает случайный элемент из последовательности. Если последовательность пуста, то возникает ошибка IndexError.

>>> random.choice("Pythonist")
'o'
>>> random.choice(range(10))
2
>>> random.choice([15,31,6,29,55, 5])
55
>>> random.choice((15,31,6,29,25, 55))
15

random.choices() − эта функция случайным образом выбирает несколько элементов из списка. Первый параметр этой функции — последовательность, а второй — количество элементов, которые нужно вернуть. Возвращает список, в котором  может повторяться несколько раз один и тот же элемент.

>>> name = "Pythonist"
>>> random.choices(name, k = 2)
['s', 'n']

random.shuffle() — эта функция переупорядочивает (перемешивает) элементы в изменяемой (mutable) последовательности и размещает их случайным образом.

>>> num = [10,20,30,40,50]
>>> random.shuffle(num)
>>> num
[50, 20, 40, 30, 10]

random.sample(sequence, n)  — эта функция возвращает список случайно выбранных элементов из последовательности. Результирующий список содержит только уникальные элементы.

>>> name = "Pythonist"
>>> nm = random.sample(name, k = 5)
>>> name, nm
(Pythonist, ['n', 'P', 'y', 't', 'h'])

Более подробную информацию о функциях модуля random вы можете найти в документации.

Python | Модуль random

Последнее обновление: 02.05.2017

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

Модуль random

Модуль random управляет генерацией случайных чисел. Его основные функции:

• random(): генерирует случайное число от 0.0 до 1.0

• randint(): возвращает случайное число из определенного диапазона

• randrange(): возвращает случайное число из определенного набора чисел

• shuffle(): перемешивает список

• choice(): возвращает случайный элемент списка

Функция random() возвращает случайное число с плавающей точкой в промежутке от 0.0 до 1.0. Если же нам необходимо число из большего диапазона,
скажем от 0 до 100, то мы можем соответственно умножить результат функции random на 100.

import random

number = random.random()  # значение от 0.0 до 1.0
print(number)
number = random.random() * 100  # значение от 0.0 до 100.0
print(number)

Функция randint(min, max) возвращает случайное целое число в промежутке между двумя значениями min и max.

import random

number = random.randint(20, 35)  # значение от 20 до 35
print(number)

Функция randrange() возвращает случайное целое число из определенного набора чисел. Она имеет три формы:

• randrange(stop): в качестве набора чисел, из которых происходит извлечение случайного значения, будет использоваться диапазон от 0 до числа stop

• randrange(start, stop): набор чисел представляет диапазон от числа start до числа stop

• randrange(start, stop, step): набор чисел представляет диапазон от числа start до числа stop, при этом каждое число в диапазоне отличается от предыдущего на шаг step

import random

number = random.randrange(10)  # значение от 0 до 10
print(number)
number = random.randrange(2, 10)  # значение в диапазоне 2, 3, 4, 5, 6, 7, 8, 9, 10
print(number)
number = random.randrange(2, 10, 2)  # значение в диапазоне 2, 4, 6, 8, 10
print(number)

Работа со списком

Для работы со списками в модуле random определены две функции: функция shuffle() перемешивает список случайным образом, а
функция choice() возвращает один случайный элемент из списка:

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
random.shuffle(numbers)
print(numbers)  
random_number = random.choice(numbers)
print(random_number)

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

Исходный код: Lib / random.py

Этот модуль реализует генераторы псевдослучайных чисел для различных
раздачи.

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

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

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

Функции, предоставляемые этим модулем, на самом деле являются связанными методами скрытого
экземпляр класса random.Random . Вы можете создать свой собственный
экземпляры Random , чтобы получить генераторы, которые не разделяют состояние.

Класс Случайный также можно разделить на подклассы, если вы хотите использовать другой
базовый генератор по вашему усмотрению: в этом случае переопределите random () ,
seed () , getstate () и setstate () .При желании новый генератор может предоставить метод getrandbits () — это
позволяет randrange () производить выборки в произвольно большом диапазоне.

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

Предупреждение

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

См. Также

М. Мацумото и Т. Нисимура, «Мерсенн Твистер: 623-мерное
равнораспределенный генератор однородных псевдослучайных чисел », Транзакции ACM на
Моделирование и компьютерное моделирование Vol. 8, № 1, январь, стр. 3–30 1998.

Рецепт комплементарного умножения с переносом для совместимой альтернативы
генератор случайных чисел с длительным периодом и сравнительно простым обновлением
операции.

Бухгалтерские функции

случайный. семя ( a = нет , версия = 2 )

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

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

Если a является int, он используется напрямую.

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

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

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

случайный. getstate ()

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

случайный. setstate (состояние )

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

случайный. getrandbits ( k )

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

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

случайный. рандрейн ( стоп )

случайный. randrange ( начало , остановка [, шаг ])

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

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

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

случайный. рандинт ( a , b )

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

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

случайный. выбор ( seq )

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

случайный. вариантов ( население , веса = Нет , * , cum_weights = Нет , k = 1 )

Вернуть список элементов размером k , выбранных из генеральной совокупности с заменой.Если популяция пуста, возникает IndexError .

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

Если не указаны веса или cum_weights , выполняется выбор
с равной вероятностью. Если указана последовательность весов, она должна быть
той же длины, что и последовательность популяции . Это

.

9,6. random - Генерация псевдослучайных чисел - документация Python 2.7.18

Исходный код: Lib / random.py

Этот модуль реализует генераторы псевдослучайных чисел для различных
раздачи.

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

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

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

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

Класс Случайный также можно разделить на подклассы, если вы хотите использовать другой
базовый генератор по вашему усмотрению: в этом случае переопределите random () ,
seed () , getstate () , setstate () и
jumpahead () методов. По желанию новый генератор может поставлять
getrandbits () метод - это
позволяет randrange () производить выборки в произвольно большом диапазоне.

В качестве примера подкласса модуль random предоставляет
WichmannHill класс, реализующий альтернативный генератор в чистом виде.
Python.Класс предоставляет обратно совместимый способ воспроизведения результатов из
более ранние версии Python, которые использовали алгоритм Вичмана-Хилла в качестве ядра
генератор. Обратите внимание, что этот генератор Вихмана-Хилла больше нельзя рекомендовать:
его период слишком короткий по современным меркам, и генерируемая последовательность
известно, что они не проходят некоторые строгие тесты на случайность. См. Ссылки ниже для
последний вариант, который устраняет эти недостатки.

Изменено в версии 2.3: MersenneTwister заменил Wichmann-Hill в качестве генератора по умолчанию.

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

Предупреждение

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

Бухгалтерские функции:

случайный. семя ( a = нет )

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

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

Если a не None или int или long , то
Вместо него используется хэш (a) . Обратите внимание, что хеш-значения для некоторых типов
недетерминированы, если включен PYTHONHASHSEED .

Изменено в версии 2.4: ранее ресурсы операционной системы не использовались.

случайный. getstate ()

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

Изменено в версии 2.6: значения состояния, созданные в Python 2.6, не могут быть загружены в более ранние версии.

случайный. setstate (состояние )

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

случайный. Jumpahead ( n )

Измените внутреннее состояние на другое и, вероятно, далеко от
Текущее состояние. n - неотрицательное целое число, которое используется для шифрования
вектор текущего состояния. Это наиболее полезно в многопоточных программах, в
в сочетании с несколькими экземплярами класса Random :
setstate () или seed () можно использовать для принудительного включения всех экземпляров в
такое же внутреннее состояние, а затем можно использовать jumpahead () для принудительного
состояния экземпляров далеки друг от друга.

Изменено в версии 2.3: вместо перехода к определенному состоянию, n шагов вперед, jumpahead (n)
переход в другое состояние, вероятно, будет разделен множеством шагов.

случайный. getrandbits ( k )

Возвращает python long int с k случайными битами. Этот метод предоставляется
с генератором MersenneTwister, и некоторые другие генераторы также могут предоставить его
как необязательная часть API. Если доступно, getrandbits () включает
randrange () для обработки сколь угодно больших диапазонов.

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

случайный. рандрейн ( стоп )

случайный. randrange ( start , stop [, step ])

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

случайный. рандинт ( a , b )

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

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

случайный. выбор ( seq )

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

случайный. в случайном порядке ( x [,

.

Случайный модуль Python

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

Модуль random имеет набор методов:

.

Случайное число Python - пошаговое руководство для начинающих

Вот краткое руководство по случайным числам Python. Вы всегда можете обратиться к нему, когда вам нужно сгенерировать случайное число в ваших программах.

Python имеет для этой цели встроенный модуль random. Он предоставляет несколько методов, таких как randrange (), randint (), random (), seed (), uniform () и т. Д. Вы можете вызвать любую из этих функций для генерации случайного числа Python.

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

Учебное пособие по случайным числам на Python для начинающих

Python генератор случайных чисел

Генератор случайных чисел Python - это детерминированная система, которая производит псевдослучайные числа. Он использует алгоритм Mersenne Twister, который может генерировать список случайных чисел.

Детерминированный алгоритм всегда возвращает один и тот же результат для одного и того же входа.

На сегодняшний день это наиболее успешный метод ГПСЧ, реализованный в различных языках программирования.

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

Давайте теперь рассмотрим несколько реальных примеров генерации случайных целых чисел и чисел с плавающей запятой.

Randrange () для генерации случайного числа

Функция randrange () доступна в модуле Python random. Это заставляет вас производить случайное число из заданного диапазона значений.

У этой функции есть три варианта:

Синтаксис

 # randrange () со всеми тремя аргументами
random.randrange (начало, конец, счетчик шагов) 

При использовании этой формы randrange () вы должны передать значения start, stop и step.

 # randrange () с первыми двумя аргументами
random.randrange (начало, конец) 

В этой форме вы указываете запуск и остановку, а значение по умолчанию (= 1) используется в качестве счетчика шагов.

 # randrange () с одним аргументом
случайный.randrange (конец) 

Вам нужно передать только конечную точку диапазона. Значение (= 0) считается начальной точкой и значением по умолчанию (= 1) для счетчика шагов.

Также обратите внимание, что конечное / конечное значение исключается при генерации случайного числа. И эта функция вызывает исключение ValueError в следующих случаях:

• Если вы использовали плавающий диапазон для запуска / остановки / шага.
• Или если начальное значение больше конечного значения.

Давайте теперь рассмотрим несколько примеров.

Случайное число Python от 0 до 100

 импорт случайный как ранд

# Генерация случайного числа от 0 до 100

# Передаем все три аргумента в randrange ()
print ("Первое случайное число:", rand.randrange (0, 100, 1))

# Передаем первые два аргумента в randrange ()
print ("Второе случайное число:", rand.randrange (0, 100)) # Шаг по умолчанию = 1

# Или вы можете передать только начальный аргумент
print ("Третье случайное число:", rand.randrange (100)) # По умолчанию start = 0, step = 1 

Вывод:

 Первое случайное число: 3
Второй случайный номер: 36
Третий случайный номер: 60 

Случайное число Python от 1 до 99

 импорт случайный как ранд

# Генерация случайного числа от 1 до 99

# Передаем все три аргумента в randrange ()
print ("Первое случайное число:", rand.рандом (1, 99, 1))

# Передаем первые два аргумента в randrange ()
print ("Второе случайное число:", rand.randrange (1, 99)) # Шаг по умолчанию = 1 

Результат:

 Первое случайное число: 18
Второй случайный номер: 77 

Randint () для включающего диапазона

Функция randint () чем-то похожа на функцию randrange (). Он также генерирует случайное целое число из диапазона. Однако немного отличается:

• Randint () имеет два обязательных аргумента: start и stop
• Он имеет инклюзивный диапазон, т.е.е., может возвращать обе конечные точки в качестве случайного вывода.

Синтаксис

 # функция randint () случайного модуля
random.randint (начало, остановка) 

Эта функция учитывает как начальное, так и конечное значения при генерации случайного вывода.

Randint () пример генератора случайных чисел

 импорт случайный как ранд

# Генерация случайного числа с помощью randint ()

# Простой пример randint ()
print («Создать первое случайное число:», rand.randint (10, 100))

# randint () вместе с seed ()
ранд.семя (10)
print («Создать второе случайное число:», rand.randint (10, 100))

rand.seed (10)
print («Повторить второе случайное число:», rand.randint (10, 100)) 

Результат:

 Сгенерировать первое случайное число: 14
Сгенерировать второе случайное число: 83
Повторить второе случайное число: 83 

Random () для генерации случайного числа с плавающей запятой

Это одна из самых основных функций модуля Python random. Он вычисляет случайное число с плавающей запятой от 0 до 1.

Эта функция имеет следующий синтаксис:

Синтаксис

 # функция random () для генерации числа с плавающей запятой
random.random () 

Генерировать случайное число с плавающей запятой от 0 до 1

 импорт случайный как ранд

# Генерация случайного числа от 0 до 1

# Генерация первого случайного числа
print ("Первое случайное число:", rand.random ())

# Сгенерировать второе случайное число
print ("Второе случайное число:", rand.random ()) 

После выполнения выводится следующий результат:

 Первое случайное число: 0.6448613829842063
Второй случайный номер: 0,9482605596764027 

Seed () для повторения случайного числа

Метод seed () позволяет сохранить состояние функции random (). Это означает, что как только вы устанавливаете начальное значение и вызываете random (). Затем Python сопоставляет данное начальное число с результатом этой операции.

Итак, всякий раз, когда вы звоните

.