Bookkeeping functions¶
 random.seed(a=None, version=2)¶

Initialize the random number generator.
If a is omitted or
None
, the current system time is used. If randomness sources are provided by the operating system, they are used instead of the system time (see the
os.urandom()
function for details on availability).If a is an int, it is used directly.
With version 2 (the default), a
str
,
bytes
, or
bytearray
object gets converted to an
int
and all of its bits are used.With version 1 (provided for reproducing random sequences from older versions of Python), the algorithm for
str
and
bytes
generates a narrower range of seeds.Changed in version 3.2: Moved to the version 2 scheme which uses all of the bits in a string seed.
 random.getstate()¶

Return an object capturing the current internal state of the generator. This object can be passed to
setstate()
to restore the state.
 random.setstate(state)¶

state should have been obtained from a previous call to
getstate()
, and
setstate()
restores the internal state of the generator to what it was at the time
getstate()
was called.
Create a multidimensional array of random integers
Python’s NumPy module has a
numpy.random
package to generate random data. To create a random multidimensional array of integers within a given range, we can use the following NumPy methods:

randint()

random_integers()

np.randint(low[, high, size, dtype])
to get random integers array from low (inclusive) to high (exclusive). 
np.random_integers(low[, high, size])
to get random integer’s array between low and high, inclusive.
Now, Let see the example.
Generate a 4 x 4 array of ints between 10 and 50, exclusive:
import numpy # 4 x 4 array newArray = numpy.random.randint(10, 50, size=(4, 4)) print(newArray)
Output:
[[10 48 30 24] [13 46 30 11] [12 28 49 26] [30 18 49 35]]
Generate a 5 x 3 array of random integers between 60 and 100, inclusive.
import numpy # 3 x 5 array of ints newArray = numpy.random.random_integers(60, 100, size=(3, 5)) print(newArray)
Output:
[[63 76 95 93 75] [71 84 63 99 93] [65 64 66 69 92]]
Python3

Output :
Traceback (most recent call last):
File “/home/f813370b9ea61dd5d55d7dadc8ed5171.py”, line 6, in
r1=random.randint(1.23, 9.34)
File “/usr/lib/python3.5/random.py”, line 218, in randint
return self.randrange(a, b+1)
File “/usr/lib/python3.5/random.py”, line 182, in randrange
raise ValueError(“noninteger arg 1 for randrange()”)
ValueError: noninteger arg 1 for randrange()
Program to Demonstrate the TypeError
In this example, we can see that if we pass string or character literals as parameters in the randint() function then a TypeError occurs.
Parameter Values
Parameter  Description 
start  Required. An integer specifying at which position to start. 
stop  Required. An integer specifying at which position to end. 
random — Generate pseudorandom numbers¶
Source code: Lib/random.py
This module implements pseudorandom number generators for various distributions.
For integers, there is uniform selection from a range. For sequences, there is uniform selection of a random element, a function to generate a random permutation of a list inplace, and a function for random sampling without replacement.
On the real line, there are functions to compute uniform, normal (Gaussian), lognormal, negative exponential, gamma, and beta distributions. For generating distributions of angles, the von Mises distribution is available.
Almost all module functions depend on the basic function
random()
, which
generates a random float uniformly in the halfopen range
0.0 <= X < 1.0
.
Python uses the Mersenne Twister as the core generator. It produces 53bit precision
floats and has a period of 2**199371. The underlying implementation in C is
both fast and threadsafe. The Mersenne Twister is one of the most extensively
tested random number generators in existence. However, being completely
deterministic, it is not suitable for all purposes, and is completely unsuitable
for cryptographic purposes.
The functions supplied by this module are actually bound methods of a hidden
instance of the
random.Random
class. You can instantiate your own
instances of
Random
to get generators that don’t share state.
Class
Random
can also be subclassed if you want to use a different
basic generator of your own devising: see the documentation on that class for
more details.
The
random
module also provides the
SystemRandom
class which
uses the system function
os.urandom()
to generate random numbers
from sources provided by the operating system.
Warning
The pseudorandom generators of this module should not be used for
security purposes. For security or cryptographic uses, see the
secrets
module.
See also
M. Matsumoto and T. Nishimura, “Mersenne Twister: A 623dimensionally equidistributed uniform pseudorandom number generator”, ACM Transactions on Modeling and Computer Simulation Vol. 8, No. 1, January pp.3–30 1998.
ComplementaryMultiplywithCarry recipe for a compatible alternative random number generator with a long period and comparatively simple update operations.
Alternative Generator¶
 class random.Random([seed])¶

