Случайное число

main.cpp

А теперь применение

#include <QCoreApplication>

#include "Random.hpp"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    std::cout << "Random STD  - ";
    for (int i = 0; i < 15; ++i)
    {
        std::cout << Random::get(15, 43) << " ";
    }
    std::cout << std::endl;
    return a.exec();
}

Вывод

Random STD  - 38 29 36 38 21 32 33 39 31 15 33 16 36 38 35

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

Так что из ништяков C++11 можно выделить достаточно качественную генерацию псевдослучайных чисел.

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

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

Соответственно, чтобы избежать повторения последовательности чисел, генератор должен инициализироваться разными значениями при каждом запуске программы. Как раз для этих целей можно использовать seed. Стандартным способом инициализации ГПСЧ является передача ему в качестве seed значения time(0) из заголовочного файла ctime. То есть генератор будет инициализироваться значением, равным количеству секунд, прошедших с момента 1 января 00 часов 00 минут 00 секунд, 1970 года по UTC.

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

Доброго времени суток! Эта статья носит практический характер и в ней я расскажу о том, как использовать генератор случайных чисел в C# и для чего это Вам может пригодиться. Хотя, если на чистоту, то речь пойдет о генераторе псевдослучайных чисел…

Где нам могут понадобиться случайные числа, да на самом деле можно привести в пример много случаев, например, криптография, или механизмы разрешения различных коллизий. Поверьте, рано или поздно Вам с такой  необходимостью придется столкнуться, если уже не пришлось, раз читаете эту статью. К счастью, в C# генератор случайных чисел разработан до нас, и единственное что нам нужно будет, большинстве случаев, это просто правильно им пользоваться. И так, для генерации случайных чисел в программах, написанных на C#, предназначен класс «Random».

//Создание объекта для генерации чисел
Random rnd = new Random();

//Получить очередное (в данном случае - первое) случайное число
int value = rnd.Next();

//Вывод полученного числа в консоль
Console.WriteLine(value);

Как видите — ничего сложного! Сначала создаем объект типа «Random», потом вызываем его метод «Next», в результате чего и получаем случайное число. Если мы вызовем метод «Next» несколько раз, то получим разные числа. Такой код, даст нам четыре разных, случайных числа:

//Создание объекта для генерации чисел
Random rnd = new Random();
 
int value = rnd.Next();  //Получить очередное случайное число
int value1 = rnd.Next(); //Получить очередное случайное число
int value2 = rnd.Next(); //Получить очередное случайное число
int value3 = rnd.Next(); //Получить очередное случайное число
 
Console.WriteLine(value);  //Вывод числа в консоль
Console.WriteLine(value1); //Вывод числа в консоль
Console.WriteLine(value2); //Вывод числа в консоль
Console.WriteLine(value3); //Вывод числа в консоль

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

//Создание объекта для генерации чисел
Random rnd = new Random();

//Получить случайное число (в диапазоне от 0 до 10)
int value = rnd.Next(0, 10);

//Вывод числа в консоль
Console.WriteLine(value); 

Как видите, и это выполняется несложно! Для этого мы всего лишь вызвали метод «Next» с двумя параметрами, первый из которых обозначает нижнюю границу диапазона, а второй — верхнюю.

Но это ещё не всё, есть еще один важный нюанс, на самом деле генератор случайных чисел является генератором псевдослучайных чисел, т.е. числа, которые он возвращает, не являются чисто случайными, они «вырабатываются» по определенным и четким законам, а «случайность» зависит от инициализации объекта, который генерирует числа (объекта класса «Random»). В примерах, приведенных выше, мы использовали конструктор по умолчанию, и в таком случае (судя по всему), «начальное значение» задается системой, и на основании системного времени. Но мы может задавать это самое «начальное значение» и сами:

//Создание объекта для генерации чисел (с указанием начального значения)
Random rnd = new Random(245);

