Случайное число python: Случайные числа в Python / Skillbox Media

Модуль random в Python: примеры с кодом

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

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

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

Компьютер не имеет воображения и «придумать» сам ничего не может. Но он может выполнить специальный алгоритм, имитирующий случайную генерацию.

В 1997 году  японские ученые Макото Мацумото и Такудзи Нисимура разработали математический алгоритм для генерации случайной величины, который называется вихрь Мерсенна. Хотя этот алгоритм не является криптостойким, он часто используется в программировании для решения простых задач, где вопрос безопасности не критичен.

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

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

Функции модуля random

Генерация случайных чисел: примеры использования

Составление плей-листа

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

import random #подключаем модуль псевдослучайных функций Python

myplaylist = ["Pink Floyd", "Santana", "The Beatles", "ELO", "Mark Knopfler", "KennyG", "Bob Dylan"]    #описание плей-листа

print(random.sample(myplaylist, k=3)) #случайных выбор трех позиций списка и вывод результата на экран

Случайное воспроизведение

В любом плеере есть функция случайного воспроизведения. Попробуем реализовать это с помощью Python, перемешивая треки в заранее составленном плей-листе:

import random #подключаем модуль псевдослучайных функций Python

myplaylist = ["Pink Floyd", "Santana", "The Beatles", "ELO", "Mark Knopfler", "KennyG", "Bob Dylan"]  #описание плей-листа

random.shuffle(myplaylist) #перемешиваем список

print(myplaylist) #вывод результата на экран

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

Представим, что нам нужно получить семь раз случайное число в диапазоне от трех до девяти:

import random  #подключаем модуль псевдослучайных функций Python

for i in range(7): #создаем цикл на семь повторений

print(random.randint(3, 9)) #вывод результата

Победитель розыгрыша

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

import random #подключаем модуль псевдослучайных функций Python

members = ["Василий", "Евгений", "Олег", "София", "Инна", "Василиса", "Петр"] #описание списка участников

print(random.choice(members)) #выбор и вывод имени победителя на экран

Случайное дробное число в нужном диапазоне

Представим, что нам нужно получить случайное дробное число в диапазоне от 20 до 40:

import random #подключаем модуль псевдослучайных функций Python

print(random.uniform(20, 40)) #выбор случайного числа и вывод на экран

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

Случайные числа в Python

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

Пример:

import random
print (random.random())

Когда вы запустите приведенный выше Пример:, вы получите случайное число с плавающей точкой меньше 1 и больше или равно 0.

Создать случайное число от 0 до 5?

from random import randint
print (randint(0, 5))

Создать 10 случайных чисел от 1 до 100?

import random
for i in range(10):
print (random.randint(1,101))

В приведенном выше коде будет напечатано 10 случайных значений чисел от 1 до 100.

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

from random import *
print(randrange(1,10))

Как выбрать случайное число из списка?

import random
list = [1,2,3,4,5]
print(random.choice(list))

Пример:

import random
list = [‘East’,’West’,’South’,’North’]
print(random.choice(list))

Как выбрать случайные числа из списка?

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

Как перетасовать список?

from random import *
list = [1,2,3,4,5,6,7,8,9,10]
shuffle(list)
print(list)

Источник: net-informations.com

python — Как сгенерировать N случайных чисел в Python 3 от 0 до бесконечности

Как мне сгенерировать n случайных чисел в Python 3? n является определяемой переменной. предпочтительно натуральные числа (целые числа> 0), все ответы, которые я нашел, берут случайные целые числа из диапазона, однако я не хочу генерировать числа из диапазона. (если диапазон не равен 0 до бесконечности)

2

Billy Cole

12 Фев 2016 в 14:45

3 ответа

Лучший ответ

В мире компьютеров / вычислений не бывает бесконечности. Вы можете получить наибольшее положительное целое число, поддерживаемое вашим компьютером, используя {{X0} } (sys.maxint в python 2) и передайте его в функцию random.randint:

>>> import sys
>>> sys.maxsize
9223372036854775807
>>> random.randint(0,sys.maxsize)
7512061515276834201

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

>>> N = 10
>>> [random.randint(0,sys.maxsize) for _ in range(N)]
[3275729488497352533, 7487884953907275260, 36555221619119354, 1813061054215861082, 619640952660975257, 9041692448390670491, 5863449945569266108, 8061742194513906273, 1435436865777681895, 8761466112930659544]

Для получения дополнительной информации о разнице sys.maxint и sys.maxsize в Python 2.X и 3.X:

Константа sys.maxint была удалена, так как больше нет ограничение на значение целых чисел. Тем не менее, sys.maxsize может использоваться как целое число больше, чем любой практический список или строковый индекс. Соответствует «натуральный» целочисленный размер реализации и, как правило, тот же как sys.maxint в предыдущих выпусках на той же платформе (при условии такие же варианты сборки).

10

Kasramvd
2 Янв 2020 в 17:55

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

Импорт системы

От случайного импорта *

Для диапазона i (sys.maxsize): print (randint (0,9), randint (0,9), randint (0,9), randint (0,9), randint (0,9), randint (0) , 9 ) , сентябрь = » )

0

Badboy
17 Апр 2020 в 18:44

Я думаю, что вам, вероятно, нужно переосмыслить то, что вы пытаетесь сделать со случайным числом, которое вы хотите. В частности, из какого распределения вы выбираете число? Если вы хотите, чтобы ваши случайные числа были равномерно распределены (равная вероятность каждого выбранного числа), вы не можете: вам понадобится бесконечный объем памяти (или время, или оба).

Конечно, если вы разрешите неравномерное распределение, вот некоторые случайные числа между 1 и (примерно) наибольшим float, разрешенным моей системой, но есть пробелы из-за способа представления таких чисел. И вы можете почувствовать, что вероятность выбора «больших» чисел падает гораздо быстрее, чем вы хотели бы …

In [254]: [int(1./random.random()) for i in range(10)]
Out[254]: [1, 1, 2, 1, 1, 117, 1, 3, 2, 6]

2

xnx
12 Фев 2016 в 12:09

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

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

Генерация случайного числа с помощью модуля Random

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

import random

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

Random.random

Функция возвращает случайное число в диапазоне 0 — 1.

import random
print(random.random())
>>> 0.172676650596703
print(random.random())
>>> 0.41967198132083483
print(random.random())
>>> 0.9918523889221545

Random.uniform

Функция возвращает случайное вещественное число в указанном диапазоне.

import random
print(random.uniform(0, 100))
>>>26.937418056935602
print(random.uniform(0, 100))
>>>50.37814119663015
print(random.uniform(0, 0.1))
>>>0.022964850436330765

В скобках указывается диапазон чисел random.unifrom(начало, конец).

Random.randint

Функция возвращает случайное целое число из указанного диапазона.

import random
print(random.randint(0, 100))
>>> 3
print(random.randint(0, 100))
>>> 54
print(random.randint(0, 100000))
31842

В скобках указывается диапазон чисел random.randint(начало, конец)

Random.randrange

Функция возвращает случайное число из указанного диапазона с определенным шагом. То есть, если мы зададим диапазон 0 — 10 и шаг 5, то функция вернет 0, 5 или 10.

import random
print(random.randrange(0, 20, 5))
>>>0
print(random.randrange(0, 20, 5))
>>>15
print(random.randrange(0, 20, 2))
>>>12

В скобках указывается диапазон чисел и шаг, с которым выбирается случайное число random.randrage(начало, конец, шаг)

Random.choince

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

import random
print(random.choices([0, 1, 12]))
>>>[0]
print(random.choices([0, 1, 12]))
>>>[12]
print(random.choices([0, 1, 12]))
>>>[1]

Функция задается в формате random.choise(список).

Как генерировать случайные числа в Python

Дата публикации 2018-07-04

Использование случайности является важной частью конфигурации и оценки алгоритмов машинного обучения.

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

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

После завершения этого урока вы узнаете:

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

Давайте начнем.

Обзор учебника

Этот урок разделен на 3 части; они есть:

1. Генераторы псевдослучайных чисел
2. Случайные числа с Python
3. Случайные числа с NumPy

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

ИсточникхаотичностьТо, что мы внедряем в наши программы и алгоритмы, — это математический прием, называемый генератором псевдослучайных чисел.

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

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

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

Ценность семени не имеет значения. Выбери что хочешь. Что важно, так это то, что один и тот же начальный этап процесса приведет к одинаковой последовательности случайных чисел.

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

2. Случайные числа с Python

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

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

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

Seed Генератор случайных чисел

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

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

семена ()функция запустит генератор псевдослучайных чисел, принимая в качестве аргумента целочисленное значение, например 1 или 7. Если функция seed () не вызывается до использования случайности, по умолчанию используется текущее системное время в миллисекундах с начала эпохи ( 1970).

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

# seed the pseudorandom number generator
from random import seed
from random import random
# seed random number generator
seed(1)
# generate some random numbers
print(random(), random(), random())
# reset the seed
seed(1)
# generate some random numbers
print(random(), random(), random())

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

0.13436424411240122 0.8474337369372327 0.763774618976614
0.13436424411240122 0.8474337369372327 0.763774618976614

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

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

Случайные значения с плавающей точкой

Случайные значения с плавающей точкой могут быть получены с помощьюслучайным образом ()функция. Значения будут генерироваться в диапазоне от 0 до 1, особенно в интервале [0,1).

Значения взяты из равномерного распределения, что означает, что каждое значение имеет равные шансы на рисование.

Пример ниже генерирует 10 случайных значений с плавающей запятой.