Class that implements the default pseudorandom number generator used by the
random
module.Changed in version 3.11: Formerly the seed could be any hashable object. Now it is limited to:
None
,
int
,
float
,
str
,
bytes
, or
bytearray
.Subclasses of
Random
should override the following methods if they wish to make use of a different basic generator: seed(a=None, version=2)¶

Override this method in subclasses to customise the
seed()
behaviour of
Random
instances.
 getstate()¶

Override this method in subclasses to customise the
getstate()
behaviour of
Random
instances.
 setstate(state)¶

Override this method in subclasses to customise the
setstate()
behaviour of
Random
instances.
 random()¶

Override this method in subclasses to customise the
random()
behaviour of
Random
instances.
Optionally, a custom generator subclass can also supply the following method:
 getrandbits(k)¶

Override this method in subclasses to customise the
getrandbits()
behaviour of
Random
instances.
 class random.SystemRandom([seed])¶

Class that uses the
os.urandom()
function for generating random numbers from sources provided by the operating system. Not available on all systems. Does not rely on software state, and sequences are not reproducible. Accordingly, the
seed()
method has no effect and is ignored. The
getstate()
and
setstate()
methods raise
NotImplementedError
if called.
Generate a list of random integer numbers
In this section, we will see how to generate multiple random numbers. Sometimes we need a sample list to perform testing. In this case, instead of creating it manually, we can create a list with random integers using a
randint()
or
randrange()
. In this example, we will see how to create a list of 10 random integers.
import random random_list = [] # Set a length of the list to 10 for i in range(0, 10): # any random numbers from 0 to 1000 random_list.append(random.randint(0, 1000)) print(random_list) # Output [994, 287, 65, 994, 936, 462, 839, 160, 689, 624]
Create a list of random numbers without duplicates
Note: In the above example, there is a chance of occurring a duplicate number in a list.
If you want to make sure each number in the list is unique, use the random.sample() method to generate a list of unique random numbers.

The
sample()
returns a sampled list of selected random numbers within a range of values.  It never repeats the element so that we can get a list of random numbers without duplicates
import random # Generate 10 unique random numbers within a range num_list = random.sample(range(0, 1000), 10) print(num_list) # Output [499, 580, 735, 784, 574, 511, 704, 637, 472, 211]
Note: You can also use the step parameter of the range() function to specify the increment. For example, you want a list of 10 random numbers, but each integer in a list must be divisible by 5, then use
random.sample(range(0, 1000, 5), 10)
Sort random numbers list
Use the
sort()
function to sort a list of random integers in ascending order
import random sample_list = random.sample(range(50, 500, 5), 5) # Before sorting print(sample_list) # Output [305, 240, 260, 235, 445] sample_list.sort() # After sorting print(sample_list) # Output [235, 240, 260, 305, 445]
Python3

Output :
Traceback (most recent call last):
File “/home/fb805b21fea0e29c6a65f62b99998953.py”, line 5, in
r2=random.randint(‘a’, ‘z’)
File “/usr/lib/python3.5/random.py”, line 218, in randint
return self.randrange(a, b+1)
TypeError: Can’t convert ‘int’ object to str implicitly
Applications : The randint() function can be used to simulate a lucky draw situation. Let’s say User has participated in a lucky draw competition. The user gets three chances to guess the number between 1 and 10. If guess is correct user wins, else loses the competition.
Realvalued distributions¶
The following functions generate specific realvalued distributions. Function parameters are named after the corresponding variables in the distribution’s equation, as used in common mathematical practice; most of these equations can be found in any statistics text.
 random.random()¶

