From Random Import Randint | True Random Number Generators

Discrete distributions¶

The following function generates a discrete distribution.

random.binomialvariate(n=1, p=0.5)¶

Binomial distribution. Return the number of successes for n independent trials with the probability of success in each trial being p:

Mathematically equivalent to:

sum(random() < p for i in range(n))

The number of trials n should be a non-negative integer. The probability of success p should be between


0.0 <= p <= 1.0

. The result is an integer in the range

0 <= X <= n

.

New in version 3.12.

Real-World Applications of Python’s randint

Python’s

randint()

function isn’t just for academic exercises—it has practical applications in real-world scenarios. Let’s explore some of these applications.

Simulations

In simulations,

randint()

can be used to generate random inputs. For example, in a weather simulation,

randint()

could generate random temperatures or wind speeds.


import random random_temperature = random.randint(-10, 40) print('Random Temperature:', random_temperature, '°C') # Output: # Random Temperature: (A random number between -10 and 40) °C


In this code, we’re using

randint()

to generate a random temperature between -10 and 40 degrees Celsius.

Games

In games,

randint()

can be used to create unpredictable elements, making the game more exciting. For instance, in a dice game,

randint()

could be used to generate the dice roll.


import random dice_roll = random.randint(1, 6) print('Dice Roll:', dice_roll) # Output: # Dice Roll: (A random number between 1 and 6)


In this code, we’re using

randint()

to simulate a dice roll, generating a random number between 1 and 6.

Data Analysis

In data analysis,

randint()

can be used to generate random samples from a larger dataset. This can ensure a more representative sample and more accurate analysis.

random.randrange() to generate random integers within a range

Now let’s see how to use the

random.randrange()

function to get a random integer number from the given exclusive range by specifying the increment.

Syntax


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


This function returns a random integer from a

range(start, stop, step)

. For example,

random.randrange(0, 10, 2)

will generate any random numbers from [0, 2, 4, 6, 8].

Parameters

It takes three parameters. Out of three, two parameters are optional. i.e.,

start

and

step

are optional.

• 
start

  : it is the star number in a range. i.e., lower limit. The default value is 0 if not specified.
• 
stop

  : It is the end/last number in a range. It is the upper limit.
• 
step

  : Specify the increment value in range. The generated random number is divisible by step. The default value is 1 if not specified.

random.randrange() examples

In the following example, we are trying to print a random int in a given range. This example demonstrates all the variants of

random.randrange()

function.


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:

• The
  
randrange()

  doesn’t consider the stop number while generating a random integer. It is an exclusive random range. For example,
  
randrange(2, 20, 2)

  will return any random number between 2 to 20, such as 2, 4, 6, …18. It will never select 20.
• Same as
  
randint()

  , you cannot use float value in
  
randrange()

  too. It will raise a
  
ValueError

  (non-integer arg 1 for randrange()) if you use non-integers.

Random number of a specific length

Let’s see how to generate a random number of length n. For example, any random number of length four, such as 7523, 3674. We can accomplish this using both

randint()


randrange()

.


import random # random number of length 4 num1 = random.randint(1000, 9999) # random number of length 4 with step 2 num2 = random.randrange(1000, 10000, 2) print(num1, num2) # Output 3457 5116


Note: As you can see, we set a

start = 1000

and a

stop = 10000

because we want to generate the random number of length 4 (from 1000 to 9999).

Random integer number multiple of n

For example, let’s generate a random number between x and y multiple of 3 like 3, 6, 39, 66.


import random num = random.randrange(3, 300, 3) print(num) # output 144


What are the Applications of Randint Python Function?

Since the Python randint() function generates a pseudo-random integer, it is usually helpful in gaming and lottery applications. For instance, let’s say a participant gets three chances to guess the following random number generated within a range. If the person gets it correct within the three attempts, he wins, or else loses. Let’s simulate this situation using the randint Python function in the example below.

Example: Creating a Lucky Draw Game with the randint() Function

