Import random python: Модуль random | Python 3 для начинающих и чайников
Содержание
Модуль 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 «import random» ошибка — CodeRoad
Как вы, возможно, знаете из моих предыдущих постов, я изучаю Python.
И на этот раз у меня есть небольшая ошибка, которая, как я думаю, связана с самой этой сборкой Python. При использовании следующих:
import random
number = random.randint(1,10000)
Python дает мне эту ошибку:
File "C\Users\name\Documents\Python\random.py", line 5, in (module)
print random.random()
TypeError: 'module' object is not callable
Каждый раз, когда я пытаюсь запустить его. Меня никто не понимает. Любая помощь будет очень признательна!
EDIT: две строки кода, которые я пытаюсь запустить:
import random
print random.randint(1,100)
Вот и все. И это дает мне ту же ошибку.
python
random
Поделиться
Источник
MalyG
11 декабря 2012 в 03:25
4 ответа
- Random Python Синтаксическая Ошибка?
Я постоянно получаю синтаксическую ошибку Random в своем коде! Я использую python 3.
3.2 def modestart(): modetype = int(inputSelect a Game Mode: 1 — Standard Selection Mode 2 — Ordered Mode 3 — Random Shuffle Mode! Or press any other key to exit ) loop=True while loop=True: try: if modetype == 1:… - import random не работает (я думаю)
Я очень новичок в Python (студент первого курса университета) и, пытаясь закончить домашнее задание, столкнулся с проблемой. Я создаю очень простую программу, используя random числа. Вот что я написал до сих пор: import random def main(): print random.randint(2,10) a=random.seed() b=random.seed(5)…
3.2 def modestart(): modetype = int(inputSelect a Game Mode: 1 — Standard Selection Mode 2 — Ordered Mode 3 — Random Shuffle Mode! Or press any other key to exit ) loop=True while loop=True: try: if modetype == 1:…
12
Называя свой сценарий random.py, вы создаете конфликт именования со стандартным библиотечным модулем random .
При попытке запустить скрипт каталог, содержащий скрипт, будет добавлен в начало пути импорта модуля. Поэтому, когда ваш сценарий делает import random, вы фактически запускаете вторую копию сценария в качестве модуля random .
>>-from-random-import-random->>>class-fiftyfifty-def-get-return-random-0-5-55235836.png’ />
Когда модуль random запускает import random, это означает, что random.random также будет ссылкой на ваш модуль. Таким образом, когда вы пытаетесь вызвать стандартную библиотечную функцию random.random() , вы фактически пытаетесь вызвать объект модуля, что приводит к ошибке, которую вы получили.
Если вы переименуете свой сценарий на что-то другое, проблема должна исчезнуть.
Поделиться
James Henstridge
11 декабря 2012 в 03:59
0
Даже я столкнулся с той же проблемой. Я переименовал свой файл python с random.py на shuffle.py. Из этого ничего не вышло. Потом я изменил версию, и она заработала. Это может немного помочь.
Python версия: 3.6.7
заменить
импорт random;
для
импорта random2;
Поделиться
Mounika
15 июня 2019 в 12:26
0
Я использую pycharm, и мне пришлось сделать дополнительный шаг, чтобы импортировать методы from random .
В моем случае:
import random
from random import choice
Поделиться
William Cheung
15 декабря 2018 в 15:28
- Ошибка при использовании import randint в python
Файл ex43.py, строка 2, in from random import randint ImportError: не import randint имя Есть какие-нибудь предложения по поводу ошибки randint? Я попытался переустановить python, но безуспешно.
- Python tkinter import ошибка
from tkinter import * from tkinter import messagebox root= Tk() root.mainloop() Ошибка: … Traceback (самый последний вызов last): файл C:\Users\Lee\Desktop\Python projects\tkinter.py, строка 1, in import tkinter as TK File C:\Users\Lee\Desktop\Python projects\tkinter.py, строка 2, in from…
-2
Простой ответ: измените имя файла с «random.
py» на что-то другое, поскольку оно конфликтует с библиотекой random.
Поделиться
Shashank Sharma
24 апреля 2020 в 09:12
Похожие вопросы:
Random функция в Python
Как я могу использовать функцию random (в Python) для выбора строки из списка txt? я хочу random из списка : import random import sys filename = sys.argv[1] f = open(filename) f.close() print…
Python — Bash — random цифры
Дан скрипт ‘random.sh’ со следующим содержимым: #!/bin/bash RANDOM=`python -v -d -S -c import random; print random.randrange(500, 800)` echo $RANDOM Запуск этого метода приводит к появлению random…
Python random функция
У меня возникли проблемы с функцией Python import random. Похоже, что import random и from random import random импортируют разные вещи. В настоящее время я использую Python 2.7.3 Python 2.7.3…
Random Python Синтаксическая Ошибка?
Я постоянно получаю синтаксическую ошибку Random в своем коде! Я использую python 3.3.2 def modestart(): modetype = int(inputSelect a Game Mode: 1 — Standard Selection Mode 2 — Ordered Mode 3 -…
import random не работает (я думаю)
Я очень новичок в Python (студент первого курса университета) и, пытаясь закончить домашнее задание, столкнулся с проблемой. Я создаю очень простую программу, используя random числа. Вот что я…
Ошибка при использовании import randint в python
Файл ex43.py, строка 2, in from random import randint ImportError: не import randint имя Есть какие-нибудь предложения по поводу ошибки randint? Я попытался переустановить python, но безуспешно.
Python tkinter import ошибка
from tkinter import * from tkinter import messagebox root= Tk() root.mainloop() Ошибка: … Traceback (самый последний вызов last): файл C:\Users\Lee\Desktop\Python projects\tkinter.
py, строка 1, in…
Random Модульные Методы Python
Как я могу найти все методы модуля random в python? Я попробовал с этим кодом: def random(): import random random.helpm random() но это не работает.
Ошибка с random в python 2.7
у меня есть ошибка запуска этого следующего кода в python: from random import randint code = %d%d%d % (randint(1,9), randint (1,9), randint(1,9)) guess = raw_input(>) guesses = 0 while guess !=…
Не могу import random.randint
В консоли python я могу запустить: from random import randint Но при выполнении я получаю ошибку: import random.randint Ошибка говорит: ModuleNotFoundError: No module named ‘random.randint’;…
Генератор случайных чисел – random. Курс «Python. Введение в программирование»
В компьютерных программах нередко требуется эмуляция случайности. Например, при разработке игр. Если в программе имеется некий генератор, то есть производитель, случайного числа, то, используя полученное таким образом число, можно выбирать ту или иную ветку выполнения программы, или произвольный объект из коллекции.
Другими словами, главное – сгенерировать число. Эмуляция случайности иного рода основывается на нем.
Мы наверняка не знаем, есть ли в природе случайность, или она нам только кажется из-за ограниченности наших знаний. Мы только знаем, что в программировании настоящей случайности нет. Неоткуда взяться произвольному числу, нельзя запрограммировать его появление из ниоткуда. Можно лишь создать программу, которая в результате применения сложной формулы к «зерну» будет выдавать число, и нам будет казаться, что это число случайно.
«Зерно» – это исходные данные для формулы. Им может быть, например, системное время в миллисекундах, которое постоянно меняется. Следовательно, «зерно» будет постоянно разным. Или программист может задавать его самостоятельно.
Подобную программу (в реальности модуль или функцию) называют генератором псевдослучайных чисел. В состав стандартной библиотеки языка Python входит модуль random. Он содержит множество функций, связанных с эмуляцией случайности (например, «перемешивание» элементов последовательности), а не только функции генерации псевдослучайных чисел.
В этом уроке будут рассмотрены функции random(), randrange() и randint() из модуля random. Обратите внимание, что модуль random содержит одноименную функцию random(). Так бывает.
Чтобы обращаться к функциям, надо импортировать модуль random:
Или импортировать отдельные функции из него:
>>> from random import random, randrange, randint
Функции для получения целых «случайных» чисел – randint() и randrange()
Функции randint() и randrange() генерируют псевдослучайные целые числа. Первая из них наиболее простая и всегда принимает только два аргумента – пределы целочисленного диапазона, из которого выбирается любое число:
>>> random.randint(0, 10) 6
или (если импортировались отдельные функции):
>>> randint(100, 200) 110
В случае randint() обе границы включаются в диапазон, т.
е. на языке математики отрезок описывается как [a; b].
Числа могут быть отрицательными:
>>> random.randint(-100, 10) -83 >>> random.randint(-100, -10) -38
Но первое число всегда должно быть меньше или, по-крайней мере, равно второму. То есть a <= b.
Функция randrange() сложнее. Она может принимать один аргумент, два или даже три. Если указан только один, то она возвращает случайное число от 0 до указанного аргумента. Причем сам аргумент в диапазон не входит. На языке математики – это [0; a).
>>> random.randrange(10) 4
Или:
Если в randrange() передается два аргумента, то она работает аналогично randint() за одним исключением. Верхняя граница не входит в диапазон, т. е. [a; b).
>>> random.randrange(5, 10) 9 >>> random.randrange(1, 2) 1
Здесь результатом второго вызова всегда будет число 1.
Если в randrange() передается три аргумента, то первые два – это границы диапазона, как в случае с двумя аргументами, а третий – так называемый шаг. Если, например, функция вызывается как randrange(10, 20, 3), то «случайное» число будет выбираться из чисел 10, 13, 16, 19:
>>> random.randrange(10, 20, 3) 13 >>> random.randrange(10, 20, 3) 19 >>> random.randrange(10, 20, 3) 10
Функция random() – «случайные» вещественные числа
Чтобы получить случайное вещественное число, или, как говорят, число с плавающей точкой, следует использовать функцию random() из одноименного модуля random языка Python. Она не принимает никаких аргументов и возвращает число от 0 до 1, не включая 1:
>>> random.random() 0.17855729241927576 >>> random.random() 0.3310978930421846
или
>>> random() 0.025328854415995194
Результат содержит много знаков после запятой.
Чтобы его округлить, можно воспользоваться встроенной в Python функцией round():
>>> a = random.random() >>> a 0.8366142721623201 >>> round(a, 2) 0.84 >>> round(random.random(), 3) 0.629
Чтобы получать случайные вещественные числа в иных пределах, отличных от [0; 1), прибегают к математическим приемам. Так если умножить полученное из random() число на любое целое, то получится вещественное в диапазоне от 0 до этого целого, не включая его:
>>> random.random() * 10 2.510618091637596 >>> random.random() * 10 6.977540211221759
Если нижняя граница должна быть отличной от нуля, то число из random() надо умножать на разницу между верхней и нижней границами, после чего прибавить нижнюю:
>>> random.random() * (10 - 4) + 4 9.517280589233597 >>> random.random() * (10 - 4) + 4 6.4429124181215975 >>> random.random() * (10 - 4) + 4 4.
9231983600782385В данном примере число умножается на 6. В результате получается число от 0 до 6. Прибавив 4, получаем число от 4 до 10.
Пример получения случайных чисел от -1 до 1:
>>> random.random() * (1 + 1) - 1 -0.673382618351051 >>> random.random() * (1 + 1) - 1 0.34121487148075924 >>> random.random() * (1 + 1) - 1 -0.988751324713907 >>> random.random() * (1 + 1) - 1 0.44137358363477674
Нижняя граница равна -1. При вычитании получается +. Когда добавляется нижняя граница, то плюс заменяется на минус ( +(-1) = — 1).
Для получения псевдослучайных чисел можно пользоваться исключительно функцией random(). Если требуется получить целое, то всегда можно округлить до него с помощью round() или отбросить дробную часть с помощью int():
>>> int(random.random() * 100) 61 >>> round(random.random() * 100 - 50) -33
Практическая работа
Используя функцию
randrange()получите псевдослучайное четное число в пределах от 6 до 12. Также получите число кратное пяти в пределах от 5 до 100.Напишите программу, которая запрашивает у пользователя границы диапазона и какое (целое или вещественное) число он хочет получить. Выводит на экран подходящее случайное число.
Также получите число кратное пяти в пределах от 5 до 100.Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса
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 до числа stoprandrange(start, stop): набор чисел представляет диапазон от числа start до числа stoprandrange(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)
Случайный модуль Python
Модуль random — это встроенный модуль для генерации псевдослучайных величин. Его можно использовать для выполнения некоторых действий случайным образом, например, для получения случайного числа, выбора случайных элементов из списка, случайного перемешивания элементов и т.
Д.
Генерировать случайные числа с плавающей запятой
Метод random.random () возвращает случайное число с плавающей запятой от 0,0 до 1,0. Функция не требует аргументов.
>>> импорт случайный
>>> random.random ()
0,645173684807533
Генерировать случайные целые числа
Метод random.randint () возвращает случайное целое число между указанными целыми числами.
>>> импорт случайный
>>> random.randint (1, 100)
95
>>> случайный.рандинт (1, 100)
49
Генерировать случайные числа в пределах диапазона
Метод random.randrange () возвращает случайно выбранный элемент из диапазона, созданного аргументами start, stop и step.
По умолчанию начальное значение равно 0. Аналогично, значение шага по умолчанию равно 1.
>>> random.randrange (1, 10)
2
>>> случайный.рандом (1, 10, 2)
5
>>> random.randrange (0, 101, 10)
80
Выбрать случайные элементы
Метод random.choice () возвращает случайно выбранный элемент из непустой последовательности. Пустая последовательность в качестве аргумента вызывает ошибку IndexError.
>>> импорт случайный
>>> random.choice ('компьютер')
'т'
>>> случайный.выбор ([12,23,45,67,65,43])
45
>>> random.choice ((12,23,45,67,65,43))
67
Перемешать элементы в случайном порядке
Метод random.shuffle () случайным образом переупорядочивает элементы в списке.
>>> числа = [12,23,45,67,65,43]
>>> random.shuffle (числа)
>>> числа
[23, 12, 43, 65, 67, 45]
>>> случайный.перемешать (числа)
>>> числа
[23, 43, 65, 45, 12, 67]
Дополнительные сведения о модуле random см.
В документации Python.
Случайная библиотека Python
Иногда нам нужно, чтобы компьютер выбрал случайное число в заданном диапазоне, случайный элемент из списка, случайную карту из колоды, подбросил монету и т. Д. Модуль random предоставляет доступ к функциям, которые поддерживают эти типы операции. Модуль random — это еще одна библиотека функций, которая может расширить базовые возможности Python.Другие модули, которые мы видели до сих пор, — это строки, математика, время и графика. За исключением графического модуля, все эти модули встроены в Python. Полный список модулей Python см. В онлайн-документации, в которой перечислены все модули по умолчанию. Чтобы получить доступ к модулю random, мы добавляем from random import * в начало нашей программы (или вводим его в оболочку python).
Откройте файл randOps.py в vim и запустите программу в отдельном терминале. Обратите внимание, что если вы снова запустите программу, вы получите другие (случайные) результаты.Эта программа иллюстрирует функции randrange и random. Чаще всего мы будем использовать randrange. Эта функция генерирует список точно так же, как range, но затем случайным образом возвращает один элемент из этого списка.
Чтобы использовать случайную библиотеку, вам необходимо ее импортировать. В верхней части вашего
программа:
из случайного импорта *
Вы также можете запустить справку (случайную) в интерпретаторе Python, чтобы увидеть
какие функции предоставляет случайная библиотека:
$ питон >>> импорт случайный >>> справка (случайная)
Код в randomOps.py содержит примеры того, как использовать наиболее
полезные функции в этой библиотеке:
random (): получить следующее случайное число в диапазоне [0,0, 1,0) randrange (start, stop): получить следующее случайное число в диапазоне [start, stop) randrange (стоп): получить следующее случайное число в диапазоне [0, стоп)
randomOps.py:
"" "
Пример кода, иллюстрирующий использование случайной библиотеки
Автор: Эндрю Даннер
Дата: октябрь 2008 г.
"" "
из случайного импорта *
def coinFlip ():
"" "
Случайным образом подбросьте монету и верните букву "H" для орла или "T" для решки.
возвращает: 'H' для орла или 'T' для решки
"" "
если randrange (2) == 0:
вернуть 'H'
вернуть 'T'
########################################################################## ##########
def main ():
# получить список из 5 случайных чисел от 0 до 9 (включительно)
l = []
для i в диапазоне (5):
rnum = randrange (10)
л.добавить (rnum)
печать l
# получить список из 3 случайных чисел с плавающей запятой от 0 до 1
flist = []
для i в диапазоне (3):
rfloat = random ()
flist.append (rfloat)
распечатать флист
# подбросьте монету 4 раза
для i в диапазоне (4):
напечатать coinFlip (),
Распечатать
основной()
случайных чисел в Python — GeeksforGeeks
Python определяет набор функций, которые используются для генерации случайных чисел или управления ими с помощью модуля random. Функции в модуле random полагаются на функцию генератора псевдослучайных чисел random () , которая генерирует случайное число с плавающей запятой между 0.0 и 1.0. Этот конкретный тип функций используется во многих играх, лотереях или в любых приложениях, требующих генерации случайных чисел.
Операции со случайными числами
1. choice () : — choice () — это встроенная функция языка программирования Python, которая возвращает случайный элемент из списка, кортежа или строки.
Пример:
Python3
|
Выход:
t2. randrange (начало, конец, шаг) : - Модуль random предлагает функцию, которая может генерировать случайные числа из указанного диапазона, а также позволяет включать комнаты для шагов, называемые randrange ().
Пример:
Python
|
Вывод:
Случайное число из списка: 4 Случайное число из диапазона: 41
3. random () : - Этот метод используется для генерации случайного числа с плавающей запятой меньше 1 и больше или равного 0.
4. seed ( ) : - Функция начального числа используется для сохранения состояния случайной функции, чтобы она могла генерировать некоторые случайные числа при многократном выполнении кода на одной и той же машине или на разных машинах (для определенного начального значения).Начальное значение - это номер предыдущего значения, сгенерированный генератором. Впервые, когда нет предыдущего значения, используется текущее системное время.
Пример:
Python
003, конец 003, конец |
Выход:
Случайное число от 0 до 1: 0,510721762520941
Сопоставленное случайное число с 5: 0,622
48897019
7: сопоставленное случайное число 0.32383276483316237
Отображенное случайное число с 5: 0,622
48897019
Отображенное случайное число с 7: 0.32383276483316237
5. shuffle () : - Используется для перемешивания последовательности (списка).Перемешивание означает изменение положения элементов последовательности. Здесь действует перетасовка.
Пример:
Python3
sample. |
Вывод:
Исходный список: ['A', 'B', 'C', 'D', 'E'] После первого перемешивания: ['A', 'B', 'E', 'C', 'D'] После второго тасования: ['C', 'E', 'B', 'D', 'A']
6. uniform (a, b) : - Эта функция используется для генерации случайного числа с плавающей запятой между числами , указанными в ее аргументах. Требуется два аргумента: нижний предел (включен в генерацию) и верхний предел (не включен в генерацию).
Python
|
Вывод:
Список до перетасовки: 1 4 5 10 2
Список после перетасовки: 2 1 4 5 10
Случайное число с плавающей запятой между 5 и 10: 5.183697823553464
Автором этой статьи является Manjeet Singh. Если вам нравится GeeksforGeeks, и вы хотите внести свой вклад, вы также можете написать статью, используя свой вклад.geeksforgeeks.org или отправьте свою статью по адресу [email protected]. Посмотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогите другим гикам.
Пожалуйста, напишите комментарий, если вы обнаружите что-то неправильное, или если вы хотите поделиться дополнительной информацией по теме, обсужденной выше.
Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.
Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS .
Как сгенерировать случайное число в Python
Опубликовано: 15, среда, -е, , февраль 2017 г.
В Python, как и почти в любом другом языке ООП, есть вероятность, что в какой-то момент вам понадобится сгенерировать случайное число. Независимо от того, выполняете ли вы просто упражнение в алгоритмах, чтобы лучше познакомиться с языком, или если вы пытаетесь написать более сложный код, вы не можете называть себя кодировщиком Python, не зная, как генерировать случайные числа.
Ознакомьтесь с приведенным ниже фрагментом кода, чтобы узнать, как он работает для генерации числа от 1 до 100.
случайный импорт
для x в диапазоне (10):
напечатать random.randint (1,101)
Приведенный выше код напечатает 10 случайных значений чисел от 1 до 100. Вторая строка для x в диапазоне (10) определяет, сколько значений будет напечатано (при использовании диапазона (x) число, которое вы используете в место x будет количеством значений, которые вы напечатаете. если вы хотите 20 значений, используйте диапазон (20).используйте range (5), если вы хотите вернуть только 5 значений и т. д.). Затем третья строка: print random.randint (1,101) автоматически выберет для вас случайное целое число от 1 до 100. Процесс довольно простой.
Что, если вы хотите выбрать случайное целое число от 1 до 100, но также кратное пяти? Это немного сложнее. Процесс такой же, но вам потребуется немного больше арифметических действий, чтобы убедиться, что случайное целое число на самом деле кратно пяти.Посмотрите код ниже:
случайный импорт
для x в диапазоне (10):
напечатать random.randint (1,21) * 5,
печать Обычно этот код генерирует случайное число от 1 до 20, а затем умножает это число на 5. Таким образом, каждое напечатанное число будет не только кратным 5, но и максимальное число, которое может быть напечатано, равно 100 (20 * 5 = 100). Поиграйте с кодом самостоятельно и посмотрите, сможете ли вы сгенерировать случайное число от 1 до 100, где каждое сгенерированное число кратно десяти!
Используйте модуль случайных чисел для генерации случайных чисел в Python
Python предлагает модуль random , который может генерировать случайные числа.
Это псевдослучайные числа, поскольку последовательность генерируемых чисел зависит от начального числа.
Если значение заполнения такое же, последовательность будет такой же. Например, если вы используете 2 в качестве начального значения, вы всегда будете видеть следующую последовательность.
случайный импорт
random.seed (2)
печать (random.random ())
печать (random.random ())
печать (random.random ()) Вывод всегда будет следовать последовательности:
0,9560342718892494 0.9478274870593494 0,05655136772680869
Не так уж и случайно, а? Поскольку этот генератор полностью детерминирован, его нельзя использовать для шифрования.
Вот список всех функций, определенных в модуле random, с кратким объяснением того, что они делают.
| Функция | Описание |
|---|---|
| начальное число (a = Нет, версия = 2) | Инициализировать генератор случайных чисел |
| getstate () | Возвращает объект, фиксирующий текущее внутреннее состояние генератора |
| setstate (состояние) | Восстанавливает внутреннее состояние генератора |
| getrandbit (k) | Возвращает целое число Python с k случайными битами |
| randrange (start, stop [, step]) | Возвращает случайное целое число из диапазона |
| рандинт (а, б) | Возвращает случайное целое число от a до b включительно |
| выбор (seq) | Вернуть случайный элемент из непустой последовательности |
| в случайном порядке (seq) | Перемешать последовательность |
| выборка (популяция, тыс.) | Возвращает список уникальных элементов длиной k, выбранных из последовательности популяции |
| случайный () | Вернуть следующее случайное число с плавающей запятой в диапазоне [0.0, 1.0) |
| форменная (а, б) | Вернуть случайное число с плавающей запятой от a до b включительно |
| треугольный (низкий, высокий, режим) | Вернуть случайное число с плавающей запятой между младшим и старшим с указанным режимом между этими границами |
| бета-вариант (альфа, бета) | Бета-распределение |
| экспоненциальный (лямбд) | Экспоненциальное распределение |
| гаммавариат (альфа, бета) | Гамма-распределение |
| гаусс (мю, сигма) | Распределение Гаусса |
| lognormvariate (mu, sigma) | Логарифм нормального распределения |
| нормальный вариант (мю, сигма) | Нормальное распределение |
| vonmisesvariate (mu, kappa) | Распределение Вонмизеса |
| паретовариант (альфа) | Распределение Парето |
| переменная Вейбулла (альфа, бета) | Распределение Вейбулла |
Посетите эту страницу, чтобы узнать больше о том, как вы можете генерировать псевдослучайные числа в Python.
Как сгенерировать случайные числа в Python
Последнее обновление 4 сентября 2020 г.
Использование случайности - важная часть конфигурации и оценки алгоритмов машинного обучения.
От случайной инициализации весов в искусственной нейронной сети до разделения данных на случайные обучающие и тестовые наборы, до случайного перетасовки обучающего набора данных при стохастическом градиентном спуске, генерация случайных чисел и использование случайности - требуемые навыки.
В этом руководстве вы узнаете, как генерировать случайные числа и работать со случайными числами в Python.
После прохождения этого руководства вы будете знать:
- Эта случайность может применяться в программах с помощью генераторов псевдослучайных чисел.
- Как сгенерировать случайные числа и использовать случайность через стандартную библиотеку Python.
- Как сгенерировать массивы случайных чисел через библиотеку NumPy.
Начните свой проект с моей новой книги «Статистика для машинного обучения», включающей пошаговых руководств и файлов исходного кода Python для всех примеров.
Приступим.
Как генерировать случайные числа в Python
Фотография Харольда Литвилера, некоторые права защищены.
Обзор учебного пособия
Это руководство разделено на 3 части; их:
- Генераторы псевдослучайных чисел
- Случайные числа со стандартной библиотекой Python
- Seed Генератор случайных чисел
- Случайные значения с плавающей запятой
- Случайные целые числа
- Случайные гауссовские значения
- Случайный выбор из списка
- Случайная подвыборка из списка
- Случайно перемешать список
- Случайные числа с NumPy
- Seed Генератор случайных чисел
- Массив случайных значений с плавающей запятой
- Массив случайных целых значений
- Массив случайных гауссовских значений
- Перемешать массив NumPy
1.Генераторы псевдослучайных чисел
Источник случайности, который мы вводим в наши программы и алгоритмы, - это математический трюк, называемый генератором псевдослучайных чисел.
Генератор случайных чисел - это система, которая генерирует случайные числа из истинного источника случайности. Часто что-то физическое, например счетчик Гейгера, где результаты преобразуются в случайные числа. Нам не нужна настоящая случайность в машинном обучении. Вместо этого мы можем использовать псевдослучайность. Псевдослучайность - это выборка чисел, которые похожи на случайные, но были сгенерированы с помощью детерминированного процесса.
Перестановка данных и инициализация коэффициентов случайными значениями используют генераторы псевдослучайных чисел. Эти маленькие программы часто представляют собой функцию, которую вы можете вызвать и которая вернет случайное число. При повторном вызове они вернут новое случайное число. Часто также доступны функции обертки, которые позволяют получить случайность в виде целого числа с плавающей запятой, в пределах определенного распределения, в пределах определенного диапазона и т. Д.
Номера генерируются последовательно. Последовательность детерминирована и засевается начальным номером.Если вы явно не задаете генератор псевдослучайных чисел, он может использовать текущее системное время в секундах или миллисекундах в качестве начального числа.
Стоимость семени не имеет значения. Выбирайте все, что пожелаете. Важно то, что одно и то же заполнение процесса приведет к одной и той же последовательности случайных чисел.
Давайте конкретизируем это на нескольких примерах.
2. Случайные числа в стандартной библиотеке Python
Стандартная библиотека Python предоставляет модуль random, который предлагает набор функций для генерации случайных чисел.
Python использует популярный и надежный генератор псевдослучайных чисел под названием Mersenne Twister.
В этом разделе мы рассмотрим ряд вариантов использования для генерации и использования случайных чисел и случайности со стандартным API Python.
Нужна помощь со статистикой для машинного обучения?
Пройдите бесплатный 7-дневный ускоренный курс по электронной почте (с образцом кода).
Нажмите, чтобы зарегистрироваться, а также получите бесплатную электронную версию курса в формате PDF.
Загрузите БЕСПЛАТНЫЙ мини-курс
Seed Генератор случайных чисел
Генератор псевдослучайных чисел - это математическая функция, которая генерирует последовательность почти случайных чисел.
Требуется параметр для запуска последовательности, называемый начальным числом. Функция является детерминированной, что означает, что при одном и том же начальном значении она каждый раз будет выдавать одну и ту же последовательность чисел. Выбор посевного материала значения не имеет.
Функция seed () будет заполнять генератор псевдослучайных чисел, принимая в качестве аргумента целое значение, например 1 или 7.Если функция seed () не вызывается до использования случайности, по умолчанию используется текущее системное время в миллисекундах от эпохи (1970).
Пример ниже демонстрирует заполнение генератора псевдослучайных чисел, генерирует некоторые случайные числа и показывает, что повторное заполнение генератора приведет к созданию той же последовательности чисел.
# заполнить генератор псевдослучайных чисел
из случайного импорта семян
из случайного импорта случайный
# генератор случайных чисел начального числа
семя (1)
# генерировать случайные числа
печать (случайный (), случайный (), случайный ())
# сбросить семя
семя (1)
# генерировать случайные числа
печать (случайный (), случайный (), случайный ())
# seed генератор псевдослучайных чисел from random import seed from random import random # seed random number generator seed (1) # generate some random numbers print (random (), random ( ), random ()) # сбросить начальное число seed (1) # сгенерировать несколько случайных чисел print (random (), random (), random ()) |
Запуск примера заполняет генератор псевдослучайных чисел значением 1, генерирует 3 случайных числа, повторно заполняет генератор и показывает, что генерируются те же три случайных числа.
0,13436424411240122 0,8474337369372327 0,763774618976614
0,13436424411240122 0,8474337369372327 0,763774618976614
0,13436424411240122 0,8474337369372327 0,763774618976614 0,13436424411240122 0,8474337369372327 0,763774618976614 |
Может быть полезно контролировать случайность, задав начальное значение, чтобы гарантировать, что ваш код каждый раз дает один и тот же результат, например, в производственной модели.
Для текущих экспериментов, в которых рандомизация используется для контроля смешивающих переменных, для каждого экспериментального запуска могут использоваться разные начальные числа.
Случайные значения с плавающей запятой
Случайные значения с плавающей запятой могут быть сгенерированы с помощью функции random (). Значения будут сгенерированы в диапазоне от 0 до 1, в частности, в интервале [0,1).
Значения взяты из равномерного распределения, что означает, что каждое значение имеет равные шансы на получение.
Пример ниже генерирует 10 случайных значений с плавающей запятой.
# генерировать случайные значения с плавающей запятой
из случайного импорта семян
из случайного импорта случайный
# генератор случайных чисел начального числа
семя (1)
# генерировать случайные числа от 0 до 1
для _ в диапазоне (10):
значение = случайное ()
print (значение)
# сгенерировать случайные числа с плавающей запятой из случайного начального числа импорта из случайного начального числа импорта # генератор случайных чисел начального числа начального числа (1) # сгенерировать случайные числа от 0 до для _ in range ( 10): значение = случайное () печать (значение) |
При выполнении примера генерируется и печатается каждое случайное значение с плавающей запятой.
0,13436424411240122
0,8474337369372327
0,763774618976614
0,25506394217
0,4954350870
95
0,4494
7887381
0,651592972722763
0,7887233511355132
0,0938595867742349
0,02834747652200631
0,13436424411240122 0,8474337369372327 0,763774618976614 0,25506394217 0,4954350870 95 0.4494 7887381 0,651592972722763 0,7887233511355132 0,0938595867742349 0,02834747652200631 |
Значения с плавающей запятой можно масштабировать до желаемого диапазона, умножив их на размер нового диапазона и прибавив минимальное значение, как показано ниже:
масштабируемое значение = min + (значение * (max - min))
масштабируемое значение = мин + (значение * (макс - мин)) |
Где min и max - это минимальное и максимальное значения желаемого диапазона соответственно, а значение - это случайно сгенерированное значение с плавающей запятой в диапазоне от 0 до 1.
Случайные целые числа
Случайные целочисленные значения могут быть сгенерированы с помощью функции randint ().
Эта функция принимает два аргумента: начало и конец диапазона сгенерированных целочисленных значений. Случайные целые числа генерируются внутри и включая значения начала и конца диапазона, в частности, в интервале [начало, конец]. Случайные значения взяты из равномерного распределения.
В приведенном ниже примере генерируется 10 случайных целочисленных значений от 0 до 10.
# генерировать случайные целочисленные значения
из случайного импорта семян
из случайного импорта randint
# генератор случайных чисел начального числа
семя (1)
# генерируем несколько целых чисел
для _ в диапазоне (10):
значение = randint (0, 10)
print (значение)
# сгенерировать случайные целые числа из случайного начального числа импорта из случайного импорта randint # генератор случайных чисел начального числа seed (1) # сгенерировать несколько целых чисел для _ in range (10): значение = randint (0, 10) печать (значение) |
При выполнении примера генерируются и печатаются 10 случайных целочисленных значений.
Случайные гауссовские значения
Случайные значения с плавающей запятой могут быть получены из распределения Гаусса с помощью функции gauss ().
Эта функция принимает два аргумента, которые соответствуют параметрам, управляющим размером распределения, а именно среднему значению и стандартному отклонению.
Пример ниже генерирует 10 случайных значений, взятых из распределения Гаусса со средним значением 0,0 и стандартным отклонением 1,0.
Обратите внимание, что эти параметры не являются границами значений и что разброс значений будет контролироваться колоколообразной формой распределения, в этом случае вероятнее всего пропорционально выше и ниже 0.0.
# генерировать случайные гауссовские значения
из случайного импорта семян
из случайного импорта gauss
# генератор случайных чисел начального числа
семя (1)
# генерируем некоторые гауссовские значения
для _ в диапазоне (10):
значение = гаусс (0, 1)
print (значение)
# генерировать случайные значения Гаусса из случайного начального числа импорта из случайного импорта gauss # генератора случайных чисел начального числа начального числа (1) # генерировать некоторые значения Гаусса для _ в диапазоне (10): значение = гаусс (0, 1) печать (значение) |
При выполнении примера генерируются и печатаются 10 случайных значений Гаусса.
1,2881847531554629
1.449445608699771
0,06633580893826191
-0,7645436509716318
-1,0921732151041414
0,03133451683171687
-1,022103170010873
-1,4368294451025299
0,19931197648375384
0,13337460465860485
1,2881847531554629 1.449445608699771 0,06633580893826191 -0,7645436509716318 -1,0921732151041414 0.03133451683171687 -1,022103170010873 -1,4368294451025299 0,19931197648375384 0,13337460465860485 |
Случайный выбор из списка
Случайные числа можно использовать для случайного выбора элемента из списка.
Например, если в списке 10 элементов с индексами от 0 до 9, вы можете сгенерировать случайное целое число от 0 до 9 и использовать его для случайного выбора элемента из списка. Функция choice () реализует это поведение за вас.Выборки производятся с одинаковой вероятностью.
Пример ниже генерирует список из 20 целых чисел и дает пять примеров выбора одного случайного элемента из списка.
# выбираем случайный элемент из списка
из случайного импорта семян
из случайного выбора импорта
# генератор случайных чисел начального числа
семя (1)
# подготовить последовательность
последовательность = [i для i в диапазоне (20)]
печать (последовательность)
# выбираем из последовательности
для _ в диапазоне (5):
выбор = выбор (последовательность)
печать (выделение)
# выбрать случайный элемент из списка из случайного начального числа импорта из случайного выбора импорта # генератора случайных чисел начального числа начального числа (1) # подготовить последовательность последовательность = [i for i in диапазон (20)] печать (последовательность) # выбор из последовательности для _ в диапазоне (5): выбор = выбор (последовательность) печать (выбор) |
При выполнении примера сначала печатается список целочисленных значений, за которым следуют пять примеров выбора и печати случайного значения из списка.
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
4
18
2
8
3
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] 4 18 2 8 3 |
Случайная подвыборка из списка
Нам может быть интересно повторить случайный выбор элементов из списка для создания случайно выбранного подмножества.
Важно отметить, что после того, как элемент выбран из списка и добавлен в подмножество, его больше не следует добавлять. Это называется выбором без замены, потому что после того, как элемент из списка выбран для подмножества, он не добавляется обратно в исходный список (т.е. не становится доступным для повторного выбора).
Это поведение обеспечивается в функции sample () , которая выбирает случайную выборку из списка без замены. Функция принимает как список, так и размер подмножества для выбора в качестве аргументов.Обратите внимание, что элементы фактически не удаляются из исходного списка, а только выбираются в копию списка.
Пример ниже демонстрирует выбор подмножества пяти элементов из списка из 20 целых чисел.
# выбираем случайную выборку без замены
из случайного импорта семян
из случайной импортной выборки
# генератор случайных чисел начального числа
семя (1)
# подготовить последовательность
последовательность = [i для i в диапазоне (20)]
печать (последовательность)
# выбрать подмножество без замены
подмножество = образец (последовательность, 5)
печать (подмножество)
# выбрать случайную выборку без замены из случайной выборки импорта из случайной выборки импорта # генератор случайных чисел семян seed (1) # подготовить последовательность последовательность = [i для i в диапазоне (20)] печать (последовательность) # выбор подмножества без замены подмножество = образец (последовательность, 5) печать (подмножество) |
При выполнении примера сначала печатается список целочисленных значений, затем выбирается случайная выборка и печатается для сравнения.
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[4, 18, 2, 8, 3]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] [4, 18, 2, 8, 3] |
Перемешать список в случайном порядке
Случайность можно использовать для перемешивания списка элементов, например для перетасовки колоды карт.
Функцию shuffle () можно использовать для перемешивания списка.Перемешивание выполняется на месте, что означает, что список, предоставленный в качестве аргумента функции shuffle (), перемешивается, а не перемешивается копия создаваемого и возвращаемого списка.
Пример ниже демонстрирует случайное перемешивание списка целочисленных значений.
# случайным образом перемешиваем последовательность
из случайного импорта семян
из случайного перемешивания импорта
# генератор случайных чисел начального числа
семя (1)
# подготовить последовательность
последовательность = [i для i в диапазоне (20)]
печать (последовательность)
# случайным образом перемешиваем последовательность
перемешать (последовательность)
печать (последовательность)
# случайное перемешивание последовательности из случайного начального числа импорта из случайного перемешивания импорта # генератор случайных чисел начального числа начальное число (1) # подготовка последовательности последовательность = [i для i в диапазоне (20 )] print (последовательность) # случайным образом перемешать последовательность shuffle (последовательность) print (последовательность) |
При выполнении примера сначала печатается список целых чисел, а затем тот же список после случайного перемешивания.
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[11, 5, 17, 19, 9, 0, 16, 1, 15, 6, 10, 13, 14, 12, 7, 3, 8, 2, 18, 4]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] [11, 5, 17, 19, 9, 0, 16, 1, 15, 6, 10, 13, 14, 12, 7, 3, 8, 2, 18, 4] |
3. Случайные числа с помощью NumPy
В машинном обучении вы, вероятно, используете такие библиотеки, как scikit-learn и Keras.
Эти библиотеки используют скрытый NumPy, библиотеку, которая делает работу с векторами и матрицами чисел очень эффективной.
NumPy также имеет собственную реализацию генератора псевдослучайных чисел и удобных функций оболочки.
NumPy также реализует генератор псевдослучайных чисел Mersenne Twister.
Давайте рассмотрим несколько примеров генерации случайных чисел и использования случайности с массивами NumPy.
Seed Генератор случайных чисел
Генератор псевдослучайных чисел NumPy отличается от генератора псевдослучайных чисел стандартной библиотеки Python.
Важно отметить, что заполнение генератора псевдослучайных чисел Python не влияет на генератор псевдослучайных чисел NumPy. Его необходимо засеять и использовать отдельно.
Функцию seed () можно использовать для заполнения генератора псевдослучайных чисел NumPy, принимая целое число в качестве начального значения.
Пример ниже демонстрирует, как заполнить генератор и как повторное заполнение генератора приведет к генерации той же последовательности случайных чисел.
# заполнить генератор псевдослучайных чисел
от numpy.случайное начальное значение импорта
из numpy.random import rand
# генератор случайных чисел начального числа
семя (1)
# генерировать случайные числа
печать (рандом (3))
# сбросить семя
семя (1)
# генерировать случайные числа
печать (ранд (3))
# seed генератор псевдослучайных чисел из numpy.random import seed from numpy.random import rand # seed random number generator seed (1) # generate some random numbers print (rand ( 3)) # сбросить начальное число seed (1) # сгенерировать несколько случайных чисел print (rand (3)) |
Запуск примера запускает генератор псевдослучайных чисел, печатает последовательность случайных чисел, затем повторно загружает генератор, показывая, что генерируется точно такая же последовательность случайных чисел.
[4.17022005e-01 7.20324493e-01 1.14374817e-04]
[4.17022005e-01 7.20324493e-01 1.14374817e-04]
[4.17022005e-01 7.20324493e-01 1.14374817e-04] [4.17022005e-01 7.20324493e-01 1.14374817e-04] |
Массив случайных значений с плавающей запятой
Массив случайных значений с плавающей запятой может быть сгенерирован с помощью функции rand () NumPy.
Если аргумент не указан, создается одно случайное значение, в противном случае можно указать размер массива.
В приведенном ниже примере создается массив из 10 случайных значений с плавающей запятой, взятых из равномерного распределения.
# генерировать случайные значения с плавающей запятой
из numpy.random import seed
из numpy.random import rand
# генератор случайных чисел начального числа
семя (1)
# генерировать случайные числа от 0 до 1
значения = rand (10)
печать (значения)
# генерировать случайные значения с плавающей запятой из numpy.random import seed from numpy.random import rand # seed random number generator seed (1) # генерировать случайные числа между 0-1 values = rand (10) print (values) |
При выполнении примера генерируется и печатается массив NumPy случайных значений с плавающей запятой.
[4.17022005e-01 7.20324493e-01 1.14374817e-04 3.02332573e-01
1.46755891e-01 9.23385948e-02 1.86260211e-01 3.45560727e-01
3.96767474e-01 5.38816734e-01]
[4.17022005e-01 7.20324493e-01 1.14374817e-04 3.02332573e-01 1.46755891e-01 9.23385948e-02 1.86260211e-01 3.45560727e-01 3.96767474e-01165,38816 |
Массив случайных целых значений
Массив случайных целых чисел может быть сгенерирован с помощью функции NumPy randint ().
Эта функция принимает три аргумента: нижний предел диапазона, верхний предел диапазона и количество целочисленных значений для генерации или размер массива.Случайные целые числа будут взяты из равномерного распределения, включая нижнее значение и исключая верхнее значение, например в интервале [нижний, верхний).
Пример ниже демонстрирует создание массива случайных целых чисел.
# генерировать случайные целочисленные значения
из numpy.random import seed
из numpy.random import randint
# генератор случайных чисел начального числа
семя (1)
# генерируем несколько целых чисел
значения = randint (0, 10, 20)
печать (значения)
# генерировать случайные целые числа из numpy.random import seed from numpy.random import randint # генератор случайных чисел seed seed (1) # генерировать некоторые целые числа values = randint (0, 10, 20) print (values) |
При выполнении примера генерируется и печатается массив из 20 случайных целочисленных значений от 0 до 10.
[5 8 9 5 0 0 1 7 6 9 2 4 5 2 4 2 4 7 7 9]
[5 8 9 5 0 0 1 7 6 9 2 4 5 2 4 2 4 7 7 9] |
Массив случайных гауссовских значений
Массив случайных значений Гаусса может быть сгенерирован с помощью функции NumPy randn ().
Эта функция принимает единственный аргумент, чтобы указать размер результирующего массива. Значения Гаусса взяты из стандартного распределения Гаусса; это распределение со средним значением 0,0 и стандартным отклонением 1,0.
Пример ниже показывает, как сгенерировать массив случайных гауссовых значений.
# генерировать случайные гауссовские значения
из numpy.random import seed
из numpy.random import randn
# генератор случайных чисел начального числа
семя (1)
# генерируем некоторые гауссовские значения
значения = randn (10)
печать (значения)
# генерировать случайные гауссовские значения из numpy.random import seed from numpy.random import randn # генератор случайных чисел seed seed (1) # генерировать некоторые гауссовские значения values = randn (10) print (values) |
При выполнении примера генерируется и печатается массив из 10 случайных значений из стандартного распределения Гаусса.
[1,62434536 -0,61175641 -0,52817175 -1,07296862 0,86540763 -2,3015387
1.74481176 -0.7612069 0,31 -0,24937038]
[1,62434536 -0,61175641 -0,52817175 -1,07296862 0,86540763 -2,3015387 1,74481176 -0,7612069 0,31 -0,24937038] |
Значения стандартного распределения Гаусса можно масштабировать путем умножения значения на стандартное отклонение и добавления среднего значения из желаемого масштабированного распределения. Например:
масштабируемое значение = среднее + значение * стандартное отклонение
масштабируемое значение = среднее + значение * стандартное отклонение |
Где среднее значение и stdev - это среднее значение и стандартное отклонение для желаемого масштабированного гауссова распределения, а значение - это случайно сгенерированное значение из стандартного гауссова распределения.
Перемешать массив NumPy
Массив NumPy можно случайным образом перемешать на месте с помощью функции shuffle () NumPy.
Пример ниже демонстрирует, как перемешать массив NumPy.
# случайным образом перемешиваем последовательность
из numpy.random import seed
из numpy.random import shuffle
# генератор случайных чисел начального числа
семя (1)
# подготовить последовательность
последовательность = [i для i в диапазоне (20)]
печать (последовательность)
# случайным образом перемешиваем последовательность
перемешать (последовательность)
печать (последовательность)
# случайным образом перемешать последовательность из numpy.random import seed from numpy.random import shuffle # генератор случайных чисел seed seed (1) # подготовить последовательность sequence = [i for i in range (20)] print (sequence) # случайным образом перемешать последовательность перемешать (последовательность) печать (последовательность) |
При выполнении примера сначала создается список из 20 целочисленных значений, затем перемешивается и распечатывается перемешанный массив.
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[3, 16, 6, 10, 2, 14, 4, 17, 7, 1, 13, 0, 19, 18, 9, 15, 8, 12, 11, 5]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] [3, 16, 6, 10, 2, 14, 4, 17, 7, 1, 13, 0, 19, 18, 9, 15, 8, 12, 11, 5] |
Дополнительная литература
Этот раздел предоставляет дополнительные ресурсы по теме, если вы хотите углубиться.
Сводка
В этом руководстве вы узнали, как генерировать случайные числа и работать со случайными числами в Python.
В частности, вы выучили:
- Эта случайность может применяться в программах с помощью генераторов псевдослучайных чисел.
- Как сгенерировать случайные числа и использовать случайность через стандартную библиотеку Python.
- Как сгенерировать массивы случайных чисел через библиотеку NumPy.
Есть вопросы?
Задайте свои вопросы в комментариях ниже, и я постараюсь ответить.
Получите доступ к статистике для машинного обучения!
Развить рабочее понимание статистики
... путем написания строк кода на Python
Узнайте, как это сделать, в моей новой электронной книге:
Статистические методы машинного обучения
Он предоставляет руководств для самостоятельного изучения по таким темам, как:
Проверка гипотез, корреляция, непараметрическая статистика, повторная выборка и многое другое ...
Узнайте, как преобразовать данные в знания
Пропустить академики.Только результаты.
Посмотрите, что внутри
Работа со случайными числами в Python - dbader.org
Создание случайных интервалов между
x и y
Вот как вы можете сгенерировать случайное целое число между двумя конечными точками в Python с помощью функции random.randint () . Это охватывает полный интервал [x, y] и может включать обе конечные точки:
>>> импорт случайный >>> random.randint (1, 10) 10 >>> random.randint (1, 10) 3 >>> случайный.рандинт (1, 10) 7
С помощью функции random.randrange () вы можете исключить правую часть интервала, то есть сгенерированное число всегда находится в пределах [x, y) и всегда будет меньше правой конечной точки:
>>> импорт случайный >>> random.randrange (1, 10) 5 >>> random.randrange (1, 10) 3 >>> random.randrange (1, 10) 4
Выбор случайного элемента из списка
Чтобы выбрать случайный элемент из непустой последовательности (например, списка или кортежа), вы можете использовать Python random.выбор функция:
>>> импорт случайный >>> items = ['один', 'два', 'три', 'четыре', 'пять'] >>> random.choice (элементы) 'пять' >>> random.choice (элементы) 'один' >>> random.choice (элементы) 'четыре'
Это работает для любой непустой последовательности, однако вызовет исключение IndexError , если последовательность пуста.
Случайный выбор списка элементов
Вы можете рандомизировать последовательность на месте, используя random.функция перемешивания . Это изменит объект последовательности и изменит порядок элементов:
>>> импорт случайный >>> items = ['один', 'два', 'три', 'четыре', 'пять'] >>> random.shuffle (элементы) >>> предметы ['четыре', 'один', 'пять', 'три', 'два']
Если вы не хотите изменять оригинал, вам нужно сначала сделать копию, а затем перетасовать копию. Вы можете создавать копии объектов Python с помощью модуля copy .
Отбор
n случайных выборок из списка элементов
Чтобы выбрать случайную выборку из n уникальных элементов из последовательности, используйте случайную выборку .пример функции. Выполняет случайную выборку без замены:
>>> импорт случайный >>> items = ['один', 'два', 'три', 'четыре', 'пять'] >>> random.sample (items, 3) ['один', 'пять', 'два'] >>> random.sample (items, 3) ['пять', 'четыре', 'два'] >>> random.sample (items, 3) ['три', 'два', 'пять']
Генерация криптографически безопасных случайных чисел
Если вам нужны криптографически безопасные случайные числа в целях безопасности, используйте random.SystemRandom , который использует криптографически безопасный генератор псевдослучайных чисел.
Экземпляры класса SystemRandom предоставляют большинство операций генератора случайных чисел, доступных как функция в модуле random . Вот пример:
>>> импорт случайный >>> rand_gen = random.SystemRandom () >>> rand_gen.random () 0,61124414599 >>> rand_gen.randint (1, 10) 2 >>> rand_gen.randrange (1, 10) 5 >>> rand_gen.униформа (1, 10) 8.42357365980016 >>> rand_gen.choice ('abcdefghijklmn') 'j' >>> items = ['один', 'два', 'три', 'четыре', 'пять'] >>> rand_gen.shuffle (элементы) >>> предметы ['два', 'четыре', 'три', 'один', 'пять'] >>> rand_gen.sample ('abcdefghijklmn', 3) ['g', 'e', 'c']
Имейте в виду, что SystemRandom не гарантируется, что он будет доступен во всех системах, на которых работает Python (хотя обычно так и есть).
Python 3.6+ - секретов Модуль:
Если вы работаете над Python 3 и ваша цель - генерировать криптографически безопасные случайные числа, то обязательно ознакомьтесь с модулем секретов .