Return the next random floating point number in the range
0.0 <= X < 1.0
 random.uniform(a, b)¶

Return a random floating point number N such that
a <= N <= b
for
a <= b
and
b <= N <= a
for
b < a
.The endpoint value
may or may not be included in the range depending on floatingpoint rounding in the equation
a + (ba) * random()
.
 random.triangular(low, high, mode)¶

Return a random floating point number N such that
low <= N <= high
and with the specified mode between those bounds. The low and high bounds default to zero and one. The mode argument defaults to the midpoint between the bounds, giving a symmetric distribution.
 random.betavariate(alpha, beta)¶

Beta distribution. Conditions on the parameters are
alpha > 0
and
beta > 0
. Returned values range between 0 and 1.
 random.expovariate(lambd=1.0)¶

Exponential distribution. lambd is 1.0 divided by the desired mean. It should be nonzero. (The parameter would be called “lambda”, but that is a reserved word in Python.) Returned values range from 0 to positive infinity if lambd is positive, and from negative infinity to 0 if lambd is negative.
Changed in version 3.12: Added the default value for
lambd
.
 random.gammavariate(alpha, beta)¶

Gamma distribution. (Not the gamma function!) The shape and scale parameters, alpha and beta, must have positive values. (Calling conventions vary and some sources define ‘beta’ as the inverse of the scale).
The probability distribution function is:
x ** (alpha – 1) * math.exp(x / beta) pdf(x) = ————————————– math.gamma(alpha) * beta ** alpha
 random.gauss(mu=0.0, sigma=1.0)¶

Normal distribution, also called the Gaussian distribution. mu is the mean, and sigma is the standard deviation. This is slightly faster than the
normalvariate()
function defined below.Multithreading note: When two threads call this function simultaneously, it is possible that they will receive the same return value. This can be avoided in three ways. 1) Have each thread use a different instance of the random number generator. 2) Put locks around all calls. 3) Use the slower, but threadsafe
normalvariate()
function instead.Changed in version 3.11: mu and sigma now have default arguments.
 random.lognormvariate(mu, sigma)¶

Log normal distribution. If you take the natural logarithm of this distribution, you’ll get a normal distribution with mean mu and standard deviation sigma. mu can have any value, and sigma must be greater than zero.
 random.normalvariate(mu=0.0, sigma=1.0)¶

Normal distribution. mu is the mean, and sigma is the standard deviation.
Changed in version 3.11: mu and sigma now have default arguments.
 random.vonmisesvariate(mu, kappa)¶

mu is the mean angle, expressed in radians between 0 and 2*pi, and kappa is the concentration parameter, which must be greater than or equal to zero. If kappa is equal to zero, this distribution reduces to a uniform random angle over the range 0 to 2*pi.
 random.paretovariate(alpha)¶

Pareto distribution. alpha is the shape parameter.
 random.weibullvariate(alpha, beta)¶

Weibull distribution. alpha is the scale parameter and beta is the shape parameter.
Points to remember about randint() and randrange()

Use
randint()
when you want to generate a random number from an inclusive range. 
Use
randrange()
when you want to generate a random number within a range by specifying the increment. It produces a random number from an exclusive range.
You should be aware of some value constraints of a
randrange()
function.

The
randint(
) rand
randrange()
works only with integers. You cannot use float numbers. 
The step must not be 0. If it is set to 0, you will get a
ValueError: zero step for randrange()
 The start should not be greater than stop if you are using all positive numbers. If you set start greater than stop, you will get a ValueError: empty range for randrange()