In the below code, you will generate a random number between 1 and 20 three times. You will then accept input from the user and check if the guess is correct and wins. Let’s begin with our example.

# importing randint function

from random import randint

# Function to generate new random integer

def random_generator():

return randint(1, 20)

# Function to take input from user and show results

def your_guess():

# calling function to generate random numbers

rand_number = random_generator()

# defining the number of

# guesses the user gets

remaining_gus = 3

# Setting win-condition checker flagship variable

flagship = 0

# Using loop to provide only three chances

while remaining_gus > 0:

# Taking user input

guess_num = int(input(“What’s your guess?\n”))

# checking if the guess is correct

if guess_num == rand_number

# setting flagship 1 for correct guess to

# break loop

flagship = 1

break

else:

# printing the failure message

print(“Oops, you missed!”)

# Decrementing guesses left

remaining_gus -= 1

# your_guess function returns True if win-condition

# is satisfied

if flagship == 1:

return True

# else returns False

else:

return False

# Final output code to decide win or lose

if __name__ == ‘__main__’:

if your_guess() is True:

print(“Wow, you hit the bull’s eye!”)

else :

print(“Sorry, better luck next time!”)

Output:

Second attempt output:

Well, as it is evident, you could not get it correct in the first game. But in the second game, you hit the bull’s eye in the very first attempt. Copy-paste the code in any Python compiler, and you too can enjoy the game. You can compete with your friends and family members, and make a day out of it.

Understanding Random Number Generation in Python

Random number generation is a fundamental concept in programming that has a variety of applications, from game development to data analysis. Python’s

random

module, which includes the

randint()

function, is a powerful tool for generating these random numbers.

The Role of Python’s Random Module

Python’s

random

module provides a suite of functions for generating random numbers. These functions include

randint()

,

random()

,

uniform()

, and many others. Each function generates a random number in a different way or within a different range.


import random random_integer = random.randint(1, 10) random_float = random.random() random_uniform = random.uniform(1.0, 10.0) print(random_integer, random_float, random_uniform) # Output: # (A random integer between 1 and 10, a random float between 0.0 and 1.0, a random float between 1.0 and 10.0)


In this code, we’re using three functions from Python’s

random

module to generate different types of random numbers. Each function provides a unique way to generate random numbers, making the

random

module a versatile tool for random number generation in Python.

The Importance of Randomness in Programming

Randomness plays a crucial role in many areas of programming. For instance, in game development, randomness can be used to create unpredictable gameplay elements. In data analysis, random sampling can help ensure a representative sample of data. By understanding how to generate random numbers in Python, you can harness the power of randomness in your own programming projects.

Further Reading: Probability Theory and Statistical Analysis

If you’re interested in the theory behind random number generation, consider studying probability theory. And if you want to apply random number generation in data analysis, look into statistical analysis in Python. Both topics will provide a deeper understanding of the power and potential of Python’s

randint()

function.

Further Resources for Python Modules

For a more profound understanding of Python Modules, we have gathered several insightful resources for you:

• Python Modules Fundamentals Covered – Dive deep into Python’s module caching and reload mechanisms.

• Implementing Queues in Python – Dive into various queue types, including FIFO and LIFO, in Python.

• Simplifying Random Data Generation in Python – Learn how to add randomness to your Python programs with “random.”

• Python’s Random Module – Learn about the random module and generating random numbers with this Programiz guide.

• How to Create Random Numbers in Python – A Medium article that delves into generating random numbers in Python.

• Python’s Random Tutorial – A tutorial by Real Python covering topics related to generating random numbers in Python.

Explore these resources, and you’ll be taking another stride towards expertise in Python and taking your coding abilities to the next level.

What Errors and Exceptions Can Occur While Using Randint in Python?

The Python randint() function can throw the following two errors:

• ValueError: This error is thrown if you try to pass floating-point numbers as arguments
• TypeError: This error is thrown if you try to pass anything except numeric values as arguments

Example: Getting ValueError for Randint Python Function