# generate random floating point values
from random import seed
from random import random
# seed random number generator
seed(1)
# generate random numbers between 0-1
for _ in range(10):
	value = random()
	print(value)

Выполнение примера генерирует и печатает каждое случайное значение с плавающей запятой

0.13436424411240122
0.8474337369372327
0.763774618976614
0.2550690257394217
0.49543508709194095
0.4494910647887381
0.651592972722763
0.7887233511355132
0.0938595867742349
0.02834747652200631

Значения с плавающей запятой можно изменить до требуемого диапазона, умножив их на размер нового диапазона и добавив минимальное значение следующим образом:

scaled value = min + (value * (max - min))

кудамина такжеМаксимумминимальные и максимальные значения желаемого диапазона соответственно, изначениеэто случайно сгенерированное значение с плавающей запятой в диапазоне от 0 до 1.

Случайные целочисленные значения

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

Эта функция принимает два аргумента: начало и конец диапазона для сгенерированных целочисленных значений. Случайные целые числа генерируются в пределах, включая начало и конец значений диапазона, особенно в интервале [начало, конец]. Случайные значения взяты из равномерного распределения.

Пример ниже генерирует 10 случайных целых значений от 0 до 10.

# generate random integer values
from random import seed
from random import randint
# seed random number generator
seed(1)
# generate some integers
for _ in range(10):
	value = randint(0, 10)
	print(value)

Выполнение примера генерирует и печатает 10 случайных целочисленных значений.

2
9
1
4
1
7
7
7
10
6

Случайные гауссовские значения

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

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

В приведенном ниже примере генерируется 10 случайных значений из гауссовского распределения со средним значением 0,0 и стандартным отклонением 1,0.

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

# generate random Gaussian values
from random import seed
from random import gauss
# seed random number generator
seed(1)
# generate some Gaussian values
for _ in range(10):
	value = gauss(0, 1)
	print(value)

Выполнение примера генерирует и печатает 10 гауссовских случайных значений.

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 и использовать его для случайного выбора элемента из списка.выбор()Функция реализует это поведение для вас. Выборы сделаны с одинаковой вероятностью.

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

# choose a random element from a list
from random import seed
from random import choice
# seed random number generator
seed(1)
# prepare a sequence
sequence = [i for i in range(20)]
print(sequence)
# make choices from the sequence
for _ in range(5):
	selection = choice(sequence)
	print(selection)

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

[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

Случайная выборка из списка

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

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

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

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

# select a random sample without replacement
from random import seed
from random import sample
# seed random number generator
seed(1)
# prepare a sequence
sequence = [i for i in range(20)]
print(sequence)
# select a subset without replacement
subset = sample(sequence, 5)
print(subset)

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

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

Случайно перемешать список

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

перетасовать ()Функция может быть использована для перемешивания списка. Перестановка выполняется на месте, это означает, что список предоставляется в качестве аргументаперетасовать ()функция тасуется, а не тасуется копия создаваемого и возвращаемого списка.

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

# randomly shuffle a sequence
from random import seed
from random import shuffle
# seed random number generator
seed(1)
# prepare a sequence
sequence = [i for i in range(20)]
print(sequence)
# randomly shuffle the sequence
shuffle(sequence)
print(sequence)

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

[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. Он должен быть посеян и использоваться отдельно.

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

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

# seed the pseudorandom number generator
from numpy.random import seed
from numpy.random import rand
# seed random number generator
seed(1)
# generate some random numbers
print(rand(3))
# reset the seed
seed(1)
# generate some random numbers
print(rand(3))

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

[4.17022005e-01 7.20324493e-01 1.14374817e-04]
[4.17022005e-01 7.20324493e-01 1.14374817e-04]

Массив случайных значений с плавающей точкой

Массив случайных значений с плавающей запятой может быть создан с помощьюRand ()Функция NumPy.

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

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

# generate random floating point values
from numpy.random import seed
from numpy.random import rand
# seed random number generator
seed(1)
# generate random numbers between 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]

Массив случайных целочисленных значений

Массив случайных целых чисел может быть создан с использованиемrandint ()Функция NumPy.

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

Пример ниже демонстрирует генерацию массива случайных целых чисел.

# generate random integer values
from numpy.random import seed
from numpy.random import randint
# seed random number generator
seed(1)
# generate some integers
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]

Массив случайных гауссовских значений

Массив случайных гауссовских значений может быть создан с использованиемrandn ()Функция NumPy.

Эта функция принимает один аргумент, чтобы указать размер результирующего массива. Гауссовские значения взяты из стандартного гауссовского распределения; это распределение имеет среднее значение 0,0 и стандартное отклонение 1,0.

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

# generate random Gaussian values
from numpy.random import seed
from numpy.random import randn
# seed random number generator
seed(1)
# generate some Gaussian values
values = randn(10)
print(values)

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

[ 1.62434536 -0.61175641 -0.52817175 -1.07296862  0.86540763 -2.3015387
  1.74481176 -0.7612069   0.3190391  -0.24937038]

Значения из стандартного гауссовского распределения можно масштабировать, умножая значение на стандартное отклонение и добавляя среднее значение от желаемого масштабированного распределения. Например:

scaled value = mean + value * stdev

кудаимею в видуа такжеSTDEVсреднее значение и стандартное отклонение для желаемого масштабного распределения Гаусса изначениеявляется случайно сгенерированным значением из стандартного распределения Гаусса.

Shuffle NumPy Array

Массив NumPy может быть произвольно перемешан на месте с помощьюперетасовать ()Функция NumPy.

Пример ниже демонстрирует, как перемешать массив NumPy.

# randomly shuffle a sequence
from numpy.random import seed
from numpy.random import shuffle
# seed random number generator
seed(1)
# prepare a sequence
sequence = [i for i in range(20)]
print(sequence)
# randomly shuffle the sequence
shuffle(sequence)
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]

Дальнейшее чтение

Этот раздел предоставляет больше ресурсов по теме, если вы хотите углубиться.

Резюме

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

В частности, вы узнали:

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

У вас есть вопросы?
Задайте свои вопросы в комментариях ниже, и я сделаю все возможное, чтобы ответить.

Оригинальная статья

Как сгенерировать случайные числа, в которых каждое случайное число имеет разность не менее x со всеми другими элементами?

Было бы хорошо, если бы вопрос показывал больше усилий для решения проблемы (например, из Stack Overflow Tour : «Не задавай о … Вопросах, на которые ты не пытался найти ответ (покажи свою работу) !) «), но иногда вопрос вызывает зуд, который вы просто должны почесать …

Вот один способ, которым вы могли бы сделать это, записанный как функция random_spaced:

import numpy as np


def random_spaced(low, high, delta, n, size=None):
    """
    Choose n random values between low and high, with minimum spacing delta.

    If size is None, one sample is returned.
    Set size=m (an integer) to return m samples.

    The values in each sample returned by random_spaced are in increasing
    order.
    """
    empty_space = high - low - (n-1)*delta
    if empty_space < 0:
        raise ValueError("not possible")

    if size is None:
        u = np.random.Rand(n)
    else:
        u = np.random.Rand(size, n)
    x = empty_space * np.sort(u, axis=-1)
    return low + x + delta * np.arange(n)

Например,

In [27]: random_spaced(0, 200, 15, 5)
Out[27]: array([ 30.3524969 ,  97.4773284 , 140.38221631, 161.9276264 , 189.3404236 ])

In [28]: random_spaced(0, 200, 15, 5)
Out[28]: array([ 81.01616136, 103.11710522, 118.98018499, 141.68196775, 169.02965952])

Аргумент size позволяет генерировать более одного семпла за раз:

In [29]: random_spaced(0, 200, 15, 5, size=3)
Out[29]: 
array([[ 52.62401348,  80.04494534,  96.21983265, 138.68552066, 178.14784825],
       [  7.57714106,  33.05818556,  62.59831316,  81.86507168, 180.30946733],
       [ 24.16367913,  40.37480075,  86.71321297, 148.24263974, 195.89405713]])

Этот код генерирует гистограмму для каждого компонента, используя 100000 выборок, и строит соответствующие теоретические маргинальные PDF-файлы каждого компонента:

import matplotlib.pyplot as plt
from scipy.stats import beta

low = 0
high = 200
delta = 15 
n = 5
s = random_spaced(low, high, delta, n, size=100000)

for k in range(s.shape[1]):
    plt.hist(s[:, k], bins=100, density=True, alpha=0.25)
plt.title("Normalized marginal histograms and marginal PDFs")
plt.grid(alpha=0.2)

# Plot the PDFs of the marginal distributions of each component.
# These are beta distributions.
for k in range(n):
    left = low + k*delta
    right = high - (n - k - 1)*delta
    xx = np.linspace(left, right, 400)
    yy = beta.pdf(xx, k + 1, n - k, loc=left, scale=right - left)
    plt.plot(xx, yy, 'k--', linewidth=1, alpha=0.25)
    if n > 1:
        # Mark the mode with a dot.
        mode0 = k/(n-1)
        mode = (right-left)*mode0 + left
        plt.plot(mode, beta.pdf(mode, k + 1, n - k, loc=left, scale=right - left),
                 'k.', alpha=0.25)

plt.show()

Вот сюжет, который он генерирует:

Как видно на графике, маргинальные распределения — это бета-распределения . Режимы маргинальных распределений соответствуют позициям n равномерно распределенных точек на интервале [low, high].