Examples
import random # ValueError: empty range for randrange() print(random.randrange(100, 10, 2))
But, you can also set a start value greater than stop if you are using a negative step value.
import random print(random.randrange(100, 10, 2)) # output 60
Examples¶
Basic examples:
>>> random() # Random float: 0.0 <= x < 1.0 0.37444887175646646 >>> uniform(2.5, 10.0) # Random float: 2.5 <= x <= 10.0 3.1800146073117523 >>> expovariate(1 / 5) # Interval between arrivals averaging 5 seconds 5.148957571865031 >>> randrange(10) # Integer from 0 to 9 inclusive 7 >>> randrange(0, 101, 2) # Even integer from 0 to 100 inclusive 26 >>> choice([‘win’, ‘lose’, ‘draw’]) # Single random element from a sequence ‘draw’ >>> deck = ‘ace two three four’.split() >>> shuffle(deck) # Shuffle a list >>> deck [‘four’, ‘two’, ‘ace’, ‘three’] >>> sample([10, 20, 30, 40, 50], k=4) # Four samples without replacement [40, 10, 50, 30]
Simulations:
>>> # Six roulette wheel spins (weighted sampling with replacement) >>> choices([‘red’, ‘black’, ‘green’], [18, 18, 2], k=6) [‘red’, ‘green’, ‘black’, ‘black’, ‘red’, ‘black’] >>> # Deal 20 cards without replacement from a deck >>> # of 52 playing cards, and determine the proportion of cards >>> # with a tenvalue: ten, jack, queen, or king. >>> deal = sample([‘tens’, ‘low cards’], counts=[16, 36], k=20) >>> deal.count(‘tens’) / 20 0.15 >>> # Estimate the probability of getting 5 or more heads from 7 spins >>> # of a biased coin that settles on heads 60% of the time. >>> sum(binomialvariate(n=7, p=0.6) >= 5 for i in range(10_000)) / 10_000 0.4169 >>> # Probability of the median of 5 samples being in middle two quartiles >>> def trial(): … return 2_500 <= sorted(choices(range(10_000), k=5))[2] < 7_500 … >>> sum(trial() for i in range(10_000)) / 10_000 0.7958
Example of statistical bootstrapping using resampling with replacement to estimate a confidence interval for the mean of a sample:
# https://www.thoughtco.com/exampleofbootstrapping3126155 from statistics import fmean as mean from random import choices data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95] means = sorted(mean(choices(data, k=len(data))) for i in range(100)) print(f’The sample mean of {mean(data):.1f} has a 90% confidence ‘ f’interval from {means[5]:.1f} to {means[94]:.1f}’)
Example of a resampling permutation test to determine the statistical significance or pvalue of an observed difference between the effects of a drug versus a placebo:
# Example from “Statistics is Easy” by Dennis Shasha and Manda Wilson from statistics import fmean as mean from random import shuffle drug = [54, 73, 53, 70, 73, 68, 52, 65, 65] placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46] observed_diff = mean(drug) – mean(placebo) n = 10_000 count = 0 combined = drug + placebo for i in range(n): shuffle(combined) new_diff = mean(combined[:len(drug)]) – mean(combined[len(drug):]) count += (new_diff >= observed_diff) print(f'{n} label reshufflings produced only {count} instances with a difference’) print(f’at least as extreme as the observed difference of {observed_diff:.1f}.’) print(f’The onesided pvalue of {count / n:.4f} leads us to reject the null’) print(f’hypothesis that there is no difference between the drug and the placebo.’)
Simulation of arrival times and service deliveries for a multiserver queue:
from heapq import heapify, heapreplace from random import expovariate, gauss from statistics import mean, quantiles average_arrival_interval = 5.6 average_service_time = 15.0 stdev_service_time = 3.5 num_servers = 3 waits = [] arrival_time = 0.0 servers = [0.0] * num_servers # time when each server becomes available heapify(servers) for i in range(1_000_000): arrival_time += expovariate(1.0 / average_arrival_interval) next_server_available = servers[0] wait = max(0.0, next_server_available – arrival_time) waits.append(wait) service_duration = max(0.0, gauss(average_service_time, stdev_service_time)) service_completed = arrival_time + wait + service_duration heapreplace(servers, service_completed) print(f’Mean wait: {mean(waits):.1f} Max wait: {max(waits):.1f}’) print(‘Quartiles:’, [round(q, 1) for q in quantiles(waits)])
See also
Statistics for Hackers a video tutorial by Jake Vanderplas on statistical analysis using just a few fundamental concepts including simulation, sampling, shuffling, and crossvalidation.
Economics Simulation a simulation of a marketplace by Peter Norvig that shows effective use of many of the tools and distributions provided by this module (gauss, uniform, sample, betavariate, choice, triangular, and randrange).
A Concrete Introduction to Probability (using Python) a tutorial by Peter Norvig covering the basics of probability theory, how to write simulations, and how to perform data analysis using Python.
How to use random.randint()
Syntax:
random.randint(start, stop)
This function returns a random integer between a given start and stop integer.
Parameters:
It takes two parameters. Both are mandatory.