In the code below, you will try passing a floating-point value as a parameter to get the ValueError while compiling the program.

# importing the random module

import random

# using the randint function

int1 = random.randint(0.0, 4.9)

print(int1)

Output:

As you passed a floating-point value as the second (end) parameter, you got a ValueError while running the code.

Example: Getting TypeError for Randint Python Function

In the code below, you will try passing a string value as a parameter to get the TypeError while compiling the program intentionally.

# importing the random module

import random

# using the randint function

int1 = random.randint(‘x’, ‘y’)

print(int1)

Output:

As you can see in the output, this demo got a TypeError saying ‘can only concatenate str (not “int”) to str’ as you passed string values instead of integers.

Random negative integer

Let’s see how to generate a random negative integer between -60 to -6.


import random singed_int = random.randrange(-60, -6) print(singed_int) # Output -16


Generate random positive or negative integer


import random for i in range(5): print(random.randint(-10, 10), end=' ') # Output 10 -1 5 -10 -7


Randomly generate 1 or -1


import random num = random.choice([-1, 1]) print(num)


Note: we used random.choice() to choose a single number from the list of numbers. Here our list is

[-1, 1]

.

Conclusion

• randint() function is used to generate the random integers between the two given numbers passed as parameters.
• Randint is an in-built function of random library in python. So we have to import the random library at the start of our code to generate random numbers.
• randint function returns:
  • ValueError, when floating point values are passed as parameters.
  • TypeErrorwhen anything other than numeric values is passed as parameters.

In this lesson, we will see how to use the

randrange()

and

randint()

functions of a Python random module to generate a random integer number.

Using

randrange()

and

randint()

functions of a random module, we can generate a random integer within a range. In this lesson, you’ll learn the following functions to generate random numbers in Python. We will see each one of them with examples.

Function	Description
Returns any random integer from 0 to 9
Returns a random integer from 0 to 19
Returns a random integer from 2 to 19.
Returns any random integer from 100 to 999 with step 3. For example, any number from 100, 103, 106 … 994, 997.
Returns a random negative integer between -50 to -6.
Returns a list of random numbers
Returns a secure random number

Expanding the Range of randint

Python’s

randint()

function isn’t limited to small ranges. In fact, you can generate random integers in any range you like. For example, if you’re simulating a lottery draw, you might need to generate numbers between 1 and 1000:


import random lottery_number = random.randint(1, 1000) print(lottery_number) # Output: # (A random number between 1 and 1000)


In this example, we’ve expanded the range of

randint()

to generate a random number between 1 and 1000. This demonstrates the flexibility of the

randint()

function.

TL;DR: How Do I Use the randint Function in Python?

The randint function is part of Python’s random module, and it’s used to generate a random integer within a specified range. Here’s a simple example:


import random number = random.randint(1, 10) print(number) # Output: # (A random number between 1 and 10)


In this example, we’re using Python’s

random.randint()

function to generate a random number between 1 and 10. The

import random

line at the beginning is necessary because randint is part of the random module in Python. The function

random.randint(1, 10)

then generates a random integer within the range of 1 and 10.

If you’re interested in learning more about the randint function, including its more advanced uses and potential issues you might encounter, keep reading for a comprehensive exploration.

Table of Contents

• Understanding Python’s randint Function
• Expanding the Range of randint
• Using randint in Loops
• Exploring Alternatives to randint
• Common Issues and Solutions with randint
• Best Practices with randint
• Understanding Random Number Generation in Python
• Real-World Applications of Python’s randint
• Further Reading: Probability Theory and Statistical Analysis
• Wrapping Up: Python’s randint Function

Functions for integers¶

random.randrange(stop)¶

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

Return a randomly selected element from


range(start, stop, step)

.

This is roughly equivalent to


choice(range(start, stop, step))

but supports arbitrarily large ranges and is optimized for common cases.

The positional argument pattern matches the


range()

function.

Keyword arguments should not be used because they can be interpreted in unexpected ways. For example


randrange(start=100)

is interpreted as

