As programs become larger, writing all the code in a single file becomes difficult to manage.

Python solves this problem by allowing us to divide programs into multiple files called Modules.

A module contains related functions, variables, and classes that can be reused in different programs.

Using modules makes programs more organized, reusable, and easier to maintain.

A Module is a collection of related functions, variables, and classes stored in a single Python file.

Every module is saved with the .py extension.

Instead of writing the same code repeatedly, we can place the code inside a module and use it whenever required.

A group of functions, variables, and classes saved to a file is called a Module.

Every Python file with the .py extension acts as a module.

Modules provide several advantages while developing Python applications.

They help us organize code, avoid duplication, and make programs easier to understand.

Modules help us:

• Organize related code into a single file.
• Reuse the same code in multiple programs.
• Reduce code duplication.
• Make programs easier to maintain.
• Improve readability.
• Simplify testing and debugging.

Every Python file (.py) is automatically treated as a module.

For example, if a file is named durgamath.py, Python considers it a module.

Any functions, variables, or classes defined inside that file become members of the module.

The file durgamath.py is a Python module.

We can store related mathematical functions inside this file and use them in other Python programs.

A module created by the programmer is called a User-Defined Module.

To create a user-defined module, simply create a Python file and write variables, functions, or classes inside it.

For example, create a file named durgamath.py.

The module contains the following members:

• One variable: x
• Function: add()
• Function: product()

These members can be accessed from another Python program after importing the module.

If we want to use the members of a module in another program, we should import that module.

After importing the module, we can access its variables, functions, and classes.

After importing the module, its members are accessed using the module name.

Step 1

import durgamath

Imports the durgamath module.

Step 2

print(durgamath.x)

Accesses the variable x from the module.

Step 3

durgamath.add(10, 20)

Calls the add() function from the module.

Step 4

durgamath.product(10, 20)

Calls the product() function from the module.

Whenever we use a module in our program, Python generates a compiled file for that module and stores it permanently on the hard disk.

Create Module
      │
      ▼
Import Module
      │
      ▼
Access Variables
      │
      ▼
Call Functions
        

• Improves code organization.
• Encourages code reuse.
• Reduces duplication.
• Makes maintenance easier.
• Improves readability.
• Supports modular programming.
• Allows multiple programs to share the same code.

• Building reusable utility libraries.
• Creating large software projects.
• Organizing application code into separate files.
• Sharing common functions among multiple programs.
• Developing reusable APIs and frameworks.

1. What is a Module in Python?
2. Why do we use Modules?
3. Is every Python file a module?
4. What is a User-Defined Module?
5. How do you create a module?
6. How do you import a module?
7. How do you access variables from a module?
8. How do you call functions from a module?
9. What happens when a module is imported?
10. What are the advantages of using Modules?

• A module is a collection of functions, variables, and classes stored in a Python file.
• Every Python file (.py) acts as a module.
• User-defined modules are created by programmers.
• The import statement is used to load a module.
• Module variables are accessed using module_name.variable.
• Module functions are called using module_name.function().
• According to the tutorial, importing a module generates a compiled file for that module.
• Modules help organize and reuse code efficiently.

In the previous section, we learned how to create and import user-defined modules.

Python also allows us to import modules in different ways depending on our requirements.

Sometimes a module name is too long or conflicts with another identifier in the program.

In such cases, Python allows us to give another name to the module while importing it. This feature is called Module Aliasing.

Sometimes we can provide another name to a module while importing it.

This is called Module Aliasing.

Using an alias makes the module name shorter and easier to use throughout the program.

In this example:

• durgamath is the original module name.
• m is the alias name.

After importing the module with an alias, all members of the module are accessed using the alias name.

After creating an alias, we can access all module members by using the alias name.

The module durgamath is imported with the alias m.

The variable x is accessed using m.x.

The functions add() and product() are also called using the alias name.

This makes the code shorter and easier to read.

Sometimes we do not need all the members of a module.

Instead of importing the entire module, Python allows us to import only the required members.

This is done using the from ... import statement.

The main advantage is that imported members can be accessed directly without using the module name.

• x and add() are imported successfully.
• product() is not imported.
• Since product() is unavailable, Python raises a NameError.

If we want to import every member of a module, we can use the * operator.

This imports all variables, functions, and classes from the module.

After importing, the members can be accessed directly without using the module name.

Python supports several ways to import modules.