Путем изучения того, как генерируется u в random_spaced, можно создавать распределения с разными маргиналами (в старой версии этого ответа был пример), но распределение, которое в настоящее время генерирует random_spaced, кажется естественным выбором. Как упоминалось выше, режимы маргиналов встречаются в «значимых» позициях. Более того, в тривиальном случае, когда n равен 1, распределение упрощается до равномерного распределения на [low, high].

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

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

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

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

import random

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

print(random_number_1, random_number_2) # 1 2

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

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

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

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

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

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

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

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

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

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

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

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

>>> random.random()
0.668544544081956

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

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

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

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

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

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

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

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

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

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

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

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

Марк Лутц «Изучаем Python»

Скачивайте книгу у нас в телеграм

Скачать

×

Python Random Number Generator — Python Random Module

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

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

Но разве «случайное» перемешивание плейлиста не кажется случайным? Это потому, что эти случайные числа не являются действительно случайными, а скорее псевдослучайными числами.Генератор псевдослучайных чисел (ГПСЧ) представляет собой алгоритм , который генерирует кажущиеся случайными числа. Давайте узнаем о Генераторе случайных чисел Python.

Python Random Module

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

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

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

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

Встроенные функции для генератора случайных чисел Python

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

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

1. Python randint ()

Эта функция генерирует целое число между указанными пределами. Он принимает два аргумента x и y и производит целое число i такое, что x <= i <= y.

 >>> импорт случайный
>>> random.randint (3, 6)
 

Вывод:

4
>>>

2. Python randrange ()

Эта функция принимает 2 аргумента start и stop вместе с 1 необязательным шагом аргумента. И возвращает случайное целое число в диапазоне (начало, остановка, шаг).Значение шага по умолчанию — 1.

 >>> import random
>>> random.randrange (1, 10, 2)
 

Вывод:

3
>>>

В этом примере выводом будет случайное целое число из [1, 3, 5, 7, 9], поскольку начальное и конечное значения равны 1 и 10 соответственно и значение шага равно 2.

3. Python random ()

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

 >>> импорт случайный
>>> случайный.случайный()
 

Вывод:

0,5313843048739985
>>>

4. Python uniform ()

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

 >>> импорт случайный
>>> random.uniform (6, 9)
 

Выход:

6.338126781525701
>>>

5.Python choice ()

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

 >>> импорт случайный
>>> seq = (12, 33, 67, 55, 78, 90, 34, 67, 88)
>>> random.choice (seq)
 

Вывод:

67
>>>

6. Python sample ()

Если вам нужно несколько случайных элементов из последовательности, вы можете использовать sample ().Он принимает два аргумента: совокупность и k, где совокупность — это последовательность, а k — целое число. Затем он возвращает список из k случайных элементов из популяции последовательностей.

 >>> импорт случайный
>>> seq = (12, 33, 67, 55, 78, 90, 34, 67, 88)
>>> random.sample (seq, 5)

 

Вывод:

[33, 90, 78, 88, 12]
>>>

7. Python shuffle ()

Эта функция принимает один аргумент — список. Затем он перемешивает элементы списка на месте и возвращает None.

 >>> импорт случайный
>>> l = [10, 20, 30, 40, 50]
>>> random.shuffle (l)
>>> print (l)
 

Вывод:

[20, 40, 30, 50, 10]

8. Python seed ()

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

 импорт случайный
# начальное значение = 3
random.seed (3)
для i в диапазоне (3):
    print (random.random (), конец = '')

печать ('\ п')

# начальное значение = 8
random.seed (8)
для i в диапазоне (3):
    print (random.random (), конец = '')

печать ('\ п')

# начальное значение снова = 3
random.seed (3)
для i в диапазоне (3):
    print (random.random (), конец = '')

печать ('\ п')
 

Выход:

0,2379646270

37 0,54422
959519 0,369955166548079250.2267058593810488 0,9622950358343828 0,12633089865085956 
 
 0.2379646270
37 0,54422
959519 0,36995516654807925 
 
 >>> 
 
 Обратите внимание, что для seed = 3 каждый раз создается одна и та же последовательность. 
 
 Резюме 
 
 В этой статье мы рассмотрели некоторые наиболее часто используемые функции, способные генерировать псевдослучайные числа в Python. Мы видели функции, которые можно использовать для генерации целых чисел. Мы также увидели, как генерировать случайные значения с плавающей запятой. Наконец, мы увидели, как мы можем использовать встроенные функции для выбора случайных элементов из последовательности.Вы можете создавать различные небольшие проекты, используя случайные числа. Вы можете создавать игры, вы можете использовать случайные числа при работе со статистикой в ​​Data Science и многое другое. Используйте свое творчество и играйте с числами! 
 
  Надеюсь, вам понравился учебник по генератору случайных чисел Python !!  
 
 Генерация случайных чисел в Python (random, randrange, randint и т. Д.) 
 
 В Python вы можете генерировать псевдослучайные числа (числа с плавающей запятой  float  и целые числа  int ) с помощью функций  random () ,  униформа () ,  randrange ()  и т. Д.в случайном модуле. 
 
 Модуль random включен в стандартную библиотеку, поэтому дополнительная установка не требуется. 
 
 В этой статье описывается следующее содержание. 
 
 
  random.random () : 0,0 <=  с плавающей точкой  <1,0 
 
  random.uniform () :  float  в любом диапазоне 
 
 Генерировать случайные числа для различных распределений (Гаусса, гамма и т. Д.) 
 
  random.randrange () :  int  в любом диапазоне и шаге 
 
  случайный.randint () :  int  в любом диапазоне 
 
 Создать список случайных чисел 
 
  random.seed () : Инициализировать генератор случайных чисел 
 
 
 См. Следующую статью о том, как случайным образом извлекать или перемешивать элементы списка. 
 
 
 random.random () : 0,0 <=  с плавающей точкой  <1,0 
 
  random.random ()  генерирует случайное число с плавающей запятой  float  в диапазоне  0,0 <= n <1.0 . 
 
  импорт случайный

печать (random.random ())
# 0.449683
76701
  
 random.uniform () :  float  в любом диапазоне
  random.uniform (a, b)  генерирует случайное число с плавающей запятой  float  в диапазоне  a <= n <= b  или  b <= n <= a .
  импорт случайный

печать (random.uniform (100, 200))
# 175.26585048238275
  
 Два аргумента могут быть больше или меньше.Если они равны, возвращается только это значение.
  принт (random.uniform (100, -100))
# -27.82338731501028

печать (random.uniform (100, 100))
# 100.0
  
 Аргумент также может быть указан как  с плавающей запятой .
  принт (random.uniform (1.234, 5.637))
# 2.606743596829249
  
 Включение значения  b  в диапазон зависит от уравнения округления  a + (b-a) * random.random () , как описано в документации.
 Значение конечной точки  b  может или не может быть включено в диапазон в зависимости от округления с плавающей запятой в уравнении  a + (b-a) * random () .
  random.uniform () - Генерация псевдослучайных чисел - документация Python 3.9.7 
 Генерировать случайные числа для различных распределений (гауссово, гамма и т. Д.) 
 Хотя указанные выше  random (),  и  uniform ()  генерируют случайные числа для равномерного распределения, также предусмотрены функции генерации для различных распределений.
 Бета-распределение:  random.betavariate () 
 Экспоненциальное распределение:  random.expovariate () 
 Гамма-распределение:  random.gammavariate () 
 Гауссово распределение:  random.gauss () 
 Логарифм нормального распределения:  random.lognormvariate () 
 Нормальное распределение:  random.normalvariate () 
 Распределение фон Мизеса:  random.vonmisesvariate () 
 Распределение Парето:  случайное.паретовариат () 
 Распределение Вейбулла:  random.weibullvariate () 
 Дополнительную информацию о каждом дистрибутиве см. В официальной документации.
 random.randrange () :  int  в любом диапазоне и шаге
  random.randrange (start, stop, step)  возвращает случайно выбранный элемент из диапазона  (start, stop, step) .
 Как и в случае с  range () ,  start  и  step  могут быть опущены.Если они не указаны,  start = 0  и  step = 1 .
  импорт случайный

печать (список (диапазон (10)))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

печать (random.randrange (10))
# 5
  
 Вы можете сгенерировать четное или нечетное случайное целое число или случайное целое число, кратное любому целому числу. Например, если  start  четное и  step = 2 , случайным образом генерируется только четное целое число в диапазоне.
  печать (список (диапазон (10, 20, 2)))
# [10, 12, 14, 16, 18]

печать (случайный.randrange (10, 20, 2))
# 18
  
 random.randint () :  int  в любом диапазоне
  random.randint (a, b)  возвращает случайное целое число  int  in  a <= n <= b . Это эквивалентно  random..randrange (a, b + 1) . Обратите внимание, что значение  b  также включено в диапазон.
  печать (random.randint (50, 100))
# print (random.randrange (50, 101))
# 74
  
 Создать список случайных чисел 
 Список случайных 
 с плавающей запятой 
 Чтобы сгенерировать список, элементы которого являются случайными числами с плавающей запятой, используйте  random () ,  uniform ()  и т. Д.с пониманием списка.
  импорт случайный

print ([random.random () для i в диапазоне (5)])
# [0.5518201298350598, 0.34764933616, 0.8463426180468342, 0.89453303931, 0.40822657702632625]
  
 Дополнительные сведения о составлении списков см. В следующей статье.
 Список случайных 
 int 
 При генерации списка, элементы которого являются целыми случайными числами, с использованием  randrange ()  или  randint ()  с интерпретациями списка могут содержаться повторяющиеся значения.
  print ([random.randint (0, 10) для i в диапазоне (5)])