randrange(0, 100, 1)

.

Changed in version 3.2:


randrange()

is more sophisticated about producing equally distributed values. Formerly it used a style like

int(random()*n)

which could produce slightly uneven distributions.

Changed in version 3.12: Automatic conversion of non-integer types is no longer supported. Calls such as


randrange(10.0)

and

randrange(Fraction(10, 1))

now raise a

TypeError

.

random.randint(a, b)¶

Return a random integer N such that


a <= N <= b

. Alias for

randrange(a, b+1)

.

random.getrandbits(k)¶

Returns a non-negative Python integer with k random bits. This method is supplied with the Mersenne Twister generator and some other generators may also provide it as an optional part of the API. When available,


getrandbits()

enables

randrange()

to handle arbitrarily large ranges.

Changed in version 3.9: This method now accepts zero for k.

Next Steps

I want to hear from you. What do you think of this article on

randint()

and

randrange()

? Or maybe I missed one of the usages of those two functions. Either way, let me know by leaving a comment below.

Also, try to solve the following exercise and quiz to have a better understanding of working with random data in Python.

• Python random data generation Exercise to practice and master the random data generation techniques in Python.
• Python random data generation Quiz to test your random data generation concepts.

The random module in Python allows you to generate pseudo-random variables. The module provides various methods to get the random variables, one of which is the randint method. The randint Python function is a built-in method that lets you generate random integers using the random module.

Understanding Python’s randint Function

Python’s

randint()

is a function that belongs to the

random

module. It is used to generate a random integer within a defined range. The function takes two parameters: the start and end of the range, inclusive.

Using randint: A Simple Example

Let’s look at a simple code example to understand how

randint()

works:


import random number = random.randint(1, 10) print(number) # Output: # (A random number between 1 and 10)


In this example,

import random

is used to import the random module, which contains the randint function. Next,

random.randint(1, 10)

is used to generate a random integer between 1 and 10, inclusive. The result is then stored in the variable

number

, which is printed out.

Parameters and Return Value

The

randint(a, b)

function takes two parameters:

• : The lower limit of the range (inclusive).
• : The upper limit of the range (inclusive).

The function returns a random integer such that

a <= N <= b

.

Understanding the Output

The output of the

randint()

function is a random integer within the specified range. In our example, the output is a random number between 1 and 10. Each time you run the code, you might get a different number because the selection is random.

By understanding the basics of Python’s

randint()

function, you can start to harness the power of random number generation in your coding projects.

Exploring Alternatives to randint

While

randint()

is a powerful tool for generating random integers, Python offers other functions and modules for random number generation. These include the

random()

function, the

uniform()

function, and the NumPy module.

The random Function

The

random()

function is another part of Python’s random module. Unlike

randint()

,

random()

generates a random floating-point number between 0.0 and 1.0.


import random random_number = random.random() print(random_number) # Output: # (A random floating-point number between 0.0 and 1.0)


The

random()

function doesn’t take any arguments and returns a random float in the range [0.0, 1.0).

The uniform Function

The

uniform(a, b)

function generates a random floating-point number between and . It’s similar to

randint()

, but it works with floating-point numbers.


import random random_number = random.uniform(1.0, 10.0) print(random_number) # Output: # (A random floating-point number between 1.0 and 10.0)


In this example,

random.uniform(1.0, 10.0)

generates a random float between 1.0 and 10.0.

The NumPy Module

NumPy, a powerful library for numerical computation in Python, also provides functions for random number generation. For instance,

numpy.random.randint()

generates random integers in a similar way to Python’s

randint()

.


import numpy random_number = numpy.random.randint(1, 10) print(random_number) # Output: # (A random integer between 1 and 10)


In this example,

numpy.random.randint(1, 10)

generates a random integer between 1 and 10, just like Python’s

randint()

function.

These alternative methods offer more flexibility and options for random number generation in Python. Depending on your specific needs, you might find one of these methods more suitable than

randint()

.

Functions for sequences¶

random.choice(seq)¶