//Получить случайное число 
int value = rnd.Next();

Так вот если два (или более) разных объекта класса «Random» будут одинаково проинициализированы, то и возвращать они будут одни и те же числа, например, следующий код,  выведет в консоль три одинаковых числа:

class Program
{
    //Этот метод должен возвращать случайное значение
    static int GetRandom()
    {
        //Создание объекта для генерации чисел (с указанием начального значения)
        Random rnd = new Random(245);

        //Получить случайное число 
        int value = rnd.Next();

        //Вернуть полученное значение
        return value;
    }

    static void Main(string[] args)
    {        
        //Вывод сгенерированных чисел в консоль
        Console.WriteLine(GetRandom());
        Console.WriteLine(GetRandom());
        Console.WriteLine(GetRandom());
    }
}

Как видите, не смотря на то, что в при каждом вызове метода «GetRandom» создается новый объект для генерации случайных чисел, инициализируются эти объекты одним и тем же значением. Так что, будьте внимательны!

Равновероятные случайные числа

Функция генерирует любое случайное число от 0 до RAND_MAX с равной долей вероятности. Другими словами, у числа 100 есть такой же шанс выпасть, как и у числа 25876.

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

#include <stdio.h>
#include <time.h>
 
#define N 500
 
int main () {
    int i;
    int arr5 = {};
 
    srand(time(NULL));
 
    for (i=; i < N; i++)   
        switch (rand() % 5) {
            case  arr++; break;
            case 1 arr1++; break;
            case 2 arr2++; break;
            case 3 arr3++; break;
            case 4 arr4++; break;
    }
 
    for (i=; i < 5; i++) 
        printf("%d - %.2f%%\n", i, 
              ((float) arri  N) * 100);
}

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

Спишите данную программу. Посмотрите на результат ее выполнения при различных значениях N: 10, 50, 500, 5000, 50000. Объясните увиденное.

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

Традиционный алгоритм создания СЧ совмещал в себе одновременно алгоритм создания непредсказуемых битов и превращение их в последовательность чисел. В библиотеке random C++, являющаяся частью Boost, разделили эти два механизма. Теперь генерация случайных чисел и создание из них распределения (последовательности) происходит отдельно. Использование распределения является совершенно логичным. Потому что случайное число без определенного контекста не имеет смысла и его сложно использовать. Напишем простую функцию, которая бросает кость:

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

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

Время как источник случайности

Если вы запустите предыдущую программу несколько раз, вы обнаружите проблему: числа будут те же самые. Причина проста — в начале последовательности мы используем всегда одно и то же число, 18. Для последовательности это число является зерном (англ. seed), и чтобы последовательность менялась с каждым запуском, зерно должно быть случайным.

Простейший, но не самый лучший способ получения зерна: взять текущее календарное время в секундах. Для этой цели мы воспользуемся функцией std::time_t time(std::time_t* arg).

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

Почему в IT все числа неслучайные

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

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

Модуль random

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

Метод	Характеристика
random()	возвращает число в диапазоне от 0 до 1
seed(a)	настаивает генератор на новую последовательность a
randint(a, b)	возвращает целое число в диапазоне от a и b
randrange(a, b, c)	возвращает целое число в диапазоне от a до b с шагом c
uniform(a, b)	возвращает вещественное число в диапазоне от a и b
shuffle(a)	перемешивает значения в списке a
choice(a)	возвращает случайный элемент из списка a
sample(a, b)	возвращает последовательность длиной b из набора a
getstate()	возвращает внутреннее состояние генератора
setstate(a)	восстанавливает внутреннее состояние генератора a
getrandbits(a)	возвращает a случайно сгенерированных бит
triangular(a, b, c)	возвращает вещественное число от a до b с распределением c

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

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

std::random_device

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

Класс имеет методы min() и max(), а также entropy(), который возвращает любое ненулевое число в случае производства действительно СЧ, иначе вернет 0. Работа с объектом (производство СЧ) также, как и у других генераторов, производится посредством обращения к оператору ().