# [8, 5, 7, 10, 7]
  
 Если вы хотите составить список целых случайных чисел без дублирования, извлеките элементы  range ()  с помощью  random.sample () .
  печать (random.sample (диапазон (10), k = 5))
# [6, 4, 3, 7, 5]

print (random.sample (диапазон (100, 200, 10), k = 5))
# [130, 190, 140, 150, 170]
  
 Дополнительные сведения о  random см. В следующей статье.образец () .
 random.seed () : Инициализировать генератор случайных чисел
 Вы можете инициализировать генератор случайных чисел с помощью  random.seed () .
 После инициализации с тем же начальным значением случайное число генерируется таким же образом.
  random.seed (0)
печать (random.random ())
# 0.8444218515250481

печать (random.random ())
# 0.7579544029403025

random.seed (0)
печать (random.random ())
# 0.8444218515250481

печать (random.random ())
# 0.7579544029403025
  
 Python - Генерировать случайное число - положительное или отрицательное 
 Генерировать случайное число в Python 
 Случайное число представляет интерес в таких приложениях, как обработка сигналов, анализ данных, статистика и т. Д. Вы можете сгенерировать случайное число в программировании на Python с помощью модуля Python назвал  случайный .
 Чтобы сгенерировать случайное число в python, вы можете импортировать случайный модуль и использовать функцию randInt ().
 В этом руководстве мы узнаем, как сгенерировать случайное число с помощью модуля Python random.
 Синтаксис - randInt () 
 Вам необходимо импортировать  случайных пакетов , прежде чем вы сможете вызывать какие-либо его функции в своей программе. Следующий оператор импортирует  случайных пакетов  в вашу программу.
  import random  
 Синтаксис randInt ():
  randomnumber = random.randint (минимум, максимум)  
 где
 [минимум, максимум] - это диапазон, из которого случайное целое число selected
 Функция randint () возвращает целое число
 Генерация случайного числа применяется для моделирования однородных вероятностных событий, азартных игр, статистической выборки и т. д.
 Пример 1: Генерация случайного числа в Python 
 В следующем примере мы сгенерируем случайное число в диапазоне [10, 152].
  Программа Python 
  импорт случайный

randomnumber = random.randint (10, 152)
print (randomnumber)  
 Run
  Output 
  C: \ python> python example.py
144

C: \ python> python example.py
12

C: \ python> python example.py
79

C: \ python> пример Python.ру
54  
 Каждый раз при запуске функции randint () случайным образом генерируется другое число.
 Пример 2: Создание случайного отрицательного числа 
 Вы можете указать отрицательный диапазон, из которого можно выбрать случайное число. Укажите максимальное и минимальное допустимые отрицательные числа.
 В следующем примере мы сгенерируем случайное число в диапазоне [-100, -21].
  Программа Python 
  импорт случайный

randomnumber = случайный.рандинт (-100, -21)
print (randomnumber)  
 Run
  Output 
  C: \ python> python example.py
-74

C: \ python> python example.py
-95

C: \ python> python example.py
-70  
 Резюме 
 В этом руководстве примеров Python мы узнали, как сгенерировать случайное число в Python с помощью хорошо подробных примеров.
 Введение в случайные числа в NumPy 
 Что такое случайное число? 
 Случайное число НЕ означает каждый раз новое число.Случайное означает то, что может
 не может быть предсказано логически.
 Псевдослучайное и Истинное случайное. 
 Компьютеры работают по программам, и программы представляют собой окончательный набор инструкций. Значит, должно быть что-то
 алгоритм для генерации случайного числа.
 Если есть программа для генерации случайных чисел, это может быть
 предсказано, поэтому это не совсем случайно.
 Случайные числа, сгенерированные с помощью алгоритма генерации, называются  псевдослучайными .
 Можем ли мы составлять действительно случайные числа?
 Да.Чтобы сгенерировать действительно случайное число на наших компьютерах, нам нужно получить случайные данные от некоторых
 внешний источник. Этим внешним источником обычно являются наши нажатия клавиш, движения мыши, данные в сети.
 пр.
 Нам не нужны действительно случайные числа, если это не связано с безопасностью (например, ключи шифрования) или основой
 применение - случайность (например, колеса цифровой рулетки).
 В этом уроке мы будем использовать псевдослучайные числа.
 Создать случайное число 
 NumPy предлагает модуль  random  для работы со случайными числами.
 Пример 
 Создает случайное целое число от 0 до 100:
 из numpy import random
 x = random.randint (100)
 print (x)
 Попробуй сам "
 Создать случайное число с плавающей запятой 
 Метод  rand ()  модуля random возвращает случайное число с плавающей запятой от 0 до 1.
 Пример 
 Создает случайное число с плавающей запятой от 0 до 1:
 из numpy import random
 x = random.rand ()
 print (x)
 Попробуй сам "
 Создать случайный массив 
 В NumPy мы работаем с массивами, и вы можете использовать два метода из приведенных выше примеров для создания случайных массивов.
 Целые числа 
 Метод  randint ()  принимает размер  
 параметр, в котором вы можете указать форму массива.
 Пример 
 Создайте одномерный массив, содержащий 5 случайных целых чисел от 0 до 100:
 из numpy import random
 x = random.randint (100, size = (5))
 print (x)
 Попробуй сам "
 Пример 
 Создайте двумерный массив с 3 строками, каждая строка содержит 5 случайных целых чисел из 0
 к 100:
 из numpy import random
 x = random.randint (100, размер = (3, 5))
 печать (x)
 Попробуй сам "
 Поплавки 
 Метод  rand ()  также позволяет указать
 форма массива.
 Пример 
 Сгенерировать одномерный массив, содержащий 5 случайных чисел с плавающей запятой:
 из numpy import random
 x = random.rand (5)
 print (x)
 Попробуй сам "
 Пример 
 Создайте двумерный массив с 3 строками, каждая строка содержит 5 случайных чисел:
 из numpy import random
 x = random.rand (3, 5)
 печать (x)
 Попробуй сам "
 Сгенерировать случайное число из массива 
 Метод  choice ()  позволяет генерировать случайное значение на основе массива значений.
 Метод  choice ()  принимает массив как
 параметр и случайным образом возвращает одно из значений.
 Пример 
 Вернуть одно из значений в массиве:
 из numpy import random
 x = random.choice ([3, 5, 7, 9])
 print (x)
 Попробуй сам "
 Метод  choice ()  также позволяет возвращать  массив  значений.
 Добавьте параметр  размера , чтобы указать форму массива.
 Пример 
 Сгенерировать двумерный массив, состоящий из значений параметра массива (3,
 5, 7 и 9):
 из numpy import random
 x = random.choice ([3, 5, 7, 9], size = (3, 5))
 print (x)
 Попробуй сам "
 Python NumPy Random [30 примеров] 
 В этом руководстве по Python вы узнаете о  Python NumPy Random .Давайте посмотрим, как сгенерировать случайные числа в Python с помощью NumPy.
 Мы подробно рассмотрим следующие темы с примерами.
 Что такое случайное число?
 Python NumPy random number
 Как сгенерировать случайное число с плавающей запятой в Python
 Python NumPy random array
 Python NumPy random integer
 Как сгенерировать случайное число из массива в Python
 Python NumPy случайный выбор
 Python Случайное число NumPy randn
 Случайное число Python NumPy
 Случайное число Python NumPy
 Случайное число Python NumPy в диапазоне
 Случайное число Python NumPy между двумя числами
 Случайное число Python NumPy между 0 и 1
 случайное число Python NumPy между 1 и 1 10
 Python numpy random seed
 Python numpy random selection
 Python numpy random integer
 Python numpy random normal
 Python numpy random uniform
 Python numpy random sample
 Python numpy random randn
 Python numpy random number generator
 Python numpy случайная экспонента
 9023 3 Python numpy.random.randomstate
 Python numpy random permutation
 Python numpy random shuffle
 Python numpy random binomial
 Что такое случайное число в python numpy? 
  Случайные числа  - это числа, возвращающие случайное целое число. Случайное число не означает каждый раз новое число. Случайность означает то, что нельзя предсказать логически.
 Читайте: что такое NumPy в Python
 Python случайный набор чисел 
 В Python random - это модуль, доступный в библиотеке NumPy.Этот модуль возвращает массив указанных фигур и заполняет его случайными числами с плавающей запятой и целыми числами.
 Он основан на генерации псевдослучайных чисел, что означает, что это математический способ, который генерирует последовательность почти случайных чисел.
 По сути, это комбинация битового генератора и генератора. В Python случайные значения генерируются генератором и исходят от генератора битов.
  Синтаксис: 
 Вот синтаксис NumPy random
  кол-во.random.random (размер = Нет)  
 Он состоит только из одного параметра
  Размер:  По умолчанию отсутствует
  Возврат:  В Python он всегда возвращает случайное целое число или числа с плавающей запятой между нижним и верхним пределами.
  Примеры: 
 Давайте возьмем пример и посмотрим, как реализовать случайные числа в Python
.
  импорт случайный
импортировать numpy как np

результат = np.random.randint (4)
print (результат)  
 Сначала в приведенном выше коде мы импортируем случайный модуль из библиотеки NumPy.После этого я создаю переменную  ‘result’  и назначаю  np. random ()  и сгенерируйте целое число  ‘4’.  Теперь используйте оператор печати, чтобы проверить, какое число будет отображаться в выводе.
 Вот выполнение следующего данного кода