Return a random element from the non-empty sequence seq. If seq is empty, raises


IndexError

.

random.choices(population, weights=None, *, cum_weights=None, k=1)¶

Return a k sized list of elements chosen from the population with replacement. If the population is empty, raises


IndexError

.

If a weights sequence is specified, selections are made according to the relative weights. Alternatively, if a cum_weights sequence is given, the selections are made according to the cumulative weights (perhaps computed using


itertools.accumulate()

). For example, the relative weights

[10, 5, 30, 5]

are equivalent to the cumulative weights

[10, 15, 45, 50]

. Internally, the relative weights are converted to cumulative weights before making selections, so supplying the cumulative weights saves work.

If neither weights nor cum_weights are specified, selections are made with equal probability. If a weights sequence is supplied, it must be the same length as the population sequence. It is a


TypeError

to specify both weights and cum_weights.

The weights or cum_weights can use any numeric type that interoperates with the


float

values returned by

random()

(that includes integers, floats, and fractions but excludes decimals). Weights are assumed to be non-negative and finite. A

ValueError

is raised if all weights are zero.

For a given seed, the


choices()

function with equal weighting typically produces a different sequence than repeated calls to

choice()

. The algorithm used by

choices()

uses floating point arithmetic for internal consistency and speed. The algorithm used by

choice()

defaults to integer arithmetic with repeated selections to avoid small biases from round-off error.

New in version 3.6.

Changed in version 3.9: Raises a


ValueError

if all weights are zero.

random.shuffle(x)¶

Shuffle the sequence x in place.

To shuffle an immutable sequence and return a new shuffled list, use


sample(x, k=len(x))

instead.

Note that even for small


len(x)

, the total number of permutations of x can quickly grow larger than the period of most random number generators. This implies that most permutations of a long sequence can never be generated. For example, a sequence of length 2080 is the largest that can fit within the period of the Mersenne Twister random number generator.

Changed in version 3.11: Removed the optional parameter random.

random.sample(population, k, *, counts=None)¶

Return a k length list of unique elements chosen from the population sequence. Used for random sampling without replacement.

Returns a new list containing elements from the population while leaving the original population unchanged. The resulting list is in selection order so that all sub-slices will also be valid random samples. This allows raffle winners (the sample) to be partitioned into grand prize and second place winners (the subslices).

Members of the population need not be hashable or unique. If the population contains repeats, then each occurrence is a possible selection in the sample.

Repeated elements can be specified one at a time or with the optional keyword-only counts parameter. For example,


sample(['red', 'blue'], counts=[4, 2], k=5)

is equivalent to

sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)

.

To choose a sample from a range of integers, use a


range()

object as an argument. This is especially fast and space efficient for sampling from a large population:

sample(range(10000000), k=60)

.

If the sample size is larger than the population size, a


ValueError

is raised.

Changed in version 3.9: Added the counts parameter.

Changed in version 3.11: The population must be a sequence. Automatic conversion of sets to lists is no longer supported.

Summing It Up

In this article, you learned everything about the randint Python function. You also learned something fun, which was creating a lucky draw game that you can enjoy in your free time. You can also tweak that code to make it a bit more complex for a bigger lucky draw game.

It is fascinating to see how one can do so much with Python programming. If you want to learn more about Python’s concepts, you can refer to Simplilearn’s Python Tutorial for Beginners. The tutorial is dedicated to newbies to help them get acquainted with Python’s basics. Once you are done with the basics, you can opt for our Post Graduate Program in Full Stack Web Development course to learn the advanced concepts and excel in Python development.

Have any questions for us? Leave them in the comments section, and our experts will answer them for you ASAP!

Hàm random() trong Python có thực sự “ngẫu nhiên”?