The appropriate method depends on the requirements of the program.

Just as we can rename a module, we can also rename individual module members while importing them.

This feature is called Member Aliasing.

The variable x is imported with the alias y.

The function add() is imported with the alias sum.

After importing, only the alias names can be used.

Once an alias name is assigned, we must use only the alias name.

The original name cannot be used in the current program.

The variable x was imported with the alias y.

Therefore, the original name x is no longer available in the current program.

Using x raises a NameError.

• Reduces long module names.
• Makes code easier to read.
• Improves code readability.
• Helps avoid naming conflicts.
• Provides convenient access to module members.

• Imports only the required members.
• Allows direct access without using the module name.
• Produces shorter code.
• Improves readability when only a few members are needed.

• Using short aliases for large library names such as numpy as np.
• Importing only frequently used functions.
• Avoiding conflicts between modules with similar names.
• Writing clean and maintainable Python programs.

1. What is Module Aliasing?
2. Why do we use the as keyword?
3. What is the difference between import module and from module import member?
4. What does from module import * do?
5. What is Member Aliasing?
6. Can the original member name be used after aliasing?
7. What happens if a non-imported member is accessed?
8. List different ways to import modules in Python.
9. When should Module Aliasing be used?
10. What are the advantages of importing selected members?

• Module aliasing is done using the as keyword.
• After creating an alias, module members are accessed through the alias name.
• from ... import imports only the specified members.
• Imported members can be accessed directly without using the module name.
• from module import * imports all members of the module.
• Member aliasing allows imported members to be renamed.
• Once a member is imported with an alias, only the alias name can be used.
• Using the original member name after aliasing results in a NameError.

When a module is imported into a Python program, Python loads it only once.

Even if the same module is imported multiple times, Python does not reload it again.

This improves program performance because the module does not need to be loaded repeatedly.

However, this behavior creates a problem when the source code of the module is modified after it has already been imported.

In such situations, Python continues using the old version of the module instead of the updated one.

To use the modified version without restarting the Python interpreter, we must reload the module.

By default, a module will be loaded only once, even if we import it multiple times.

If we modify the source code of a module after importing it, those changes are not reflected automatically in the current program.

To load the updated version of the module, we must reload it.

Suppose:

• A module is already imported.
• Later, the module is modified.
• We want to use the updated version without restarting the Python interpreter.

In this situation, we should reload the module.

The reload() function is used to reload an already imported module.

Before using reload(), we should import it from the imp module.

After reloading, Python loads the latest version of the module from the source file.

Assume the following module already exists.

Step 1

import durgamath

The durgamath module is imported into the program.

Step 2

print(durgamath.x)

The value of the variable x stored in the module is displayed.

Step 3

from imp import reload

The reload() function is imported from the imp module.

Step 4

reload(durgamath)

The module is reloaded so that Python reads the latest version from the source file.

Step 5

print(durgamath.x)

The updated value of x is displayed after the module has been reloaded.

1. Python imports the module for the first time.
2. The module is stored in memory.
3. If the module source code changes later, Python continues using the old version.
4. The reload() function forces Python to read the module file again.
5. The updated module replaces the old version in memory.

Import Module
      │
      ▼
Module Loaded into Memory
      │
      ▼
Modify Source Code
      │
      ▼
Old Version Still Used
      │
      ▼
Call reload(module)
      │
      ▼
Latest Version Loaded
        

If a module is modified after it has already been imported, Python does not load the modified version automatically.

We must explicitly call:

reload(module_name)

Only then will Python use the updated version of the module in the current program.

• When developing or testing Python modules.
• When a module is modified while the interpreter is still running.
• When we want to use the latest version without restarting Python.
• During debugging to verify changes immediately.

• Loads the latest version of a module.
• Removes the need to restart the Python interpreter.
• Useful during development and debugging.
• Allows testing updated module code immediately.

• Works only with modules that have already been imported.
• Must be called explicitly.
• Python does not reload modules automatically after they are modified.

• Developing reusable Python libraries.
• Testing modules during software development.
• Interactive Python sessions.
• Debugging applications without restarting the interpreter.
• Updating utility modules during development.

1. What is module reloading in Python?
2. Why is reload() required?
3. When should we use reload()?
4. Which module provides the reload() function according to this tutorial?
5. Can Python automatically reload a modified module?
6. What happens if a module is modified after it has already been imported?
7. What is the syntax of the reload() function?
8. What are the advantages of using reload()?