Python numpy random
 Python numpy случайное число 
 Здесь мы можем увидеть, как  сгенерировать случайное число в numpy Python .
 Для получения случайных чисел в Python мы можем легко использовать функцию  randint () .
 В Python библиотека numpy предоставляет модуль под названием random, который поможет пользователю сгенерировать случайное число.
 В Python функция  randint ()  всегда возвращает случайное целое число между нижним и верхним пределами, эти оба ограничения являются параметрами функции randint ().
  Синтаксис: 
 Вот синтаксис  функции randint () 
  random.randint
             (
             низкий,
             высокий = Нет,
             size = None,
             dtype = int
             )  
 Состоит из нескольких параметров
  low:  Он устанавливает начальный диапазон и принимает только целочисленное значение в качестве параметра.
  высокий:  Это необязательный параметр, который показывает целое число, которое нужно извлечь из распределения.
  dtype:  По умолчанию его значение - int.
  Out:  Это объясняет окончание диапазона.
  Пример: 
 Давайте возьмем пример и посмотрим, как получить случайное число в Python numpy
  Исходный код: 
  импорт случайный
импортировать numpy как np

new_out = случайный.рандинт (2,6)
печать (new_out)  
 В приведенном выше коде сначала мы импортируем случайный модуль, а затем используем функцию  randint ()  и для отображения вывода используйте команду печати, она покажет число от  2 до 6.  Как вы можете видеть мой вывод случайное число  '5'. 
 Вот скриншот следующего кода
Python numpy случайное число
 Давайте посмотрим на другой пример, как  получить случайное число в Python NumPy .Мы можем использовать метод NumPy randint () для генерации случайного числа в Python.
  из случайного импорта numpy
val = random.randint (50)
печать (значение)  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для  Python numpy random number .
Python numpy случайное число
 Чтение: Python NumPy Array
 Python генерирует случайное число с плавающей запятой 
 Теперь мы увидим , как сгенерировать случайное число с плавающей запятой в python . Мы можем использовать метод  Python NumPy rand () , чтобы  сгенерировал случайное число с плавающей запятой в Python .
  из случайного импорта numpy
val = random.rand ()
печать (значение)  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для . Python генерирует случайное число с плавающей запятой .
Python генерирует случайное число с плавающей запятой
 Чтение: Python NumPy Sum
 Python NumPy случайный массив 
 Давайте посмотрим, как использовать  Python numpy random array  в python. Мы можем использовать метод randint () с параметром Size в NumPy для создания случайного массива в Python.
  из случайного импорта numpy
val = random.randint (50, размер = (5))
печать (значение)  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для  Python numpy random array .
Случайный массив Python numpy
 Чтение: программа Python для печати элемента в массиве
 Python NumPy случайное целое число 
 Здесь мы увидим  Python numpy random integer . Ниже кода мы можем использовать приведенный ниже код для создания случайного целого числа в Python NumPy.
  из случайного импорта randrange
печать (randrange (20))  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для  Python numpy random integer .
Python numpy случайное целое число
 Python генерирует случайное число из массива 
 Давайте посмотрим , как сгенерировать случайное число из массива  в Python.
  из случайного импорта numpy
val = random.choice ([3, 5, 7, 9])
печать (значение)  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для  Python, генерирующий случайное число из массива 
Python генерирует случайное число из массива
 Приведенный выше код мы можем использовать для создания случайного числа из массива в Python NumPy.
 Чтение: объединение массивов Python
 Python numpy случайный выбор 
 Теперь мы увидим  Python numpy random selection .
  импортировать numpy как np
randm_num = np.random.choice (18)
print ("Число случайного выбора:")
печать (randm_num)  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для  Python numpy random selection 
Случайный выбор Python numpy
 Python NumPy случайный случайный 
 Теперь мы увидим  Python numpy random randn , пример создания случайного числа с помощью метода Python randn ().
  импортировать numpy как np

random_num = np.random.randn (4)
печать (случайное_число)  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для  Python numpy random randn .
Python NumPy random randn
 Чтение: Python Tkinter Grid
 Случайная выборка Python NumPy 
  numpy.random.sample  () - одна из функций для выполнения случайной выборки в Python NumPy. Использование метода .random sample (). Вот пример случайной выборки:
  импортировать numpy как np

random_num = np.random.random_sample (4)
печать (случайное_число)  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для  Python numpy random sample .
Случайная выборка Python NumPy
 Python NumPy случайная форма 
 Теперь мы будем использовать  Python NumPy random uniform , он создает массив NumPy , заполненный числовыми значениями . Где размер = 0, низкий = 1, высокий = 10. Эти числовые значения берутся из указанного диапазона, от меньшего к большему.
  импортировать numpy как np

random_num = np.random.uniform (0,1,10)
печать (случайное_число)  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для  Python numpy random uniform .
Случайная форма Python NumPy
 Чтение: Python Tkinter OptionMenu
 Python NumPy случайное число в диапазоне 
  Python случайное число NumPy в диапазоне  - это одна функция, которая может генерировать случайные целые числа с помощью функции randint (). Требуется три аргумента. Теперь давайте приведем пример случайного диапазона между (3,8).
  импортировать numpy как np

random_num = np.random.randint (3, размер = 8)
печать (случайное_число)  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для  Python numpy random   number в диапазоне 
Случайное число Python NumPy в диапазоне
 Python NumPy случайным образом между двумя числами 
  Python NumPy random  - это функция модуля random, который используется для генерации случайных целых чисел типа np.int между низким и высоким, где 3 - меньшее значение, 8 - высокое значение, а размер - 10.
  импортировать numpy как np

random_num = np.random.randint (3, размер = (8,10))
печать (случайное_число)  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат для  Python numpy random   между двумя числами 
Python NumPy случайный между двумя числами
 Чтение: преобразование строки в число с плавающей запятой в Python
 Python NumPy случайным образом от 0 до 1 
 В этом примере мы будем использовать функцию  NumPy np.random.seed ()  для отображения случайного числа от 0 до 1.
 Random (3) определяет случайные числа от 0 до 1 - размер ключевого слова. Np.random.seed (число) устанавливает то, что NumPy называет глобальным случайным семенем.
  импортировать numpy как np
np.random.seed (32)
random_num = np.random.random (3)
печать (случайное_число)  
 Вы можете использовать приведенный выше код для  Python NumPy random   от 0 до 1 .
 Python Numpy случайное число от 1 до 10 
 В этом примере мы будем использовать функцию  NumPy randint ()  для генерации случайного числа от 1 до 10.
  импортировать numpy как np
random_num = np.random.randint (1,10)
печать (случайное_число)  
 Приведенный выше код Python, мы можем использовать для  Python NumPy случайным образом от 1 до 10 .
 Python numpy случайное семя 
 Давайте посмотрим, как использовать numpy random seed в Python.
 Numpy random seed используется для установки начального числа и для генерации псевдослучайных чисел. Псевдослучайное число - это число, которое сортируется случайным образом, но на самом деле они не случайны.
 В Python начальное значение - это номер предыдущего значения, реализованный генератором. Если в первый раз предыдущее значение отсутствует, используется рабочее системное время.
 Основная логика случайного начального числа состоит в том, чтобы получить тот же набор случайных чисел для данного начального числа.
  Синтаксис: 
 Вот синтаксис numpy random seed
  random.seed
           (
            себя,
            seed = Нет
           )  
  Примеры: 
 Здесь мы увидим, как выполнить случайное число с тем же начальным значением
  импорт случайный
импортировать numpy как np
нп.random.seed (5)
new_val = np.random.randint (2,6)
печать (новое_значение)  
 В этом примере мы используем случайное число . seed ()  и передайте  ‘5 ‘ в качестве аргумента. После этого я генерирую случайное число от  2 до 6. 
 Вот реализация следующего данного кода
Python numpy random seed
 Python numpy случайный выбор 
 В Python для генерации случайной выборки мы можем использовать концепцию  random. выбор(). Эта функция доступна в библиотеке numpy.
 Эта функция обычно используется в науке о данных и аналитике данных.
 Этот метод принимает четыре параметра и возвращает случайную выборку массива. Случайные выборки очень полезны в областях, связанных с данными.
  Синтаксис: 
 Вот синтаксис случайного выбора numpy
  numpy.choice (
             а,
             size = None,
             replace = True,
             p = Нет
            )  
 Он состоит из нескольких параметров:
  a:  массив numpy и содержит числа.
  Размер:  По умолчанию значение равно None и выводит форму массива.
  заменить:  По умолчанию значение True, и значение может быть выбрано несколько раз.
  Пример: 
 Давайте рассмотрим пример и проверим, как сгенерировать случайную выборку с помощью функции random choice ()
  импортировать numpy как np

new_rand = np.random.choice (15, 2)
печать (new_rand)
  
 Вот результат следующего кода
Случайный выбор Python numpy
 Другой пример создания однородной выборки с использованием функции random choice () 
  Исходный код: 
 
импортировать numpy как np
import matplotlib.pyplot как plt

new_samp = np.random.choice (16, 3000)

num, b, i = plt.hist (new_samp, 21, density = True)
plt.show ()  
 Вот результат следующего кода
Пример случайного выбора Python numpy
 Python numpy случайное целое число 
 Давайте посмотрим, как сгенерировать случайные целые числа в Python numpy.
 Для создания случайных целых чисел мы можем легко использовать функцию  randint () . Эта функция возвращает указанную форму и принимает три аргумента - нижний и верхний предел диапазона.
 Случайные целые числа из дискретной формы указанного типа данных.
  Синтаксис: 
  random.randint (
               низкий,
               высокий = Нет,
               size = None,
               dtype = int
              )  
  Пример: 
 Давайте возьмем пример и проверим, как использовать случайные целые числа в Python numpy
  импортировать numpy как np