Chúng ta đều biết sự hữu ích của việc tạo ra số ngẫu nhiên trong một số trường hợp cụ thể dù là trong lập trình hay trong cuộc sống thường nhật. Trong các trò chơi, chúng ta ném xúc xắc để tạo ra một con số không thể đoán trước, xác định bước đi tiếp theo của người chơi. Ngoài ra, tất cả chúng ta đều sẽ đồng ý rằng việc chơi bất cứ một trò chơi bài nào mà không có sự xáo trộn ngẫu nhiên các lá bài sẽ là vô nghĩa.
Vậy chắc hẳn, khi các bạn xử lý với số ngẫu nhiên trong lập trình Python cũng sẽ có thắc mắc giống như mình. Liệu Python có sinh ra được những số thực sự ngẫu nhiên?

Ngẫu nhiên thựcGiả ngẫu nhiên

Số ngẫu nhiên có thể thu được do áp dụng các phương pháp toán học hay được gọi là bộ tạo số ngẫu nhiên (Random Number Generator – RNG). Nó có thể được chia thành 2 loại: bộ tạo số ngẫu nhiên thực (True Random Number Generators – TRNGs hay còn gọi là bộ tạo số ngẫu nhiên phần cứng) và bộ tạo số giả ngẫu nhiên (Pseudo-random Number Generator – PRNGS).

Table of contents

• How to use random.randint()
• random.randrange() to generate random integers within a range
• Random negative integer
• Generate a list of random integer numbers
• Generate a secure random integer
• Create a multidimensional array of random integers
• Points to remember about randint() and randrange()
• Next Steps

Module Random trong Python

Python cung cấp sẵn một module cực kỳ dễ sử dụng để xử lý với các số ngẫu nhiên. Module này gọi là

random

, được cài đặt một bộ tạo số giả ngẫu nhiên và chứa các hàm cho phép chúng ta giải quyết trực tiếp nhiều vấn đề lập trình khác nhau sử dụng đến tính ngẫu nhiên.
Module

random

dựa trên Marsenne Twister – một thuật toán rất phổ biến, là trình tạo số giả ngẫu nhiên mặc định không chỉ cho Python, mà còn cho nhiều hệ thống phần mềm phổ biến khác như Microsoft Excel, MATLAB, R hay PHP. Ưu điểm nổi bật của nó là việc được cấp phép chứng nhận, tính ngẫu nhiên được xác nhận bởi nhiều thử nghiệm thống kê và tốc độ tương đối cao so với các PRNG khác.

Hàm random()

Phương thức quan trọng nhất của module

random

là phương thức

random()

. Hầu hết các chức năng khác phụ thuộc vào nó. Phương thức

random()

tạo ra một số thực float ngẫu nhiên trong phạm vi (0.0, 1.0).


>>> import random >>> random.random() 0.8474337369372327


Hàm seed()

Nếu chúng ta không đặt một seed cho bộ tạo số giả ngẫu nhiên, thì seed mặc định là thời gian hệ thống hiện tại. Tuy nhiên, chúng ta có thể đặt giá trị chính xác của seed một cách thủ công, việc này sẽ rất hữu ích nếu chúng ta muốn sao chép kết quả giả ngẫu nhiên trong tương lai. Với mục đích như vậy, chúng ta có thể sử dụng phương thức

random.seed()



>>> random.seed(5) >>> random.random() 0.6229016948897019 >>> random.random() 0.7417869892607294 >>> random.random() 0.7951935655656966 >>> random.seed(5) >>> random.random() 0.6229016948897019


Phương thức

random.seed()

sẽ ảnh hưởng đến tất cả các phương thức của module

random

mà chúng ta sử dụng sau khi gọi nó. Trong đoạn code ví dụ ở trên, ta đặt seed là và sau đó gọi hàm

random.random()

nhiều lần. Điều quan trọng cần lưu ý ở đây là seed do người dùng định nghĩa sẽ chỉ được sử dụng lần đầu tiên khi có một phương thức

random

khác được thực thi – sau đó, các seed cho các phương thức sau sẽ thay đổi bằng cách sử dụng các giá trị ngẫu nhiên được tạo ra trước đó.
Điều này cho phép Python đưa ra được giá trị ngẫu nhiên mới mỗi lần. Tuy nhiên, sau khi thiết lập lại seed bằng phương thức

