Scribd
Upload
21 views4 pages

Class 12 Python: Random Module Guide

The document provides an overview of Python's random module, detailing its functions for generating random numbers, making random selections, and shuffling data. It includes examples of basic functions like random(), uniform(), randint(), and methods for sampling and shuffling. Additionally, it discusses applications in simulations, games, and data science, along with practice questions and exam tips.

Uploaded by

uma divan
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
21 views4 pages

Class 12 Python: Random Module Guide

The document provides an overview of Python's random module, detailing its functions for generating random numbers, making random selections, and shuffling data. It includes examples of basic functions like random(), uniform(), randint(), and methods for sampling and shuffling. Additionally, it discusses applications in simulations, games, and data science, along with practice questions and exam tips.

Uploaded by

uma divan
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

Class 12 Python – Random Module (4 Pages Notes)

1. Introduction to Random Module

 Python’s random module is used to generate random numbers and perform random
operations.

 It is widely used in simulations, games, data sampling, and testing programs.

 To use it, you must import the module:

import random

2. Functions in Random Module

A. Basic Random Number Generators

1. random()

o Returns a random float between 0.0 and 1.0.

2. print([Link]()) # e.g., 0.3748

3. uniform(a, b)

o Returns a random float in the range [a, b].

4. print([Link](1, 10)) # e.g., 7.43

5. randint(a, b)

o Returns a random integer between a and b (inclusive).

6. print([Link](1, 6)) # like a dice roll

7. randrange(start, stop, step)

o Returns a random number from a range.

8. print([Link](1, 10, 2)) # odd numbers between 1 and 9

B. Random Choices from Sequences

1. choice(sequence)

o Returns a random element from a list, tuple, or string.

2. colors = ["red", "blue", "green"]


3. print([Link](colors))

4. choices(population, k=n)

o Returns a list of n random elements (with replacement).

5. print([Link]([1, 2, 3, 4], k=3)) # e.g., [2, 4, 2]

6. sample(population, k=n)

o Returns n unique random elements (without replacement).

7. print([Link]([1, 2, 3, 4, 5], 3)) # e.g., [5, 1, 3]

C. Shuffling Data

 shuffle(list)

o Randomly reorders elements of a list.

 numbers = [1, 2, 3, 4, 5]

 [Link](numbers)

 print(numbers) # e.g., [3, 1, 5, 4, 2]

D. Seeding Random Numbers

 seed(n)

o Sets the starting point of the random generator (useful for reproducibility).

 [Link](10)

 print([Link](1, 100))

If the same seed is used, the same random numbers are generated each time.

3. Applications of Random Module

 Simulations: Rolling dice, lottery, scientific experiments.

 Games: Card shuffling, random moves in AI.

 Data Science: Random sampling, model testing.

 Security: Generating OTPs and passwords.

Example – Dice Roll Simulation


import random

print("You rolled:", [Link](1, 6))

Example – Password Generator

import random, string

chars = string.ascii_letters + [Link] + "!@#$%"

password = "".join([Link](chars, 8))

print("Generated Password:", password)

4. Differences Between Functions

Function Output Type Example Usage

random() Float [0,1) Probability simulation

uniform(a,b) Float Random float in range

randint(a,b) Integer Dice roll, guessing game

randrange() Integer Random step values

choice() Single item Pick a card, color, etc.

choices() List Multiple picks (with repeat)

sample() List Multiple picks (no repeat)

shuffle() None Shuffling a deck of cards

seed(n) None Reproducibility in testing

5. Practice Questions

1. Write a program to simulate rolling a dice 10 times.

2. Generate 5 random floating-point numbers between 10 and 50.

3. Pick 3 random students from a list using sample().

4. Write a program to shuffle a deck of 52 playing cards.

5. Generate a random OTP of 6 digits.


6. Demonstrate the effect of seed() by generating the same random sequence twice.

6. Exam Tips

 Be clear about difference between randint() and randrange().

 sample() vs choices() is a frequently asked board exam question.

 Always remember random() → float between 0 and 1.

 Be ready to write simple programs using random functions.

Common questions

Powered by AI

random.choice selects a single random element from a sequence such as a list, tuple, or string, allowing duplicate selection on multiple calls. In contrast, random.sample returns a list of unique elements sampled from the input sequence, ensuring no element is selected more than once in the same operation. Hence, random.choice is used for single selections, while random.sample is used for multiple unique selections.

random.choices would be chosen over random.sample in applications where repeated elements are allowed and potentially desired, such as simulating a lottery where returning to previous states of choices is realistic, or when sampling with replacement is fundamental to the process, such as bootstrapping methods in statistical analysis. The allowance for repetition distinguishes random.choices from random.sample, which only selects unique elements.

random.randint is preferred when an integer output is specifically needed, such as simulating a die roll, where results must be whole numbers. For applications where any number, including fractions, is acceptable, such as generating random temperatures or other measurements, random.uniform is more suitable as it generates random floats within a specified range.

Seeding random number generation is crucial in machine learning for the reproducibility of results. By setting a seed, the randomness becomes deterministic, ensuring that experiments can be repeated with the same outcomes, facilitating model validation and debugging. This controlled randomness is vital in producing reliable results across different test scenarios and algorithms deployment in production, where consistent behavior is required.

The random.seed function is crucial for controlling the starting state of the random number generator. This allows for the reproducibility of sequences of random numbers by providing the same seed, enabling developers to generate identical sequences of numbers across different program runs. This is particularly important for debugging and testing as it eliminates randomness, ensuring consistent test results.

Both randrange and randint generate random integers, but randrange offers more control over the stepping of values. randint provides random integers inclusively between two bounds, akin to rolling a die, whereas randrange allows specification of a starting point, ending point, and step size, creating more tailored series of potential outputs. This makes randrange suitable for more specialized or constrained selections compared to the straightforward bounds of randint.

The uniform function can effectively simulate scientific data by generating plausible continuous data points within a specific range, such as temperature readings from environmental sensors. By specifying realistic lower and upper limits, the uniform function produces data that mimics potential real-world scenarios, useful in simulations and models that require natural variance within controlled bounds, facilitating realistic test conditions and forecasts.

random.shuffle randomly reorders the elements within a list, which can be utilized to shuffle a deck of cards, ensuring a random distribution of cards at the start of a game. This function directly modifies the list in place, reflecting the new order immediately. It implies that each card has an equal chance of being anywhere in the sequence, simulating a realistic shuffling process needed for fairness in card games.

Overlooking the differences between random.choice and random.sample can lead to software bugs and misbehaviors; for example, using random.choice where unique selections are needed may introduce duplicate elements that break programs depending on exclusive conditions, such as vote counts or subset selections in resource allocations. This misunderstood functionality can lead to incorrect logic and application failures further downstream.

random.random generates a random float within the range [0, 1), thus only capable of producing values between 0.0 and just under 1.0. Meanwhile, random.uniform allows for specifying a range [a, b], outputting random floats anywhere between the given bounds, thus offering more flexibility in applications where a broader or different range of float outputs is required. The choice between them affects their application depending on the needed range of output floats.

You might also like