res_new = np.random.randint (низкий = 0, высокий = 4, размер = 6)
печать (res_new)
  
 В приведенном выше коде сначала мы импортируем библиотеку numpy, а затем используем np.random () функция. После этого мы передаем  переменных low, high и size  в качестве аргумента.
 Вот выполнение следующего данного кода
Python numpy случайное целое число
 Python numpy random normal 
 Здесь мы можем увидеть, как применить обычный случайный код в Python numpy.
 В этом примере мы можем применить концепцию функции numpy random  normal () . Эта функция позволяет вам объявить массив numpy, в котором хранятся нормально распределенные данные.
 Нормальное распределение также называется кривой из-за его формы и размера, и эти распределения можно использовать при анализе данных, а также оно является частью распределения Гаусса.
  Синтаксис: 
 Вот синтаксис случайного нормального ()
  случайный.нормальный
             (
              loc = 0,0,
              Масштаб = 1,0,
              size = None
             )  
 Он состоит из нескольких параметров:
  loc:  это необязательный параметр и по умолчанию его значение равно  0.0  и представляет собой среднее значение распределения.
  Масштаб:  Этот параметр указывает стандартное отклонение распределения и по умолчанию его значение составляет  1  и должно быть неотрицательным.
  Размер:  Этот параметр определяет форму данного массива, при этом массив может быть  1-мерным, 2-мерным или многомерным. 
  Примеры: 
 Здесь мы обсудим, как реализовать случайную нормальную функцию в Python
.
  импортировать numpy как np
 
new_res = np.random.normal (размер = 4)
 
print (new_res)  
 В приведенном выше коде сначала мы импортируем библиотеку numpy, затем мы будем использовать концепцию функции  random.normal ()  вместе с размером  = 4  в качестве аргумента, и результат будет отображаться как массив размером  5 
 Вот выполнение следующего данного кода
Python numpy random normal
 Другой способ проверить, как использовать случайные нормальные функции в Python 
  Исходный код: 
  импортировать numpy как np

из matplotlib импортировать pyplot как plt

new_out = np.random.normal (размер = 300)

печать (new_out)
число, x, y = plt.hist (new_out, 40)
plt.show ()  
 Здесь мы будем использовать метод  normal ()  случайного модуля. Теперь я хочу отобразить триста случайных чисел выборки из функции normal () и передать  size = 300  в качестве аргумента. В этом примере я также покажу случайную выборку на графике с помощью пакета  matplotlib .
  Выход: 
Python numpy random normal matplotlib
 Python numpy random normal matplotlib graph
 Как вы можете видеть на выходе, распределение количества образцов показывает форму колоколообразной кривой
 Python numpy random uniform 
 Давайте посмотрим, как использовать numpy random uniform в Python.
 Функция numpy random uniform создает равномерно распределенные значения и возвращает случайную выборку в виде массива с помощью этой функции. В Python равномерное распределение означает, что это тип вероятности, а вероятность всегда дает разные результаты.
 В этом методе есть диапазон, который мы можем объявить по минимуму и максимуму.
  Синтаксис: 
 Вот синтаксис numpy random uniform
  случайный. Униформа
              (
               низкий = 0.0,
               высокий = 1,0,
               size = None
              )  
 Состоит из нескольких параметров.
  low:  Этот параметр является начальной точкой диапазона и по умолчанию его значение равно 0, и оно будет больше или равно минимуму.
  high:  Этот параметр является конечной точкой диапазона, и результирующее значение будет меньше высокого, и по умолчанию его значение равно  1.0. 
  Размер:  Этот параметр определяет форму данного массива.
  Пример: 
  импортировать numpy как np

new_result = np.random.uniform (0, 6, размер = 3)
печать (новый_результат)  
 Вот выполнение следующего данного кода
Python numpy random uniform
 Альтернативный способ проверить, как реализовать numpy random uniform function в Python 
  Исходный код: 
  импортировать numpy как np
импортировать matplotlib.pyplot как plt

new_val = np.random.uniform (-4, 4, 3000)

plt.hist (новое_значение, бункеры = 40, плотность = Истина)
plt.show ()  
 В этом примере мы можем использовать np.  random.uniform ()  метод получения случайных выборок из распределенных значений.
 Вот скриншот следующего кода
 Python numpy random sample 
 Здесь мы можем сгенерировать случайную выборку в Python.
 В Python модуль numpy предоставляет функцию np.random.sample () для выполнения случайной выборки в массиве. Этот метод определяет диапазон случайных значений с плавающей запятой в виде одномерного массива.
 Он всегда возвращает массив случайных чисел с плавающей запятой в диапазоне  [0,0,1,0). 
  Синтаксис: 
 Вот синтаксис случайной выборки numpy
  numpy.random.sample (
                    size = None
                   )  
  Исходный код: 
  импортировать numpy как np

new_res_arr = np.random.sample (размер = (2, 2))
print (new_res_arr)  
 В приведенном выше коде мы сгенерировали случайное число .sample () , в которой мы передаем в качестве аргумента размер  (2,2) .
  Выход: 
Случайный образец Python numpy
 Python numpy random randn 
 Давайте посмотрим, как использовать функцию Numpy random randn () в Python.
 В Python метод  random randn ()  создает массив numpy и возвращает образец распределения. Этот метод принимает форму массива и заполняет его случайными значениями.
 Эта функция возвращает все значения в среднем распределении со значениями с плавающей запятой.
  Синтаксис: 
 Вот синтаксис функции numpy random randn ()
  numpy.random.randn (d0, d1, .... dn)  
 Здесь  do, d1,… dn  это необязательный параметр, и он проверяет условие, если параметр не задан, возвращается одно значение с плавающей запятой. Размер массива не должен быть отрицательным. Эта функция генерирует фигуру, заполненную значениями с плавающей запятой.
  Примеры: 
 Давайте возьмем пример и посмотрим, как использовать функцию numpy random randn () в Python
.
  импортировать numpy как np

new_arr = np.random.randn (2, 3)
print (new_arr)  
 Вот выполнение следующего данного кода
Python numpy random randn
 Как видно из выходных данных, значения представлены в форме с плавающей запятой
 Другой пример создания трехмерного массива с помощью функции random randn ()
  Исходный код: 
  импортировать numpy как np

d_arr = np.random.randn (5, 3, 2)
печать (d_arr)

d_arr2 = np.random.randn (3, 5, 3,4)
print ("Многомерный массив", d_arr2)
  
 Вы можете обратиться к приведенному ниже снимку экрана, чтобы увидеть результат
Python numpy random randn
 Python numpy генератор случайных чисел 
 В Python генератор обеспечивает вход в широкий диапазон нормального распределения и заменяется случайным состоянием.
 Это математический способ, который генерирует последовательность почти случайных чисел, а генератор полагается на дополнительный битовый генератор для управления случайными битовыми числами. В Python случайные значения генерируются генератором и исходят от генератора битов.
  Синтаксис: 
 Вот синтаксис генератора случайных чисел numpy
  numpy.random.default_rng ()  
  Примечание:  По умолчанию битовый генератор принимает значение  (PCG64) , и если вы хотите инициализировать битовый генератор, используйте в нем начальный параметр, и он вернет инициализированный объект генератора.
  Пример: 
  импортировать numpy как np

gen_new = np.random.default_rng (4567)
печать (gen_new)
new_val = gen_new.random ()
печать (новое_значение)  
 Вот выполнение следующего данного кода
Генератор случайных чисел Python numpy
 Python numpy случайная экспонента 
 Здесь мы можем увидеть, как генерировать экспоненциальные случайные выборки в Python.
 В Python экспоненциальное распределение может получить образец и вернуть массив numpy.
 Функция плотности вероятности -
  f (x; 1 / β) = 1 / βexp (-x / β)  
  Примечание:  x> 0 и β - это параметр, который является обратным параметру скорости λ = 1 / β
 Синтаксис:
 Вот синтаксис numpy random  exponential 
  random.exponential (
                   масштаб = 1.0,
                   size = None
                  )  
 Пример:
 Здесь мы сгенерируем случайную выборку экспоненциального распределения, используя метод  random exponential () 
  импортировать numpy как np

new_plot = np.случайная экспонента (23)
print (new_plot)  
  Выход: 
Случайный экспоненциальный метод Python numpy
 Python numpy random.randomstate 
 Здесь мы увидим, как получить доступ к методу randomstate в модуле numpy random.
 В Python randomstate предоставляет начальное число для генератора случайных чисел и используется для алгоритма наследования засева и в настоящее время сбрасывает состояние  MT19937  с использованием метода  randomstate (). 
  Синтаксис: 
 Вот синтаксис следующего кода
  кол-во.random.randomstate (
                         seed = Нет
                        )  
 В этой функции параметр начального числа инициализирует генератор псевдо-чисел и может быть целым числом.
 Пример:
  импортировать numpy как np

new_plot = np.random.RandomState (4)
печать (новый_площадь)
  
 Вот реализация следующего данного кода