random.seed()

, chúng ta sẽ có thể sao chép chính xác chuỗi số giả ngẫu nhiên bất cứ lúc nào. Điều này rất hữu ích cho những việc như chạy thử nghiệm. Nếu bạn đưa ra cùng một seed mỗi khi bạn chạy một thử nghiệm có sử dụng một trong các phương pháp

random

thì bạn vẫn có thể biết đầu ra sẽ là gì cho các thử nghiệm này.

Một vài ví dụ cụ thể của module Random

Hàm randint()


>>> random.randint(1,10) 4


Phương thức

random.randint()

lấy hai đối số thể hiện phạm vi mà phương thức rút ra một số nguyên ngẫu nhiên. Ở ví dụ trên là số nguyên được chọn ngẫu nhiên từ 1 đến 9.

Hàm randrange()


>>> random.randrange(2,10,2) 2 >>> random.randrange(2,10,2) 4 >>> random.randrange(2,10,2) 8 >>> random.randrange(2,10,2) 6


Trong đoạn code trên, phương thức

random.randrange()

tương tự như

random.randint()

nhưng nó cũng cho phép chúng ta xác định đối số thứ ba, là bước nhảy trong phạm vi được xác định. Ở ví dụ này, ta chỉ yêu cầu đưa ra các số chẵn trong phạm vi từ 2 đến 9.

Hàm choice()


>>> cards = ['ace_spades','10_hearts','3_diamonds','king_hearts'] >>> random.choice(cards) '10_hearts'


Trong đoạn code này, phương thức

random.choice()

chọn một phần tử ngẫu nhiên thuộc danh sách.

Hàm shuffle()


>>> cards = ['ace_spades','10_hearts','3_diamonds','king_hearts'] >>> random.shuffle(cards) >>> print(cards) ['king_hearts', '3_diamonds', 'ace_spades', '10_hearts']


Trong đoạn code trên, phương thức

random.shuffle()

xáo trộn một danh sách các phần tử. Điều quan trọng cần lưu ý ở đây là nó xáo trộn chính ở trong danh sách đó. Có nghĩa là phương thức này trả về

None

và thực sự sửa đổi biến

cards

của chúng ta.

Recipes¶

These recipes show how to efficiently make random selections
from the combinatoric iterators in the

itertools

module:

def random_product(*args, repeat=1): “Random selection from itertools.product(*args, **kwds)” pools = [tuple(pool) for pool in args] * repeat return tuple(map(random.choice, pools)) def random_permutation(iterable, r=None): “Random selection from itertools.permutations(iterable, r)” pool = tuple(iterable) r = len(pool) if r is None else r return tuple(random.sample(pool, r)) def random_combination(iterable, r): “Random selection from itertools.combinations(iterable, r)” pool = tuple(iterable) n = len(pool) indices = sorted(random.sample(range(n), r)) return tuple(pool[i] for i in indices) def random_combination_with_replacement(iterable, r): “Choose r elements with replacement. Order the result to match the iterable.” # Result will be in set(itertools.combinations_with_replacement(iterable, r)). pool = tuple(iterable) n = len(pool) indices = sorted(random.choices(range(n), k=r)) return tuple(pool[i] for i in indices)

The default

random()

returns multiples of 2⁻⁵³ in the range
0.0 ≤ x < 1.0. All such numbers are evenly spaced and are exactly
representable as Python floats. However, many other representable
floats in that interval are not possible selections. For example,

0.05954861408025609

isn’t an integer multiple of 2⁻⁵³.

The following recipe takes a different approach. All floats in the interval are possible selections. The mantissa comes from a uniform distribution of integers in the range 2⁵² ≤ mantissa < 2⁵³. The exponent comes from a geometric distribution where exponents smaller than -53 occur half as often as the next larger exponent.