Пример: создание ГСЧ std::random_device

#include <random>  
#include <iostream>  
 int main() 
{ 
    std::random_device rd; 
    std::uniform_int_distribution<int> uid(, 50); 
    std::cout << uid(rd) << std::endl; 
} 

Иногда ГПСЧ инициализируют результатом действия ГСЧ (time(0) оказывается недостаточно).

Пример: инициализация ГПСЧ результатом работы ГСЧ

#include <random>  
#include <iostream>  
 int main() 
{ 
    std::random_device rd; 
    std::mt19937 gen(rd()); 
    std::uniform_int_distribution<int> uid(, 50); 
    std::cout << uid(gen) << std::endl; 
} 

std::mt19937 gen(std::random_device().operator()());

std::mt19937 gen { std::random_device()() }; 

Распределения

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

Все они принимают в качестве аргументов в конструкторе либо параметры другого распределения, либо переменные, отвечающие за диапазон значений. Если оные не указаны, то используется диапазон от 0 до максимального значения, определенного в numeric_limits<>::max() данного идентификатора типа, являющегося параметром шаблона.

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

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

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

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

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

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

Python

import random

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

AnnaScore = 0
AlexScore = 0

# У каждого кубика шесть возможных значений
diceOne =
diceTwo =

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

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

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

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

importrandom PlayerOne=»Анна» PlayerTwo=»Алекс» AnnaScore= AlexScore=   # У каждого кубика шесть возможных значений diceOne=1,2,3,4,5,6 diceTwo=1,2,3,4,5,6 defplayDiceGame() «»»Оба участника, Анна и Алекс, бросают кубик, используя метод shuffle»»» foriinrange(5) #оба кубика встряхиваются 5 раз random.shuffle(diceOne) random.shuffle(diceTwo) firstNumber=random.choice(diceOne)# использование метода choice для выбора случайного значения SecondNumber=random.choice(diceTwo) returnfirstNumber+SecondNumber print(«Игра в кости использует модуль random\n»)   #Давайте сыграем в кости три раза foriinrange(3) # определим, кто будет бросать кости первым AlexTossNumber=random.randint(1,100)# генерация случайного числа от 1 до 100, включая 100 AnnaTossNumber=random.randrange(1,101,1)# генерация случайного числа от 1 до 100, не включая 101 if(AlexTossNumber>AnnaTossNumber) print(«Алекс выиграл жеребьевку.») AlexScore=playDiceGame() AnnaScore=playDiceGame() else print(«Анна выиграла жеребьевку.») AnnaScore=playDiceGame() AlexScore=playDiceGame() if(AlexScore>AnnaScore) print(«Алекс выиграл игру в кости. Финальный счет Алекса:»,AlexScore,»Финальный счет Анны:»,AnnaScore,»\n») else print(«Анна выиграла игру в кости. Финальный счет Анны:»,AnnaScore,»Финальный счет Алекса:»,AlexScore,»\n»)

Вывод:

Shell

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

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

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

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

1 2 3 4 5 6 7 8 9 10

Игравкостииспользуетмодульrandom   Аннавыигралажеребьевку. Аннавыигралаигрувкости.ФинальныйсчетАнны5ФинальныйсчетАлекса2   Аннавыигралажеребьевку. Аннавыигралаигрувкости.ФинальныйсчетАнны10ФинальныйсчетАлекса2   Алексвыигралжеребьевку. Аннавыигралаигрувкости.ФинальныйсчетАнны10ФинальныйсчетАлекса8

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

Знакомство с новым ГПСЧ

Мы будем использовать генератор mersenne twister, а точнее mt19937. Основанный на свойствах простых чисел, он подходит для решения большинства задач. Несмотря на то, что степень его «случайности» весьма неплоха, он все-таки является ГПСЧ. Генерирует СЧ он достаточно быстро и хватить его должно с головой.