• By default, a module is loaded only once.
• Importing the same module multiple times does not reload it.
• Modifying a module does not automatically update it in the current program.
• The reload() function is used to reload an already imported module.
• According to this tutorial, reload() should be imported from the imp module.
• Reloading allows the latest version of the module to be used without restarting Python.
• The module must already be imported before it can be reloaded.

When working with Python modules, we often need to know what variables, functions, classes, and built-in attributes are available inside a module.

Python provides a built-in function called dir() for this purpose.

The dir() function displays all the members available in a specified module.

This makes it easy to explore a module without reading its source code.

The dir() function is used to display all members of a module.

It returns:

• Variables
• Functions
• Classes
• Built-in attributes

available in the specified module.

The output contains all the available members of the math module.

The exact output may vary depending on the Python version being used, but it always includes the members provided by that module.

The dir() function is useful when:

• We want to know what members are available in a module.
• We do not remember the exact function names.
• We want to explore a module.

First, the math module is imported.

The dir(math) function returns a list containing every available member of the module.

The returned list is stored in the variable members and then displayed.

• Displays all members of a module.
• Helps discover available functions.
• Useful for beginners learning new modules.
• Reduces the need to memorize function names.
• Helps during debugging and development.
• Provides information about built-in attributes.

• Exploring built-in Python modules.
• Learning third-party libraries.
• Debugging unfamiliar modules.
• Finding available functions quickly.
• Understanding APIs without reading source code.

• By default, a module is loaded only once.
• Modifying a module does not automatically update it in the current program.
• The reload() function is used to reload an already imported module.
• According to this tutorial, reload() should be imported from the imp module.
• The dir() function displays all members of a module.
• dir() helps identify the available variables, functions, classes, and built-in attributes in a module.

1. What is the purpose of the dir() function?
2. What does the dir() function return?
3. Can dir() display functions available in a module?
4. How do you display all members of the math module?
5. What is the difference between import and reload()?
6. Why is the dir() function useful?
7. Does dir() display built-in attributes?
8. When should you use dir() while programming?

Whenever a Python module is executed, the Python interpreter automatically adds several special properties to that module.

These properties are created internally by Python and are mainly used by the interpreter for managing the execution of the program.

Although these properties are generated automatically, they can also be accessed from our Python programs whenever required.

These special properties provide useful information about the currently executing module.

For every module, at the time of execution, the Python interpreter automatically adds some special properties for internal use.

These properties can also be accessed in our program.

Some of the important special properties are:

• __builtins__
• __cached__
• __doc__
• __file__
• __loader__
• __name__
• __package__
• __spec__

Each special property stores different information related to the current module.

Some properties describe the module itself, while others help Python manage module loading and execution.

These properties are created automatically, so programmers normally do not need to define them manually.

The program simply prints every important special property automatically added by Python.

Each statement displays information maintained internally by the Python interpreter.

The displayed values may vary depending on the Python version and execution environment.

__builtins__ refers to the built-in Python module that contains all built-in functions, exceptions, and objects.

Examples include:

• print()
• len()
• input()
• type()
• range()

This property allows Python to access all built-in functionality.

__cached__ stores information about the compiled version of the module.

If no compiled version exists, its value may be None.

Python internally uses this property while working with compiled module files.

__doc__ stores the documentation string (Docstring) of the module.

If no documentation string is available, Python returns None.

__file__ stores the name or path of the currently executing Python file.

In the example, it displays:

test.py

__loader__ contains information about the object responsible for loading the module.

Python uses this loader internally while importing modules.

__name__ stores information about how the current file is executed.

If the file is executed directly, its value becomes __main__.

If the file is imported as a module, its value becomes the module name.

This important property will be discussed in detail in the next section.

__package__ stores the package name to which the module belongs.

If the file does not belong to any package, its value is generally None.

__spec__ stores information related to the module specification.

This property is mainly used internally by Python's import system.

• Provide internal information about modules.
• Help Python manage program execution.
• Useful for debugging.
• Allow developers to inspect module details.
• Help understand how modules are loaded.

• Debugging Python programs.
• Building Python frameworks.
• Developing reusable libraries.
• Understanding module loading.
• Creating developer tools and utilities.