start
: It is the start position of a range. The default value is 0 if not specified. 
stop
: It is the end position of a range.
Return value:
It will generate any random integer number from the inclusive range. The
randint(start, stop)
consider both the start and stop numbers while generating random integers
How to use Python
randint()
and
randrange()
to get random integers

Import random module
Use Python’s random module to work with random data generation.
import it using a
import random
statement. 
Use randint() Generate random integer
Use a
random.randint()
function to get a random integer number from the inclusive range. For example,
random.randint(0, 10)
will return a random number from [0, 1, 2, 3, 4, 5, 6, 7, 8 ,9, 10]. 
Use the randrnage() function to generate a random integer within a range
Use a
random.randrange()
function to get a random integer number from the given exclusive range by specifying the increment. For example,
random.randrange(0, 10, 2)
will return any random number between 0 and 20 (like 0, 2, 4, 6, 8).
random.randint() example of generating random number
import random # random integer from 0 to 9 num1 = random.randint(0, 9) print(num1) # output 5 # Random integer from 10 to 100 num2 = random.randint(10, 100) print(num2) # Output 84
Note: You cannot use float numbers in
randint()
. It will raise a ValueError (
noninteger stop for randrange()
) if you use noninteger numbers. Please, read how to generate a random float number within a range.
Nguồn tham khảo
All rights reserved
Python is one of the programming languages and it defines a set of functions whose use takes place for the generation or manipulation of random numbers via the random module in python. Furthermore, the reliance of the functions in the random module is on a pseudorandom number generator function random(). Moreover, randint() refers to an inbuilt function belonging to the random module that is in Python3.
Random Module in Python
random() Function in Python
random(), simply speaking, is an inbuilt function of the random module in Python3 and it helps in the derivation of the python random list. Furthermore, the random module in Python provides access to some useful functions and one of them is able to facilitate the generation of random floating numbers, which is random(). Also, its syntax is random. random() python.
Syntax: random.random()
Parameters: Any parameter is not accepted by this method.
Returns: Random floating number between 0 and 1 is returned by this method.
First of all, example #1: Simple implementation of sample() function
# Python3 program to demonstrate # the use of random() function . # import random from random import random # Prints random item Moreover, print(random())
Furthermore, output:
0.41941790721207284
Moreover, Example 2:
# Python3 program to demonstrate # the use of random() function . # import random Also, from random import random lst = [] for i in range(10): lst.append(random()) # Prints random items Furthermore, print(lst)
Finally, Output:
[0.12144204979175777, 0.27614050014306335, 0.8217122381411321, 0.34259785168486445, 0.6119383347065234, 0.8527573184278889, 0.9741465121560601, 0.21663626227016142, 0.9381166706029976, 0.2785298315133211]
Browse more Topics Under Functions
randint() Function in Python
randint() refers to an inbuilt function belonging to the random module in Python3. Furthermore, access is provided by random module provides access to some beneficial functions. Moreover, one of the functions is to generate random numbers, which is randint().
Syntax :
randint(start, end)
Parameters :
(start, end) : Both of them have to be integertype values.
Returns :
A random integer in the range [start, end] consisting of the endpoints.
Errors and Exceptions :
ValueError: Returns a ValueError when floatingpoint values are passed as parameters.
TypeError: TypeError is returned when anything other than
numeric values is passed as parameters.
Code #1 :
# Python3 program explaining work # of randint() function # imports random module import random # Generates a random number between # a given positive range r1 = random.randint(0, 10) Furthermore, another important point, print(“Random number between 0 and 10 is % s” % (r1)) # Generates a random number between # two given negative range r2 = random.randint(10, 1) Also, another important point, print(“Random number between 10 and 1 is % d” % (r2)) # Generates a random number between # a positive and a negative range r3 = random.randint(5, 5) Furthermore, another important point, print(“Random number existing between 5 and 5 is % d” % (r3))
So, output:
Random number between 0 and 10 is 5 Also, Random number between 10 and 1 is 7 Finally, Random number between 5 and 5 is 2
Furthermore, code #2 : Program demonstrating the ValueError.
# imports random module import random ”’If we pass floating point values as parameters in the randint() function”’ r1 = random.randint(1.23, 9.34) Moreover, print(r1)
So, output :
Traceback (most recent call last): File “/home/f813370b9ea61dd5d55d7dadc8ed5171.py”, line 6, in r1=random.randint(1.23, 9.34) File “/usr/lib/python3.5/random.py”, line 218, in randint return self.randrange(a, b+1) File “/usr/lib/python3.5/random.py”, line 182, in randrange raise ValueError(“noninteger arg 1 for randrange()”) ValueError: noninteger arg 1 for randrange()
FAQs on Using Random and Randint Functions
Question 1: Explain the working of randint in a simple manner?
Answer 1: randint(1,101) will facilitate the automatic selection of a random integer between 1 and 100 for you. Furthermore, the process is fairly simple. Moreover, a random number will be generated between 1 and 20 by this code, and that number will be multiplied by 5.
Question 2: What is meant by the random module in python?
Answer 2: The random module in python is a builtin module that leads to the generation of pseudorandom variables. Furthermore, its use can take place to perform some action randomly such as to randomly shuffle elements, selecting random elements from a list, getting a random number, etc.
True Random Number Generators
Các bộ tạo số ngẫu nhiên thực là các phương pháp trích rút tính ngẫu nhiên hoặc không thể tiên đoán từ các khía cạnh không thể đoán trước được của các tiến trình vật lý. Các phương thức này không trực tiếp tạo ra các số, mà là các trạng thái, sau đó có thể được diễn dịch sang dạng số – đây là lý do tại sao chúng thường được gọi là các trình tạo sự kiện ngẫu nhiên (Random Event Generators – REGs). Một số trong số chúng, sử dụng các sự kiện vĩ mô phổ biến, như là các phương pháp ném xúc xắc, lật đồng xu hoặc xáo trộn thẻ bài.
Những bộ tạo số ngẫu nhiên thực này thường sử dụng các hiện tượng vật lý phức tạp hơn. Một số trong số chúng, như phân rã phóng xạ, nhiễu nhiệt hoặc nhiễu vô tuyến, được trích xuất sự khó lường từ đặc thù của cơ học lượng tử. Các phương pháp khác sử dụng tính không thể đoán trước được của tiếng ồn trong khí quyển hoặc thậm chí là trạng thái của đèn đối lưu giọt dầu.
Python3

Output
Pick your number to enter the lucky draw
8
Wrong Guess!!
Pick your number to enter the lucky draw
9
Wrong Guess!!
Pick your number to enter the lucky draw
0
Congrats!! You Win.
Don’t miss your chance to ride the wave of the data revolution! Every industry is scaling new heights by tapping into the power of data. Sharpen your skills and become a part of the hottest trend in the 21st century.
Dive into the future of technology – explore the Complete Machine Learning and Data Science Program by GeeksforGeeks and stay ahead of the curve.
Last Updated :
30 Oct, 2023
Like Article
Save Article
Share your thoughts in the comments