Как найти случайное число в питоне

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

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

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

[1] Википедия: Генератор псевдослучайных чисел
[2] Доусон М. Программируем на Python. — СПб.: Питер, 2014. — 416 с.: ил. — 3-е изд

Модуль 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.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) — распределение Вейбулла.

Примеры¶

Генерация произвольного пароля¶

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

import random
# Щепотка цифр
str1 = '123456789'
# Щепотка строчных букв
str2 = 'qwertyuiopasdfghjklzxcvbnm'
# Щепотка прописных букв. Готовится преобразованием str2
в верхний     регистр.
str3 = str2.upper()
print(str3)
# Выведет: 'QWERTYUIOPASDFGHJKLZXCVBNM'

# Соединяем все строки в одну
str4 = str1+str2+str3
print(str4)
# Выведет: '123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'

# Преобразуем получившуюся строку в список
ls = list(str4)
# Тщательно перемешиваем список
random.shuffle(ls)
# Извлекаем из списка 12 произвольных значений
psw = ''.join([random.choice(ls) for x in range(12)])
# Пароль готов
print(psw)
# Выведет: '1t9G4YPsQ5L7'

Этот же скрипт можно записать всего в две строки:

import random
print(''.join([random.choice(list('123456789qwertyuiopasdfghjklzxc
vbnmQWERTYUIOPASDFGHJKLZXCVBNM')) for x in range(12)]))

Данная команда является краткой записью цикла for, вместо неё можно было написать так:

import random
psw = '' # предварительно создаем переменную psw
for x in range(12):
    psw = psw + random.choice(list('123456789qwertyuiopasdfgh
jklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'))

print(psw)
# Выведет: Ci7nU6343YGZ

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

Ссылки¶

  • Официальная документация по модулю random (англ.)
  • Python 3 для начинающих: Модуль random
  • Модуль random — генерация случайных чисел
  • Безопасность случайных чисел в Python
Источник

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

Содержание

  • Как использовать модуль random в Python
  • Генерация случайных чисел в Python
  • Выбор случайного элемента из списка
  • Python функции модуля random
  • Случайное целое число — randint(a, b)
  • Генерация случайного целого числа — randrange()
  • Выбор случайного элемента из списка choice()
  • Метод sample(population, k)
  • Случайные элементы из списка — choices()
  • Генератор псевдослучайных чисел — seed()
  • Перемешивание данных — shuffle()
  • Генерации числа с плавающей запятой — uniform()
  • triangular(low, high, mode)
  • Генератор случайной строки в Python
  • Криптографическая зашита генератора случайных данных в Python
  • getstate() и setstate() в генераторе случайных данных Python
  • Состояние генератора getstate()
  • Восстанавливает внутреннее состояние генератора — setstate()
  • Зачем нужны функции getstate() и setstate()
  • Numpy.random — Генератор псевдослучайных чисел
  • Генерация случайного n-мерного массива вещественных чисел
  • Генерация случайного n-мерного массива целых чисел
  • Выбор случайного элемента из массива чисел или последовательности
  • Генерация случайных универсально уникальных ID
  • Игра в кости с использованием модуля random в Python

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

Метод Описание
seed() Инициализация генератора случайных чисел
getstate() Возвращает текущее внутренне состояние (state) генератора случайных чисел
setstate() Восстанавливает внутреннее состояние (state) генератора случайных чисел
getrandbits() Возвращает число, которое представляет собой случайные биты
randrange() Возвращает случайное число в пределах заданного промежутка
randint() Возвращает случайное число в пределах заданного промежутка
choice() Возвращает случайный элемент заданной последовательности
choices() Возвращает список со случайной выборкой из заданной последовательности
shuffle() Берет последовательность и возвращает ее в перемешанном состоянии
sample() Возвращает заданную выборку последовательности
random() Возвращает случайное вещественное число в промежутке от 0 до 1
uniform() Возвращает случайное вещественное число в указанном промежутке
triangular() Возвращает случайное вещественное число в промежутке между двумя заданными параметрами. Также можно использовать параметр mode для уточнения середины между указанными параметрами
betavariate() Возвращает случайное вещественное число в промежутке между 0 и 1, основываясь на Бета-распределении, которое используется в статистике
expovariate() Возвращает случайное вещественное число в промежутке между 0 и 1, или же между 0 и -1, когда параметр отрицательный. За основу берется Экспоненциальное распределение, которое используется в статистике
gammavariate() Возвращает случайное вещественное число в промежутке между 0 и 1, основываясь на Гамма-распределении, которое используется в статистике
gauss() Возвращает случайное вещественное число в промежутке между 0 и 1, основываясь на Гауссовом распределении, которое используется в теории вероятности
lognormvariate() Возвращает случайное вещественное число в промежутке между 0 и 1, основываясь на Логнормальном распределении, которое используется в теории вероятности
normalvariate() Возвращает случайное вещественное число в промежутке между 0 и 1, основываясь на Нормальном распределении, которое используется в теории вероятности
vonmisesvariate() Возвращает случайное вещественное число в промежутке между 0 и 1, основываясь на распределении фон Мизеса, которое используется в направленной статистике
paretovariate() Возвращает случайное вещественное число в промежутке между 0 и 1, основываясь на распределении Парето, которое используется в теории вероятности
weibullvariate() Возвращает случайное вещественное число в промежутке между 0 и 1, основываясь на распределении Вейбулла, которое используется в статистике

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

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

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

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

Для достижения перечисленных выше задач модуль 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().

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

  • randint()
  • randrange()

В следующем примере показано, как получить случайно сгенерированное число в промежутке между 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‘xaexa0x91*.xb6xa1x05=xf7+>r;Yxc3’

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

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

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

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

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

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

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

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

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

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

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

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:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

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(«Игра в кости использует модуль randomn»)

#Давайте сыграем в кости три раза

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

Анна выиграла жеребьевку.

Анна выиграла игру в кости. Финальный счет Анны: 5 Финальный счет Алекса: 2

Анна выиграла жеребьевку.

Анна выиграла игру в кости. Финальный счет Анны: 10 Финальный счет Алекса: 2

Алекс выиграл жеребьевку.

Анна выиграла игру в кости. Финальный счет Анны: 10 Финальный счет Алекса: 8

Вот и все. Оставить комментарии можете в секции ниже.

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

E-mail: vasile.buldumac@ati.utm.md

Образование
Universitatea Tehnică a Moldovei (utm.md)

  • 2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
  • 2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»
Источник

Содержание:развернуть

  • Как работают случайные числа
  • Модуль random

  • Случайные целые числа (int)

  • Случайные вещественные числа (float)

  • Случайные элементы из последовательности

  • Управление генератором

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

  • Best practices

  • Случайная задержка (random sleep)

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

  • Случайный пароль

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

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

Как работают случайные числа

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

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

Чтобы понять, как работают генераторы псевдослучайных чисел, рассмотрим работу одного из первых подобных генераторов. Его алгоритм работы был разработан Нейманом. В нем первое число возводят в квадрат, а потом из полученного результата берут средние цифры. Например, первое число 281, возводим его в квадрат, получаем 78961 и берем три цифры, находящиеся в середине – 896. После этого для генерации следующего числа используем 896.

Модуль random

В модуле random реализованы различные генераторы псевдослучайных чисел. Здесь присутствуют методы, с помощью которых можно получить равномерное, Гауссовское, бета и гамма распределения и другие функции. Практически все они зависят от метода random(). В Python, в качестве основного, используется генератор псевдослучайных чисел Mersenne Twister, который выдает 53-х битные вещественные числа.

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

import random

После этого можно вызывать методы модуля random:

random.randint(0, 125)

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

Случайные целые числа (int)

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

randint
Функция randint(a, b) получает на вход два целых числа и возвращает случайное значение из диапазона [a, b] (a и b входят в этот диапазон).

import random

random_number = random.randint(0, 125)
print(random_number)

> 113

randrange
В функцию randrange(start, stop[, step]) передают три целых числа:

  • start – начало диапазона (входит в последовательность);
  • stop – конец диапазона (в последовательность не входит);
  • step – шаг генерации (если на его месте написать 0, получим ошибку «ValueError»).

На выходе функция выдает случайное число в заданном диапазоне.

import random

random_number = random.randrange(1, 100, 2)
print(random_number)

> 43

Случайные вещественные числа (float)

Перечислим функции, которые выдают вещественные числа.

random
Функция random() выдает вещественные числа, в диапазоне [0.0, 1.0) (включая 0.0, но не включая 1.0).

import random

random_number = random.random()
print(random_number)

> 0.47673250896173136

uniform
Сгенерировать число с плавающей точкой можно с помощью функции uniform(a, b). При этом полученное число будет в диапазоне [a, b) или [a, b] (a входит в диапазон, а вхождение b зависит от округления).

import random

random_number = random.uniform(7.3, 10.5)
print(random_number)

> 10.320165816501492

Случайные элементы из последовательности

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

choice
С помощью функции choice(seq) можно выбрать один элемент из набора данных. В качестве единственного аргумента в функцию передаётся последовательность. Если последовательность будет пустой (то есть в ней не будет ни одного элемента), получим ошибку «IndexError».

import random

seq = [10, 11, 12, 13, 14, 15]
random_element = random.choice(seq)
print(random_element)

> 12

choices
С помощью функции choices(seq [, weights, cum_weights, k]) можно выбрать 1 или несколько элементов из набора данных. weights, cum_weights и k — необязательные параметры.

  • weights — список относительных весов;
  • cum_weights — список кумулятивных (совокупных) весов, например weights [10, 5, 30, 5] эквивалентен cum_weights [10, 15, 45, 50].
  • k — длина возвращаемого списка (она может быть больше длины переданной последовательности и элементы могут дублироваться).

import random

seq = [1, 2, 3, 4, 5, 6]
random_elements = random.choices(seq, weights=[20, 1.1, 1, 2.1, 10, 1], k=4)
print(random_elements)

> [5, 1, 1, 5]

shuffle
Перемешать элементы набора данных можно с помощью функции shuffle(x[, random]).

  • х — последовательность;
  • random (необязательный параметр) — задает метод вероятностных распределений. Этот параметр не рекомендуется использовать в версии Python 3.9, а в версии 3.11 его поддержка будет прекращена.

shuffle перемешивает переданную последовательность, и возвращает None.

import random

seq = ["Cappuccino", "Latte", "Espresso", "Americano"]
random.shuffle(seq)
print(seq)

> ['Espresso', 'Americano', 'Latte', 'Cappuccino']

sample
Чтобы выбрать какое-то количество элементов из набора данных можно воспользоваться функцией sample(х, k).

  • х — последовательность;
  • k — количество элементов новой подпоследовательности.

На выходе получаем k уникальных случайных элементов из последовательности.

Если в исходной последовательности есть неуникальные (повторяющиеся) элементы, то каждый их них может появиться в новом списке.

import random

seq = [10, 11, 12, 11, 14, 11]
random_seq = random.sample(seq, 4)
print(random_seq)

> [10, 11, 11, 14]

Управление генератором

Генерация чисел в Python не совсем случайна и зависит от состояния генератора случайных чисел. Рассмотрим функции, с помощью которых можно управлять состоянием этого генератора.

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

import random

print(random.getstate())

> (3, (2147483648, 3570748448, 2839542888, 4273933825, 4291584237, ...

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

import random

state = random.getstate() # сохраняем текущее состояние генератора
random_number_1 = random.random() # получаем случайное число
print(random_number_1)
# > 0.42164837822065193 # первое случайное число

random_number_2 = random.random()
print(random_number_2)
# > 0.2486825504535808 # второе случайное число

random.setstate(state) # восстанавливаем состояние генератора
random_number_3 = random.random() # снова генерируем число
print(random_number_3)
# > 0.42164837822065193 # новое число равное первому, сгенерированному с тем же состояние генератора

seed
Генератору случайных чисел нужно число, основываясь на котором он сможет начать генерировать случайные значения.

Задать начальное значение можно с помощью метода seed(a=None, version=2).

  • а — начальное число, с которого начинается генерация. Этот параметр не обязательный. Если он не задан, используется текущее системное время (или доступный механизм генерации, предоставляемый ОС);
  • version — стратегия интерпретации первого аргумента. По умолчанию используется версия 2, при которой str, bytes и bytearray преобразуются в int. Версия 1 (используется для совместимости со старыми версиями Python) и в ней для str и bytes генерирует более узкий диапазон начальных значений.

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

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

Для наглядности рассмотрим самое распространенное нормальное распределение вероятностей. На рисунке ниже приведена кривая нормального распределения.

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

  • triangular(a, b, mode) — генерирует случайное вещественное число, находящееся в диапазоне от a до b. По умолчанию эти параметры равны: а = 0, b = 1. Третий параметр mode задает среднюю точку вероятности распределения. (подробнее про треугольное распределение тут).
  • betavariate(alpha, beta) — генерирует случайные числа соответствующие параметрам бета-распределения. Возвращаемые значения лежат в диапазоне от 0 до 1.
  • expovariate(lambd) — можно получить случайные значения, соответствующие экспоненциальному распределению. Если lambd положительное, то на выходе будут значения от 0 до +∞, а если отрицательное, то от -∞ до 0.
  • gammavariate(alpha, beta) — на выходе получаются случайные числа, соответствующие гамма распределению. Параметры alpha и beta, передаваемые в функцию должны быть больше 0.
  • gauss(mu, sigma) — на выходе получаются случайные числа, которые соответствуют Гауссовому распределению. В этот метод передаются два параметра: mu — среднее значение и sigma — среднеквадратичное отклонение.
  • lognormvariate(mu, sigma) — генерирует случайные значения соответствующие логарифму нормального распределения. То есть если вычислить натуральный логарифм полученного распределения, то в результате получится нормальное распределение с параметрами mu (среднее) и sigma (среднеквадратичное отклонение).
  • normalvariate(mu, sigma) — предназначен для генерации случайных значений подчиняющихся закону нормального распределения. В качестве параметров передаются: mu — среднее распределения и sigma — стандартное отклонение.
  • vonmisesvariate(mu, kappa) — используется для возврата случайного числа с плавающей запятой с распределением фон Мизеса (или круговым нормальным распределением).
  • paretovariate(alpha) — выдает случайные числа, соответствующие распределению Парето. Параметр alpha задает форму.
  • weibullvariate(alpha, beta) — Значения, выдаваемые weibullvariate соответствуют распределению Вейбулла. Параметр alpha задает масштаб, а beta форму.

💭 Ознакомиться со всеми функциями модуля random можно на официальном сайте Python в разделе документация.

Best practices

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

Случайная задержка (random sleep)

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

import random
import time

page_list = ["site.ru/page1", "site.ru/page2", "site.ru/page3"]

for page in page_list:
#
# some actions
#
time.sleep(random.randint(1, 3)) # задержка от 1 до 3 секунд

💭 Для имитации действий человека можно использовать random.uniform(1, 3) — это добавит случайные миллисекунды к вашим задержкам.

Случайны элемент из списка (с учетом веса)

Дано: веб-сайт. В базе данных 4 баннера, к каждому баннеру указан вес (приоритет к показу).

Необходимо рандомно показывать на сайте 1 баннер, в зависимости от его веса.

import random

# данные из БД
hero_banners = [
{
"id": 1,
"name": "SupermanBanner",
"weight": 5,
},
{
"id": 2,
"name": "BatmanBanner",
"weight": 40,
},
{
"id": 3,
"name": "FlashBanner",
"weight": 5,
},
{
"id": 4,
"name": "AquamanBanner",
"weight": 40,
}
]

banner_weights = [banner['weight'] for banner in hero_banners]
my_banner = random.choices(hero_banners, banner_weights)[0]
print(my_banner)

> {'id': 2, 'name': 'BatmanBanner', 'weight': 40}

Случайный пароль

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

import random
import string

pwd_length = 0
while pwd_length < 12:
pwd_length = int(input('Укажите длину пароля (от 12 символов): '))

# набор данных (заглавные и строчные буквы, цифры, символы пунктуации)
UPPERCASE_CHARACTERS = string.ascii_uppercase
LOWERCASE_CHARACTERS = string.ascii_lowercase
DIGITS = string.digits
SYMBOLS = string.punctuation

# весь набор
combined_list = UPPERCASE_CHARACTERS + LOWERCASE_CHARACTERS + DIGITS + SYMBOLS

# случайный элемент из каждого набора
rand_upper = random.choice(UPPERCASE_CHARACTERS)
rand_lower = random.choice(LOWERCASE_CHARACTERS)
rand_digit = random.choice(DIGITS)
rand_symbol = random.choice(SYMBOLS)

#
temp_pwd = random.sample(combined_list, pwd_length - 4) + [rand_upper, rand_lower, rand_digit, rand_symbol]
random.shuffle(temp_pwd)
password = "".join(temp_pwd)

print(password)

> Укажите длину пароля (от 12 символов): 12
> JFyc;6-ICxuQ

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

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

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

  • numpy.random — как random, но для массивов;
  • os — в состав входит urandom() [криптографически безопасный];
  • secrets — модуль для генерации безопасных случайных чисел, байтов и строк [криптографически безопасный];
  • uuid — содержит нескольких функций для создания 128-битных идентификаторов [криптографически безопасный].

Источник

Python defines a set of functions that are used to generate or manipulate random numbers through the random module. 

Functions in the random module rely on a pseudo-random number generator function random(), which generates a random float number between 0.0 and 1.0. These particular type of functions is used in a lot of games, lotteries, or any application requiring a random number generation.

Let us see an example of generating a random number in Python using the random() function.

Python3

import random

num = random.random()

print(num)

Output: 

0.30078080420602904

Different Ways to Generate a Random Number in Python

There are a number of ways to generate a random numbers in Python using the functions of the Python random module. Let us see a few different ways.

Generating a Random number using choice()

Python random.choice() is an inbuilt function in the Python programming language that returns a random item from a list, tuple, or string.

Python3

import random

list1 = [1, 2, 3, 4, 5, 6]

print(random.choice(list1))

string = "striver"

print(random.choice(string))

Output:

5
t

Generating a Random Number using randrange()

The random module offers a function that can generate Python random numbers from a specified range and also allows room for steps to be included, called randrange().

Python3

import random

print("A random number from list is : ", end="")

print(random.choice([1, 4, 8, 10, 3]))

print("A random number from range is : ", end="")

print(random.randrange(20, 50, 3))

Output: 

A random number from list is : 4
A random number from range is : 41

Generating a Random number using seed()

Python random.seed() function is used to save the state of a random function so that it can generate some random numbers in Python on multiple executions of the code on the same machine or on different machines (for a specific seed value). The seed value is the previous value number generated by the generator. For the first time when there is no previous value, it uses the current system time.

Python3

import random

print("A random number between 0 and 1 is : ", end="")

print(random.random())

random.seed(5)

print("The mapped random number with 5 is : ", end="")

print(random.random())

random.seed(7)

print("The mapped random number with 7 is : ", end="")

print(random.random())

random.seed(5)

print("The mapped random number with 5 is : ", end="")

print(random.random())

random.seed(7)

print("The mapped random number with 7 is : ", end="")

print(random.random())

Output: 

A random number between 0 and 1 is : 0.510721762520941
The mapped random number with 5 is : 0.6229016948897019
The mapped random number with 7 is : 0.32383276483316237
The mapped random number with 5 is : 0.6229016948897019
The mapped random number with 7 is : 0.32383276483316237

Generating a Random number using shuffle()

The shuffle() function is used to shuffle a sequence (list). Shuffling means changing the position of the elements of the sequence. Here, the shuffling operation is in place.

Python3

import random

sample_list = ['A', 'B', 'C', 'D', 'E']

print("Original list : ")

print(sample_list)

random.shuffle(sample_list)

print("nAfter the first shuffle : ")

print(sample_list)

random.shuffle(sample_list)

print("nAfter the second shuffle : ")

print(sample_list)

Output:

Original list : 
['A', 'B', 'C', 'D', 'E']

After the first shuffle : 
['A', 'B', 'E', 'C', 'D']

After the second shuffle : 
['C', 'E', 'B', 'D', 'A']

Generating a Random number using uniform()

The uniform() function is used to generate a floating point Python random number between the numbers mentioned in its arguments. It takes two arguments, lower limit(included in generation) and upper limit(not included in generation).

Python3

import random

li = [1, 4, 5, 10, 2]

print("The list before shuffling is : ", end="")

for i in range(0, len(li)):

    print(li[i], end=" ")

print("r")

random.shuffle(li)

print("The list after shuffling is : ", end="")

for i in range(0, len(li)):

    print(li[i], end=" ")

print("r")

print("The random floating point number between 5 and 10 is : ", end="")

print(random.uniform(5, 10))

Output: 

The list before shuffling is : 1 4 5 10 2 
The list after shuffling is : 2 1 4 5 10 
The random floating point number between 5 and 10 is : 5.183697823553464

Last Updated :
05 May, 2023

Like Article

Save Article

Источник

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

В качестве лирического отступления следует сказать, что, согласно специфике внутреннего состояния генератора, модуль для Python под названием random позволяет сгенерировать не случайный, а псевдослучайный элемент, то есть значения и их последовательности формируются на основе формулы. Раз последовательность зависит от нескольких параметров, она не является случайной в полном смысле этого слова. Если нужна истинная случайность, генерация может основываться, к примеру, на принципах квантовой механики, однако на практике это слишком дорого и сложно, да и не всегда экономически целесообразно, ведь для многих задач программирования вполне подойдут и псевдослучайные генераторы (если речь идет не про онлайн-казино). Вдобавок к этому, случайность (randomness) — вещь капризная, поэтому, как тут не вспомнить прекрасное высказывание американского математика Роберта Кавью:

Также на ум приходит еще одно интересное высказывание, но уже от выдуманного персонажа и с некоторым уклоном в философию:

Применение random в Python

В языке программирования «Пайтон» модуль random позволяет реализовывать генератор псевдослучайных чисел для разных распределений, куда входят как целые (integers), так и вещественные числа, то есть числа с плавающей запятой.

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

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

Но прежде чем это сделать и иметь возможность полноценно использовать модуль, его надо импортировать. Делается это предельно просто: нужно прописать в начале кода import random.

random.random

У модуля random есть одноименный метод-тезка — функция random. Она возвращает случайное число в диапазоне 0 — 1.0:

import random

print("Выводим случайное число с помощью random.random():")

print(random.random())

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

Также вывести можно не одно, а, к примеру, три (three) числа (используется for i in range), причем прекрасным решением будет ограничить вывод до двух знаков после запятой (за это отвечает ‘%.2f’):

import random

print("Выводим 3 случайных числа; не более 2 знаков после запятой:")

print(['%.2f' % random.random() for i in range(3)])

random.seed

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

Если же задействовать seed с одним и тем же параметром, то вычисление будет производиться на основании этого параметра. Итог — на выходе будут получаться одинаковые «случайные» значения. Возьмем для примера параметр 5 и сделаем так, чтобы метод отработал дважды:

import random

random.seed(5)

print(random.random())

random.seed(5)

print(random.random())

random.uniform

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

import random

print("Находим число с плавающей точкой в заданном диапазоне:")

print(random.uniform(5, 10))

random.randint

Randint в Python тоже позволяет вернуть псевдослучайное число в определенном диапазоне, но тут уже речь идет о целом значении (int, integer):

import random

print("Используем randint для генерации целого числа int из диапазона:")

print(random.randint(10, 20))

random.randrange

Следующий метод, называемый randrange, похож на предыдущий randint, но тут, кроме диапазона целых значений int, можно добавить еще и шаг выборки (в качестве третьего параметра):

import random

print("Генерируем случайное целое число в заданном диапазоне с шагом")

print(random.randrange(10, 100, 2))

Судя по результату ниже и в соответствии с выбранным диапазоном от 10 до 100, установив шаг 2, мы будем получать лишь четные значения:

random.choice

Применение choice позволяет вернуть элемент из какой-нибудь последовательности — это может быть список, строка, кортеж.

И это уже интереснее, т. к. напрашивается аналогия с броском игрального кубика:

import random

list = [1, 2, 3, 4, 5, 6]

print("Выборка одного элемента из списка с помощью choice:")

print(random.choice(list))

Ура, выпало шесть!

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

Сыграйте в игру и попробуйте погадать, какой язык программирования вам лучше учить в Otus:

import random

list = ['Python','Java','C#','C++','PHP','C','JavaScript','Scala']

print("Какой язык программирования будешь учить?")

print(random.choice(list))

Sample и choices

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

Вернемся к нашему виртуальному кубику. Вот работа sample:

import random

list = [1, 2, 3, 4, 5, 6]

print ("Выборка двух случайных значений:")

print (random.sample(list,2))

Все бы ничего, но этот метод будет постоянно выводить 2 разных значения. Если же мы захотим сымитировать бросок двух игральных кубиков, код придется менять, ведь в реальной жизни выкинуть дубль все-таки можно. Но зачем менять код, если есть choices? Он обеспечит вывод двух случайных значения из заданного диапазона, причем они могут повторяться. Это уже максимально приближено к реальному броску двух кубиков, причем профит достигается и за счет того, что объем кода не увеличивается. Ради интереса мы его даже уменьшили — оптимизировали (List превратился в l, да и лишний текст выкинули):

import random

l = [1,2,3,4,5,6]

print(random.choices(l, k=2))

Кстати, вот и дубль — результат равен [6, 6], причем всего лишь с 5-й попытки (можете поверить на слово):

Правда, тут нюанс: пришлось сменить онлайн-компилятор, так как на предыдущем компиляторе Python версии 3.6 не поддерживался.

random.shuffle

Функция с интересным названием shuffle может перемешивать последовательность, меняя местами значения (она не подходит для неизменяемых объектов). Здесь важна именно последовательность выпадения определенных значений, как в лото.  

import random

list = [1,2,3,4,5,6,7,8,9,10]

random.shuffle(list)

print ("Крутим барабан и достаем шары наугад: ", list)

Остается добавить, что английское слово shuffle означает «тасовать, перемешивать». Как тут не вспомнить картежного шулера или лопату-шуфлю для перемешивания бетонного раствора. Но это так, для общего развития.

Успехов вам, друзья!

Источник

Понравилась статья? Поделить с друзьями:
  • Как найти все расширения в опере
  • Как найти модули векторов зная координаты точек
  • Как найти страницу по ссылке на файл
  • Как значит составить план к проекту
  • Как найти погрешность ускорения свободного падения