1. What are Special Properties in Python?
2. Who creates Special Properties?
3. When are these properties added to a module?
4. What is the purpose of __builtins__?
5. What does __file__ store?
6. What is stored in __doc__?
7. What is the use of __loader__?
8. What information is stored in __package__?
9. What is __spec__?
10. Which special property stores execution information?

• Python automatically adds several special properties to every module.
• These properties are mainly used internally by the Python interpreter.
• Programmers can also access these properties directly.
• __builtins__ provides access to Python's built-in objects.
• __doc__ stores the module documentation string.
• __file__ stores the module filename.
• __loader__ stores loader information.
• __package__ stores package information.
• __spec__ stores module specification details.
• __name__ is one of the most important special properties and is explained separately in the next section.

__name__ is one of the most important special variables automatically added by the Python interpreter.

Every Python module contains this variable.

The value stored in __name__ depends on how the Python file is executed.

Because of this behavior, __name__ is widely used while creating reusable Python modules.

The special variable __name__ identifies whether a Python file is executed directly or imported as a module.

Python automatically assigns an appropriate value during program execution.

Sometimes a Python file contains reusable functions as well as testing code.

We want the testing code to execute only when the file is run directly.

If another program imports that file as a module, only the reusable functions should become available.

The __name__ variable helps us achieve this behavior.

When module1.py is executed directly, Python assigns:

__name__ = "__main__"

The condition:

if __name__ == "__main__":

becomes true.

Therefore, the statements inside the if block are executed.

When module1 is imported into another program, Python assigns:

__name__ = "module1"

The condition:

if __name__ == "__main__":

becomes false.

Hence, the statements inside the if block are not executed.

Only the module members become available for use.

Python File Starts
        │
        ▼
Is File Executed Directly?
        │
   ┌────┴────┐
   │         │
  Yes        No
   │         │
   ▼         ▼
__name__   __name__
= "__main__" = Module Name
   │         │
   ▼         ▼
if Block    Skip if Block
Executed
        

• Separates testing code from reusable code.
• Makes modules reusable.
• Prevents unnecessary execution when importing modules.
• Improves code organization.
• Widely used in professional Python projects.

• Testing Python modules.
• Creating reusable libraries.
• Writing standalone scripts.
• Developing large Python applications.
• Separating demonstration code from actual module code.

• __name__ is automatically created by the Python interpreter.
• Its value depends on how the file is executed.
• Direct execution assigns __main__.
• Importing assigns the module name.
• The statement if __name__ == "__main__": is one of the most commonly used statements in Python.
• It prevents testing code from executing when the module is imported.

1. What is the purpose of the __name__ variable?
2. Who creates the __name__ variable?
3. What is the value of __name__ when a file is executed directly?
4. What is the value of __name__ when a file is imported?
5. Why is if __name__ == "__main__": used?
6. Can reusable modules contain testing code?
7. What happens when a module is imported?
8. Where is the __name__ variable commonly used?
9. Why is __name__ important in large projects?
10. What are the advantages of using __name__?

Python provides an inbuilt math module.

This module defines several functions that can be used for performing mathematical operations.

The math module contains many predefined functions, constants, and utilities that simplify mathematical calculations.

Instead of writing complex mathematical formulas manually, we can use the functions available in the math module.

The main important functions available in the math module are:

1. sqrt(x)
2. ceil(x)
3. floor(x)
4. fabs(x)
5. log(x)
6. sin(x)
7. tan(x)

Before using the functions available in the math module, we must import the module.

To use all functions available in the module, import all members as shown below:

The sqrt() function returns the square root of a number.

The square root of 4 is 2.

Therefore, the sqrt() function returns 2.0.

The ceil() function returns the smallest integer greater than or equal to the given value.

The value 10.1 lies between 10 and 11.

The smallest integer greater than or equal to 10.1 is 11.

Hence, ceil(10.1) returns 11.

The floor() function returns the largest integer less than or equal to the given value.

The value 10.1 lies between 10 and 11.

The largest integer less than or equal to 10.1 is 10.

Therefore, floor(10.1) returns 10.

The fabs() function returns the absolute (positive) value of a number.

Whether the given number is positive or negative, the returned value is always positive.

The absolute value removes the negative sign.

Therefore:

• fabs(-10.6) returns 10.6.
• fabs(10.6) also returns 10.6.