from random import Random from math import ldexp class FullRandom(Random): def random(self): mantissa = 0x10_0000_0000_0000 | self.getrandbits(52) exponent = -53 x = 0 while not x: x = self.getrandbits(32) exponent += x.bit_length() – 32 return ldexp(mantissa, exponent)

All real valued distributions in the class will use the new method:

>>> fr = FullRandom() >>> fr.random() 0.05954861408025609 >>> fr.expovariate(0.25) 8.87925541791544

The recipe is conceptually equivalent to an algorithm that chooses from
all the multiples of 2⁻¹⁰⁷⁴ in the range 0.0 ≤ x < 1.0. All such
numbers are evenly spaced, but most have to be rounded down to the
nearest representable Python float. (The value 2⁻¹⁰⁷⁴ is the smallest
positive unnormalized float and is equal to

math.ulp(0.0)

.)

See also

Generating Pseudo-random Floating-Point Values a
paper by Allen B. Downey describing ways to generate more
fine-grained floats than normally generated by

random()

.

By Sneh

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

In this tutorial, we are going to focus on the

randint()

method in Python. In our previous tutorials, we saw different random number generating methods defined inside the random module in our Random Number Tutorial in Python.

So, as you already know, we need to import the random module in Python first to begin using the randint() method. The module essentially creates pseudo-randomness.

Basically, the

randint()

method in Python returns a random integer value between the two lower and higher limits (including both limits) provided as two parameters.

It should be noted that this method is only capable of generating integer-type random value. Take a look at the syntax so that we can further incorporate the method.


#randint() Syntax randint(lower limit , upper limit)


Here,

The above example returns an integer N where N>=beg and N<=end.

It works in the same way

randrange(beg,end)

does, and hence is an alias for the same.

Let us look at the given code below, it illustrates the use and working of the

randint()

method.


import random beg=10 end=100 random_integer = random.randint(beg, end) print("The random integer is :", random_integer)


Output:

Clearly, we can see that the

randint()

method generates a random integer value within the limit 1-100.

Is this value random? What happens when we call the method multiple times? Does it return the same value?

The code snippet below answers all the above-mentioned questions and gives us a clear understanding.


import random beg=10 end=100 for i in range(5): print(random.randint(beg, end))


Output:

For the above code, repeating the

random.randint()

method gives us different random integers for each call within the limit 10 to 100.

Hence, we can infer that the values are random for each call and do not overlap in our case. Furthermore, when the number of calls is large and the range is quite smaller, in that case, the random values generated may collide or overlap.

As said earlier, one must ensure that the higher and lower limit parameters have to be an integer type. For other types, we get a ValueError as shown below.


import random beg=5.3 end=10.2 print(random.randint(beg, end))


Output:


Traceback (most recent call last): File "C:/Users/sneha/Desktop/test.py", line 4, in

print(random.randint(beg, end)) File "C:\Users\sneha\AppData\Local\Programs\Python\Python37-32\lib\random.py", line 222, in randint return self.randrange(a, b+1) File "C:\Users\sneha\AppData\Local\Programs\Python\Python37-32\lib\random.py", line 186, in randrange raise ValueError("non-integer arg 1 for randrange()") ValueError: non-integer arg 1 for randrange() Process finished with exit code 1



I hope this brief tutorial on the randint() method in Python has made the function clear for you. Your feedback is always welcome through the comments.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Click below to sign up and get $200 of credit to try our products over 60 days!

Working on improving health and education, reducing inequality, and spurring economic growth? We’d like to help.

Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

Using Python’s randint for Random Number Generation

Python’s randint function is a powerful tool in your coding arsenal. It’s like a digital dice, capable of generating random numbers for a variety of applications.

This function can seem a bit confusing at first, but fear not! In this guide, we will dive deep into the ins and outs of using randint in Python. By the end of this guide, you will be able to confidently use the randint function in your own Python projects.

So, let’s roll the dice and start our journey into the world of Python’s randint function.

Python3

Output

Random number between 0 and 10 is 2
Random number between -10 and -1 is -7
Random number between -5 and 5 is -3