Python numpy randomstate
 Python numpy случайная перестановка 
 Давайте посмотрим, как использовать перестановку numpy в Python.Этот метод случайным образом генерирует последовательность и получает случайным образом переставленный диапазон в Python.
 Если x - это многомерный массив numpy, и он смешан с первым индексом.
  Синтаксис: 
 Вот синтаксис случайной перестановки numpy
  случайная перестановка (x)  
  Примечание:  Здесь x - целое число, оно произвольно переставляет и всегда возвращает диапазон массива случайной последовательности.
  Пример  нп.случайная перестановка
  импортировать numpy как np
 
new_output = np.random.permutation (6)
print (new_output)  
 Сначала в приведенном выше коде мы возьмем ввод x как  ‘6’.  После этого используйте функцию  random.permutation ()  и получите значения случайной последовательности.
 Вот выполнение следующего данного кода
Случайная перестановка Python numpy
 Python numpy random shuffle 
 Здесь мы можем увидеть, как использовать numpy random shuffle в Python.
 В Python перемешивание означает упорядочивание объектов, и этот метод поможет пользователю изменить положение элементов в массиве Numpy.
 В этом примере мы случайным образом перемешаем все значения в массиве.
  Синтаксис: 
 Вот синтаксис numpy random shuffle
  np.random.shuffle  
  Примечание:  Здесь X - это массив или модифицирующая последовательность, и он вернет перемешанный массив.
  Исходный код: 
 
импортировать numpy как np

новый_массив = np.апельсин (6)
np.random.shuffle (новый_массив)
печать (новый_массив)
  
 В этом примере мы использовали функцию numpy np.arange (). В Python метод np.arange () создает ndarray с разнесенными значениями в пределах интервала или заданного предела. После этого мы используем функцию случайного перемешивания и передаем переменную «new_array» в качестве аргумента и печатаем результат.
  Выход: 
Случайное перемешивание Python numpy
 Python numpy случайный бином 
 Давайте посмотрим, как использовать случайную биномиальную функцию в numpy Python.
 В Python биномиальные переменные представляют собой фиксированное количество испытаний и возвращают два результата. Случайные выборки берутся из распределения с заданными аргументами.
  Синтаксис: 
  np.random.binomial (
                   п,
                   п,
                   size = None
                  )  
 Состоит из нескольких параметров
  n:  нет трейлов и значение распределения больше 0
  p:  Этот параметр находится в диапазоне от > = 0 до <= 1 
  Размер :  По умолчанию значение равно none.
  Исходный код: 
  импортировать numpy как np
случайный импорт

arr = np.random.binomial (n = 8, p = 0,5, размер = 15)
печать (обр)
  
 Вот реализация следующего данного кода
Python numpy random binomial
 Вам могут понравиться следующие уроки Python:
 В этом руководстве по Python мы изучили примеры на  Python NumPy Random :
 Python NumPy случайное число
 Python генерирует случайное число с плавающей запятой
 Python NumPy random array
 Python NumPy random integer
 Python генерирует случайное число из массива
 Python NumPy случайный выбор
 Python NumPy 902 random randn
 Случайный образец NumPy
 Python NumPy random uniform
 Python NumPy random number в диапазоне
 Python NumPy random между двумя числами
 Python NumPy random между 0 и 1
 python NumPy random number между 1 и 10
 Python numpy random семя
 Python numpy random selection
 Python numpy random integer
 Python numpy random normal
 Python numpy random uniform
 Python numpy random sample
 Python numpy random randn
 Python numpy random number generator
 exponential nential генератор случайных чисел Python
 Python numpy.random.randomstate
 Python numpy random permutation
 Python numpy random shuffle
 Python numpy random binomial
 Случайная библиотека | Генерация случайных чисел в Python 
 Миром правит случай. Случайность преследует нас каждый день нашей жизни.
 - Пол Остер
 Случайные числа повсюду в мире науки о данных.Время от времени мне нужно быстро набрать несколько случайных чисел, чтобы запустить мысленный эксперимент или продемонстрировать концепцию аудитории, но без необходимости загружать большие наборы данных.
 От создания фиктивных данных до перетасовки данных для целей обучения и тестирования или инициализации весов нейронной сети - мы все время генерируем случайные числа в Python. Вам понравится эта концепция, когда вы освоите ее после этой статьи.
 На мой взгляд, генерация случайных чисел - тема, которую необходимо знать любому специалисту в области науки о данных.Здесь я проведу вас через весь процесс генерации случайных чисел в Python, а также продемонстрирую его с помощью различных методов.
  Впервые в Python? Эти два бесплатных курса помогут вам начать работу: 
 Содержание 
 Случайная библиотека
 Посадка случайных чисел
 Генерация случайных чисел в диапазоне
 Случайный выбор из списка
 Перемешивание списка
 Генерация случайных чисел в соответствии с распределениями
 Генерация случайных чисел в Python с использованием библиотеки случайных чисел 
 Хорошая новость - в Python есть разные способы генерации случайных чисел.Самый простой способ - использовать случайный модуль. Это встроенный модуль в Python, который не требует установки. Этот модуль использует генератор псевдослучайных чисел (PRNG), известный как Mersenne Twister, для генерации случайных чисел.
 Генератор псевдослучайных чисел - это детерминированный генератор случайных чисел. Он не генерирует действительно случайные числа. Он принимает число в качестве входных данных и генерирует для него случайное число.
   Примечание:  Не используйте модуль случайных чисел для генерации случайных чисел в целях безопасности.Для обеспечения безопасности и криптографии вы можете использовать модуль секретов, который использует генераторы истинных случайных чисел (TRNG). 
 Посадка случайных чисел 
 Как мы обсуждали в предыдущем разделе, модуль random принимает число в качестве входных данных и генерирует для него случайное число. Это начальное значение известно как начальное значение, а процедура известна как начальное значение.
 Числа, которые мы генерируем с помощью генераторов псевдослучайных чисел, детерминированы. Это означает, что они могут быть воспроизведены с использованием одного и того же семени.
 Давайте разберемся с этим на примере:
 случайный импорт

print ('Случайное число 1 =>', random.random ())
print ('Случайное число 2 =>', random.random ()) 
 Здесь я использую функцию random (), которая генерирует случайное число в диапазоне [0.0, 1.0]. Обратите внимание, что я не упомянул ценность семени. По умолчанию текущее системное время в миллисекундах используется в качестве начального числа. Давайте посмотрим на результат.
 Оба числа различаются из-за изменения времени во время выполнения от первого оператора ко второму.Давайте посмотрим, что произойдет, если мы заполним генераторы одинаковым значением:
.
 random.seed (42)
print ('Случайное число 1 =>', random.random ())

random.seed (42)
print ('Случайное число 2 =>', random.random ()) 
 Здесь такие же числа. Вот почему генераторы псевдослучайных чисел являются детерминированными и не используются в целях безопасности, потому что любой, у кого есть начальное число, может сгенерировать такое же случайное число.
 Генерация случайных чисел в диапазоне 
 На данный момент мы знаем о создании случайных чисел в диапазоне [0.0, 1.0]. Но что, если нам нужно создать число в другом диапазоне, кроме этого?
 Один из способов - умножить и добавить числа к числу, возвращаемому функцией  random () . Например, random.random () * 3 + 2 вернет числа в диапазоне [2.0, 5.0]. Однако это скорее обходной путь, а не прямое решение.
 Не волнуйтесь! Случайный модуль вернет вас сюда. Он предоставляет функции  uniform ()  и  randint () , которые мы можем использовать для этой цели.Давайте разберемся с ними по порядку.
 униформа () 
 Функция uniform () модуля random принимает начальное и конечное значения диапазона в качестве аргументов и возвращает случайное число с плавающей запятой в диапазоне [начало, конец]:
 print ('Случайное число в диапазоне (2,8) =>', random.uniform (2,8)) 
 рандинт () 
 Эта функция аналогична функции uniform (). Единственное отличие состоит в том, что функция uniform () возвращает случайные числа с плавающей запятой, а функция randint () возвращает целое число.Он также возвращает число в диапазоне [начало, конец]:
.
 print ('Случайное число в диапазоне (2,8) =>', random.randint (2,8)) 
 Случайный выбор из списка 
  choice ()  и  choices ()  - это две функции, предоставляемые модулем random, которые мы можем использовать для случайного выбора значений из списка. Обе эти функции принимают список в качестве аргумента и случайным образом выбирают из него значения. Сможете угадать, в чем разница между  choice ()  и  choices () ?
  choice ()  выбирает только одно значение из списка, тогда как  choices ()  выбирает несколько значений из списка  с заменой .Одна из замечательных особенностей этих функций заключается в том, что они также работают со списком, содержащим строки. Давайте посмотрим на них в действии:
 a = [5, 9, 20, 10, 2, 8]
print ('Случайно выбранное число =>', random.choice (a))
print ('Случайно выбранное число =>', random.choices (a, k = 3)) 
 Как видите,  choice ()  вернул одно значение из , а  и  choices (),  вернул три значения из  в . Здесь  k  - длина списка, возвращаемого функцией  choices () .
 Еще одна вещь, которую вы можете заметить в ответах, возвращаемых функцией  choices () , - это то, что каждое значение встречается только один раз. Вы можете увеличить вероятность выбора каждого значения, передав массив в виде  весов  в функцию  choices () . Итак, давайте увеличим вероятность с 10 до трех других и посмотрим на результат:
 для _ в диапазоне (5):
   print ('Случайно выбранное число =>', random.choices (a, weights = [1,1,1,3,1,1], k = 3)) 
 Здесь мы видим, что в каждом розыгрыше из списка выпало 10.Также существует функция  sample ()  в модуле random, которая работает аналогично функции  choices () , но берет случайные выборки из списка  без замены .
 Перемешивание списка 
 Допустим, мы не хотим выбирать значения из списка, а вы просто хотите изменить их порядок. Мы можем сделать это с помощью функции  shuffle ()  из модуля random. Эта функция  shuffle ()  принимает список в качестве аргумента и перемешивает список на месте:
 print ('Исходный список =>', a)