1. The math module is imported.
2. sqrt(4) calculates the square root of 4.
3. ceil(10.1) returns the next greater integer.
4. floor(10.1) returns the previous smaller integer.
5. fabs(-10.6) converts the negative value into a positive value.
6. fabs(10.6) returns the same positive value.

• Provides predefined mathematical functions.
• Reduces the need to write complex mathematical formulas.
• Produces accurate mathematical results.
• Makes programs shorter and easier to understand.
• Useful for scientific and engineering applications.

• Scientific calculations.
• Engineering software.
• Financial applications.
• Data analysis.
• Artificial Intelligence.
• Machine Learning.
• Computer graphics.

1. What is the purpose of the math module?
2. How do you import all members of the math module?
3. What does the sqrt() function return?
4. What is the difference between ceil() and floor()?
5. What is the purpose of the fabs() function?
6. Which function returns the absolute value?
7. Which function returns the square root?
8. Name four commonly used functions of the math module.

1. Which module provides advanced mathematical functions?
   A. random
   B. math
   C. os
   D. sys
   Answer: B
2. Which function returns the square root?
   A. pow()
   B. sqrt()
   C. root()
   D. abs()
   Answer: B
3. What is the output of ceil(10.1)?
   A. 10
   B. 10.1
   C. 11
   D. 12
   Answer: C
4. What is the output of floor(10.1)?
   A. 9
   B. 10
   C. 11
   D. 10.1
   Answer: B
5. Which function returns the absolute value?
   A. fabs()
   B. absvalue()
   C. positive()
   D. absolute()
   Answer: A

In addition to sqrt(), ceil(), floor(), and fabs(), the math module also provides several other useful mathematical functions.

Some of the important functions are:

• log(x)
• sin(x)
• tan(x)

These functions are available for performing various mathematical calculations.

The log() function is used to calculate the logarithm of a number.

It is commonly used in scientific calculations, engineering, statistics, and data analysis.

The log() function returns the natural logarithm of the specified number.

In the above example, the natural logarithm of 10 is displayed.

The sin() function returns the sine value of the specified angle.

This function is mainly used in trigonometry and scientific calculations.

The sine value of 0 is 0.

Hence the output is 0.0.

The tan() function returns the tangent value of the specified angle.

Like the sin() function, it is also used in trigonometric calculations.

The tangent value of angle 0 is 0.

Therefore, the output is 0.0.

Python provides the built-in help() function to obtain complete information about any module.

We can use this function to learn about all the functions, constants, variables, and documentation available in the math module.

The help(math) statement displays:

• All functions
• Variables
• Constants
• Documentation

available in the math module.

• Scientific calculations.
• Engineering software.
• Artificial Intelligence.
• Machine Learning.
• Data Analysis.
• Financial calculations.
• Computer Graphics.
• Game Development.

• The math module is a built-in Python module.
• It provides many functions for mathematical operations.
• sqrt() returns the square root of a number.
• ceil() returns the smallest integer greater than or equal to the given value.
• floor() returns the largest integer less than or equal to the given value.
• fabs() always returns the positive (absolute) value of a number.
• The math module also provides functions such as log(), sin(), and tan().
• We can use help(math) to view complete information about the math module.

1. What is the purpose of the math module?
2. What does the log() function return?
3. What is the use of the sin() function?
4. What is the use of the tan() function?
5. Why do we use help(math)?
6. Which function returns the absolute value?
7. Which function returns the square root?
8. Name any four functions provided by the math module.
9. Is the math module built into Python?
10. Which function displays complete information about a module?

Python provides an inbuilt module named random.

This module defines several functions to generate random numbers.

Using these functions, we can generate different random values whenever a program is executed.

The random module is useful whenever unpredictable values are required.

We can use these functions while:

• Developing games.
• Cryptography.
• Generating random numbers on the fly for authentication.

In this section, we will learn the following functions:

1. random()
2. uniform()

The random() function always generates a floating-point value between 0 and 1.

The generated value is always greater than 0 and less than 1.

The random() function generates a floating-point value every time it is called.

Each generated value lies between 0 and 1.

The value is never exactly 0 or 1.

Every execution of the program produces different values.

Note: Every execution produces different values.

The uniform(a, b) function returns a random floating-point number between the specified range.

Unlike random(), we can specify both the starting value and ending value.

The generated value may be any floating-point number between 1 and 10.

Every execution produces different values because the numbers are generated randomly.

This function is useful whenever random decimal values are required within a specified range.