Определен он, как и все, что мы далее будем рассматривать, в хедере random и пространстве имен std. Является 32-битным генератором, имеет собрата mt19937_64, являющегося 64-битным.В конструкторе может инициализироваться величиной, от которой начинается генерация последовательности, либо специальным объектом seed_seq, являющимся зерном последовательности. Мы будем использовать первый вариант.

Пример: создание переменных std::mt19937

#include <random>  
#include <ctime>  
 int main() 
{ 
    std::mt19937 gen1, gen2(time());
} 

Пример: использование метода seed

#include <random>  
#include <ctime>  int main() 
{ 
    std::mt19937 gen; 
    gen.seed(time());
}

Пример: генерация СЧ и вывод на экран

#include <iostream>  
#include <random> 
#include <ctime>

int main() 
{ 
    std::mt19937 gen; 
    gen.seed(time()); // try to comment this string 
    std::cout << «My number: » << gen() << std::endl; 
}

Алгоритм произвольного выбора

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

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

 Реализации на Си
В результате получаем новый массив b, сформированный произвольной выборкой элементов массива a.

123456789101112131415161718192021222324252627282930313233

#include <stdio.h>#include <stdlib.h>#include <time.h>#define SIZE 20int main() {  int a;  int b; // результирующий массив  srand(time(NULL));  // Заполняем массив последовательными значениями от 1 до 20  for (int i = 0; i < SIZE; i++)  {    a = i + 1;    printf(«%2d «, a);  }  for (int i = 0; i < SIZE; i++)  {    int ind = rand() % 20; // выбираем произвольный индекс    while (a == -1) // пока элемент «выбран»    {      ind++;       // двигаемся вправо      ind %= 20;     // если дошли до правой границы, возвращаемся в начало     }    b = a;    // записываем следующий элемент массива b    a = -1;    // отмечаем элемент массива a как «выбранный»  }  printf(«\n»);  // Выводим получившийся массив  for (int i = 0; i < SIZE; i++)    printf(«%2d «, b);  getchar();  return 0;}

Алгоритмизация

Функции rand() и srand()

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

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

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

Функция возвращает целое число от 0 до значения присвоенного константе RAND_MAX. Значение RAND_MAX зависит от системы и определено в заголовочном файле stdlib.h. Так, например, оно может быть равно 32767 (двухбайтовое целое) или 2147483647 (четырехбайтовое целое).

Определите значение RAND_MAX в вашей системе. Для этого не забудьте подключить к файлу исходного кода заголовочный файл stdlib.h.

Код ниже выводит на экран 50 случайных чисел:

#include <stdio.h>
#include <stdlib.h>
 
int main () {
    char i;
 
    for (i = 1; i <= 50; i++) {
        printf("%15d", rand());
        if (i % 5 == ) printf("\n");
    }        
}

В теле цикла осуществляется переход на новую строку после каждых выведенных на экран пяти чисел. Для этого используется выражение, в котором находится остаток от деления i на 5, результат сравнивается с 0. Чтобы после первого числа не происходил переход на новую строку, iсначала присваивается единица, а не ноль (т.к. 0 делится на 5 без остатка).

Спишите код, приведенный выше

Выполните программу несколько раз, при этом обратите внимание, разные ли результаты вы получаете от выполнения к выполнению

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

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

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

Текущее время можно узнать с помощью функции , прототип которой описан в файле time.h. Передав в качестве параметра NULL, мы получим целое число, которое можно передать в :

srand(time(NULL));

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

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

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

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

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

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

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

Python

import random

1	importrandom

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

Python

import random

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

1 2 3 4 5

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

Вывод:

Shell

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

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

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

• является базовой функцией модуля ;
• Почти все функции модуля зависят от базовой функции ;
• возвращает следующее случайное число с плавающей запятой в промежутке .

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