случайный.перемешать (а)
print ('Перемешанный список =>', a) 
  Примечание. Функция shuffle () не возвращает список. 
 Генерация случайных чисел в соответствии с распределениями 
 Еще одна удивительная особенность модуля random заключается в том, что он позволяет нам генерировать случайные числа на основе различных распределений вероятностей. Существуют различные функции, такие как  gauss () ,  expovariate ()  и т. Д., Которые помогают нам в этом.
 Если вы не знакомы с распределениями вероятностей, я настоятельно рекомендую вам прочитать эту статью: 6 распространенных распределений вероятностей, которые должен знать каждый специалист в области науки о данных.
 гаусс () 
 Начнем с наиболее распространенного распределения вероятностей, т. Е. Нормального распределения.  gauss ()  - это функция случайного модуля, используемого для генерации случайных чисел в соответствии с нормальным распределением. В качестве аргумента он принимает среднее значение и стандартное отклонение и возвращает случайное число:
.
 для _ в диапазоне (5):
   печать (random.gauss (0,1)) 
 Здесь я построил график 1000 случайных чисел, сгенерированных функцией  gauss ()  для среднего, равного 0, и стандартного отклонения, равного 1.Вы можете видеть выше, что все точки разбросаны вокруг среднего, и они не имеют большого разброса, так как стандартное отклонение составляет 1.
 экспоненциальный () 
 Экспоненциальное распределение - еще одно очень распространенное распределение вероятностей, с которым вы столкнетесь. Функция  expovariate ()  используется для получения случайного числа в соответствии с экспоненциальным распределением. Он принимает значение лямбда в качестве аргумента и возвращает значение от 0 до положительной бесконечности, если лямбда положительная, и от отрицательной бесконечности до 0, если лямбда отрицательная:
 print ('Случайное число из экспоненциального распределения =>', random.экспоненциальная (10)) 
 Конечные ноты 
 Я часто использую случайные числа для создания фиктивных наборов данных и для случайной выборки. Мне бы хотелось узнать, как вы используете случайные числа в своих проектах, поэтому оставьте комментарии ниже и поделитесь ими с сообществом.
 Если вы нашли эту статью информативной, поделитесь ею с друзьями и прокомментируйте ниже свои запросы и отзывы. Я перечислил несколько замечательных статей, связанных с Python и наукой о данных, ниже для вашей справки:
 Связанные 
 Python Генерация случайных чисел 
Python предоставляет модуль для генерации случайных чисел.Имя этого модуля -  random . В модуле random есть набор различных функций, которые используются для создания случайных чисел. Иногда может возникнуть необходимость в генерации случайных чисел; например, при проведении имитационных экспериментов, в играх и многих других приложениях. В этой статье объясняется генерация случайных чисел в Python с использованием различных функций модуля random.
 Функции генерации случайных чисел 
 Модуль random в Python предоставляет множество функций для управления и создания случайных чисел.
 Ниже перечислены некоторые общие функции модуля случайных чисел, используемых для генерации и обработки случайных чисел: e »
 Функция
 Описание
 рандинт (а, б)
 Создает и возвращает случайное число в указанном диапазоне.
 Термин «a, b» означает диапазон. Например, если мы напишем randint (1,7), то эта функция вернет случайное числовое значение от 1 до 17.
 выбор ()
 Выбирает и возвращает элемент из заданных чисел.
 Числа могут находиться в контейнере, то есть в списке.
 случайный ()
 Используется для генерации случайного числа с плавающей запятой.
 Возвращает случайное число с плавающей запятой от 0 до 1.
 рандрейндж ()
 Используется для генерации случайного числа между заданной последовательностью.
 Принимает начальное значение, конечное значение и число, которое вы хотите исключить из своего выбора.
 в случайном порядке ()
 Принимает контейнер или список в качестве аргумента и изменяет последовательность элементов.
 униформа ()
 Возвращает случайное число с плавающей запятой в заданном диапазоне.
 Это наиболее распространенные функции, используемые для генерации случайных чисел в Python.
 Теперь давайте посмотрим на несколько примеров этих функций.
 Функция randint (a, b) 
 Ниже приведен пример функции randint (a, b). В этом примере мы указываем диапазон до (1,20) и генерируем случайное число. Программа будет запускаться несколько раз, чтобы мы могли получить разные случайные числа в заданном диапазоне.
 # импорт случайного модуля 
 import random 
 # печать случайного числа от 1 до 20 
 print ("Случайное число:", random.randint (1,20))
  Выход 
 Вывод отображается в консоли Python. В выходных данных вы можете видеть, что случайные числа были сгенерированы от 1 до 20.
 Если мы изменим диапазон функции randint () на (1,10), то будет сгенерировано случайное число в диапазоне от 1 до 10.Программа будет запускаться несколько раз, чтобы мы могли получить разные случайные числа в заданном диапазоне.
 # импорт случайного модуля 
 import random 
 # печать случайного числа от 1 до 10 
 print («Случайное число:», random.randint (1,10))
  Выход 
 Вывод отображается в консоли Python. В выходных данных вы можете видеть, что случайные числа были сгенерированы от 1 до 10.
 Выбор () Функция 
 Как обсуждалось ранее, функция choice () выбирает и возвращает элемент из заданных чисел.Цифры могут быть в контейнере, то есть в списке. Давайте посмотрим на пример списка.
# импорт случайного модуля 
 import random 
 # определение списка чисел 
 list = [1,2,3,4,44,5,65,99,10,100]
 # печать случайного выбора 
 print (random.choice ( список))
  Выход 
 Вывод отображается в консоли Python. Программа выполняется несколько раз, поэтому мы можем получить различные случайные варианты выбора из данного списка.
 Точно так же мы можем определить список строк и сделать случайный выбор с помощью функции choice ().
# импорт случайного модуля 
 import random 
 # определение списка слов 
 list = ["Hello", "Welcome", "to", "the", "linuxhint"]
 # печать случайного выбора 
 print (random. выбор (список))
  Выход 
 Вывод отображается в консоли Python. Программа выполняется несколько раз, поэтому мы можем получить различные случайные варианты выбора из данного списка.
 Функция random () 
 Функция random используется для генерации случайного числа с плавающей запятой от 0 до 1.
 # импорт модуля random 
 import random 
 # печать случайного числа с плавающей запятой от 0 до 1. 
 print (random.random ())
  Выход 
 Вывод отображается в консоли Python. Программа выполняется несколько раз, поэтому мы можем получить различные случайные варианты выбора из данного списка.
 Если мы хотим взять сумму одного случайного числа от 1 до 10 и одного числа с плавающей запятой, то мы можем сделать это таким образом.
 # импорт модуля random 
 import random 
 # объявление переменной num1 и сохранение случайного числа от 1 до 10 
 num1 = random.randint (1,10) 
 # объявление переменной num2 и сохранение случайного числа с плавающей запятой от 0 до 1 
 num2 = random.random () 
 # вывод суммы num1 и num 2 
 print ("Сумма:", num1 + num2)
  Выход 
 Вывод отображается в консоли Python. Скорее всего, каждый раз генерируются новые случайные числа.Поэтому программа выполняется несколько раз, чтобы получить разные значения суммы.
 Функция randrange () 
 Как обсуждалось ранее, функция randrange () используется для генерации случайного числа в заданной последовательности. Он принимает начальное значение, конечное значение и число, которое вы хотите исключить из своего выбора.
 # импорт случайного модуля 
 import random 
 # печать случайного числа от 1 до 10 и исключение числа 2 
 print (random.рандом (1,10,2))
  Выход 
 Вывод отображается в консоли Python. Программа выполняется несколько раз.
 Функция shuffle () 
 Функция shuffle () принимает контейнер или список в качестве аргумента и изменяет последовательность элементов.
 # импорт случайного модуля 
 import random 
 # определение списка чисел 
 list = [1,2,3,4,44,5,65,99,10,100] 
 # печать исходного списка 
 print ("Исходный list is \ n ", list) 
 # перемешивание списка путем вызова функции shuffle () 
 random.shuffle (list) 
 # печать перемешанного списка 
 print ("Перемешанный список \ n", list)
  Выход 
 Вывод отображается в консоли Python.
 Точно так же мы можем перемешать список слов с помощью функции shuffle ().
 # импорт случайного модуля 
 import random 
 # определение списка слов 
 list = ["Hello", "Welcome", "to", "the", "linuxhint"] 
 # печать исходного списка 
 print (" Исходный список \ n ", list) 
 # перемешивание списка вызовом функции shuffle () 
 random.shuffle (list) 
 # печать перемешанного списка 
 print ("Перемешанный список \ n", list)
  Выход 
 Вывод отображается в консоли Python.
 Функция uniform () 
 Функция uniform () возвращает случайное число с плавающей запятой в заданном диапазоне.
 # импорт случайного модуля 
 import random 
 # печать случайного числа с плавающей запятой от 1 до 10 
 print (random.uniform (1,10))
  Выход 
 Вывод отображается в консоли Python.Программа выполняется несколько раз для генерации нескольких чисел с плавающей запятой от 1 до 10.
Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
Комментарий *
Имя * 
Email * 
Сайт