• Game development.
• OTP generation.
• Password generation.
• Lottery systems.
• Simulation software.
• Testing applications using random data.
• Cryptography-related programs.

1. What is the purpose of the random module?
2. What type of value is returned by random()?
3. What is the range of the random() function?
4. What is the difference between random() and uniform()?
5. Which function allows us to specify the range?
6. Why do random numbers change every execution?
7. Where is the random module commonly used?
8. Can uniform() generate decimal values?

The random module also provides functions to generate random integer values.

Unlike random() and uniform(), these functions generate whole numbers (integers).

In this section, we will learn:

1. randint()
2. randrange()

The randint(a, b) function returns a random integer between a and b.

Both the starting value and ending value are included in the generated range.

The randint(1, 10) function generates a random integer between 1 and 10.

Both 1 and 10 are included in the possible output.

Each execution of the program produces different random numbers.

• The generated value is always an integer.
• Both the beginning and ending values are included.
• Every execution produces different random values.

The randrange() function returns a random integer from the specified range.

Its behavior is similar to Python's built-in range() function.

It is useful when random values are required from a sequence.

The statement randrange(10) generates a random integer from 0 to 9.

The ending value 10 is not included.

The statement randrange(1, 11) generates a random integer between 1 and 10.

The ending value 11 is excluded.

The third parameter specifies the step value.

In this example, only odd numbers are generated because the step size is 2.

Possible values are:

1, 3, 5, 7, 9, 11, 13, 15, 17, 19

• Dice simulation.
• Lottery number generation.
• Card games.
• Quiz applications.
• OTP generation.
• Random test case generation.
• Gaming applications.

1. What is the difference between randint() and randrange()?
2. Does randint() include the ending value?
3. Does randrange() include the ending value?
4. Which function supports a step value?
5. What is the output range of randrange(10)?
6. How do you generate only odd numbers using the random module?
7. Which function behaves like Python's range()?
8. Name two functions used to generate random integers.

The random module also provides functions that work with sequences such as lists and tuples.

These functions do not always generate random numbers. Instead, they can select random elements from a sequence.

In this section, we will learn the choice() function.

The choice() function does not return a random number.

It returns a random object from the given list or tuple.

Every time the function is executed, it may return a different element from the sequence.

The list contains five names.

Each time choice(list) is called, Python randomly selects one element from the list.

The selected element is returned and displayed.

The same element may appear multiple times because every selection is independent.

• choice() works with sequences such as lists and tuples.
• It returns only one element at a time.
• The returned element is selected randomly.
• The same value can be selected multiple times.
• It does not generate a random number.

• Selecting a random winner from a list.
• Displaying random motivational quotes.
• Choosing random quiz questions.
• Selecting random names in classrooms.
• Random card selection in games.
• Random recommendation systems.

1. What is the purpose of the choice() function?
2. Does choice() return a random number?
3. Which data structures are supported by choice()?
4. Can the same element be selected multiple times?
5. What is the difference between choice() and randint()?
6. Name five important functions of the random module.
7. Which function returns a random object from a sequence?
8. Where is the choice() function commonly used?

1. The random module is a built-in Python module.
2. random() returns a floating-point number between 0 and 1.
3. uniform() returns a floating-point number within the specified range.
4. randint() returns an integer within the specified range.
5. randrange() returns a random integer from the given range and also supports a step value.
6. choice() returns a random element from a list or tuple.
7. The random module is commonly used in games, cryptography, and authentication systems.

• Easy to generate random values.
• Provides both integer and floating-point random numbers.
• Can randomly select elements from lists and tuples.
• Useful for simulations and testing.
• Reduces the need to implement custom random number algorithms.
• Built into Python, so no external installation is required.

• Game development.
• Lottery systems.
• Online quiz applications.
• Password and OTP generation.
• Authentication systems.
• Simulation software.
• Random testing and test data generation.
• Artificial Intelligence and Machine Learning experiments.

1. What is the purpose of the random module?
2. Which function returns a floating-point number between 0 and 1?
3. What is the difference between random() and uniform()?
4. What is the difference between randint() and randrange()?
5. Which function returns a random object from a list?
6. Can choice() return duplicate values?
7. Which random function supports a step value?
8. Which functions generate floating-point numbers?
9. Which functions generate integers?
10. List five functions available in the random module.
11. Where is the random module commonly used?
12. Is the random module built into Python?