By writing Python code in a .py file

By creating a .module file

By defining functions inside a Python script

Both a and c

External

Enclosing

Environment

Encapsulation

A module is a file containing Python code.

Modules help to organize code.

Modules allow code reuse.

All of the above

import module_name

module_name import

import_module module_name

None of the above

import module_name as new_name

rename module_name as new_name

import module_name -> new_name

module_name.rename(new_name)

Each module creates its own namespace.

Variables in one module are isolated from other modules.

Functions and variables in a module can be accessed using the dot operator.

All of the above

reload()

importlib.reload()

reimport()

module.reload()

math

os

sys

All of the above

Code reusability

Simplified debugging

Better organization

All of the above

import sqrt from math

from math import sqrt

import math.sqrt

from math import *

Local scope

Global scope

Class scope

Function scope

Global variable

Local variable

Both values

None of the above

Writing code multiple times

Using import statements

Copy-pasting functions

Redefining functions in every file

os

random

math

sys

The global scope

The scope of the outer function in a nested function

The local scope of a function

The built-in scope

import module_name.all

from module_name import all

from module_name import *

import * from module_name

To create a copy of the module

To simplify module names in the code

To improve the performance of the module

To protect the module from errors

To apply changes made to the module without restarting the program

To clear the cache of the module

To delete the module's content

To use a module with a new name

os

sys

argparse

input

local

def

No keyword is needed

var

To define a new global variable

To access or modify a global variable inside a function

To declare a local variable

To remove a global variable

Local

Enclosing

Global

Built-in

print()

len()

max()

All of the above

Modules can be reused in other programs.

Modules always run faster than plain scripts.

Modules help in organizing the code better.

Modules can contain functions, classes, and variables.

All functions and variables from the module are imported into the current namespace.

The module is imported as an object, and its members must be accessed using the dot operator.

Only the main function of the module is imported.

None of the above.

.py

.mod

.module

.pyc

To import the entire module.

To import specific members of a module into the current namespace.

To create a duplicate of the module.

To rename the module at import.

The code in the module gets executed

The module's functions become available for use

The entire module is copied into the program

All of the above

Local scope

Global scope

Enclosing scope

Built-in scope

import math imports the entire module, while from math import sqrt imports only the sqrt function

import math imports only the sqrt function

There is no difference

from math import sqrt imports the entire module

Global scope

General scope

Global function

Group scope

import numpy as np

import numpy np

import np from numpy

import numpy = np

import numpy as np

import numpy np

import np from numpy

import numpy = np

print()

math.sqrt()

random.choice()

sys.argv()

A file with .py extension

A class definition inside the file

Functions inside the file

All of the above

sqrt(math)

math.sqrt()

math.sqroot()

sqrt(math.sqrt)

Import specific functions or variables from a module

Import all functions and variables from a module

Import modules from a subdirectory

Both a and b

os

sys

importlib

math

os

random

time

sys

'module'

'__main__'

'__file__'

'__name__'

The module is imported and executed

The module is executed, and its __name__ attribute is set to '__main__'

The module is ignored by the interpreter

Only the functions of the module are executed

It raises an error

It is imported only once, and subsequent imports are ignored

It overwrites the previous import

It wi

It raises an error

It is imported only once, and subsequent imports are ignored

It overwrites the previous import

It will result in slower execution

A place where all variables are stored

A space that defines the scope of a variable

A special module to store functions

A space to execute code

length()

size()

str_length()

len()

A namespace that refers to a specific module's name

A namespace where all global variables are stored

A special namespace where only functions are available

A unique namespace assigned to the Python interpreter

It resets the module to its original state

It clears the module's cache and reimports the module

It makes the module permanent in memory

It does nothing to the module

It imports everything, which could lead to namespace conflicts

It imports only specific functions

It does not work with built-in modules

It increases memory usage

By directly using the variable

By using the global keyword

By defining it again inside the function

By using the enclosing keyword

In the global namespace

In the interpreter's memory

In a cache file

In the module's own namespace

In the global namespace

In the interpreter's memory

In a cache file

In the module's own namespace

import module as alias_name

import alias_name from module

from module import alias_name

rename module as alias_name

bar.foo()

foo.bar()

import bar.foo()

import foo.bar()

random

math

sys

All of the above

Provides functions for interacting with the system

Allows access to system-specific parameters

Handles command-line arguments

All of the above

mymodule.x

import mymodule.x

mymodule(x)

from mymodule import x

A file with .py extension

A Python class inside the file

Functions in the module

All of the above

import math.function1, function2

from math import function1, function2

import function1, function2 from math

from math import *

In the current directory

In the directories listed in sys.path

In the Python standard library

All of the above

It marks a directory as a package

It initializes the package

It executes the code when the package is imported

All of the above

It marks a directory as a package

It initializes the package

It executes the code when the package is imported

All of the above

reload()

importlib.reload()

reload(module_name)

Both b and c

'module'

'__main__'

'__init__'

'__file__'

Only the math function is imported

All functions and variables in the math module are available

math module is renamed to math_function

Only sqrt function is imported

datetime

time

calendar

All of the above

Python raises a ModuleNotFoundError

Python ignores the error and continues

Python raises an ImportError

Both a and c

It imports the module and all its dependencies

It imports only the module, not the dependencies

It raises an error

It ignores dependencies

Yes, using the import statement

No, Python doesn't allow it

Yes, but only if both modules are in the same directory

No, you need to use external libraries for it

Local scope

Global scope

Enclosing scope

Built-in scope

By directly using the variable

By using the global keyword

By defining it again inside the function

By using the enclosing keyword

In the global namespace

In the interpreter's memory

In a cache file

In the module's own namespace

import module as alias_name

import alias_name from module

from module import alias_name

rename module as alias_name

bar.foo()

foo.bar()

import bar.foo()

import foo.bar()

random

math

sys

All of the above

Provides functions for interacting with the system

Allows access to system-specific parameters

Handles command-line arguments

All of the above

mymodule.x

import mymodule.x

mymodule(x)

from mymodule import x

A file with .py extension

A Python class inside the file

Functions in the module

All of the above

import math.function1, function2

from math import function1, function2

import function1, function2 from math

from math import *

In the current directory

In the directories listed in sys.path

In the Python standard library

All of the above

It marks a directory as a package

It initializes the package

It executes the code when the package is imported

All of the above

reload()

importlib.reload()

reload(module_name)

Both b and c

'module'

'__main__'

'__init__'

'__file__'

Only the math function is imported

All functions and variables in the math module are available

math module is renamed to math_function

Only sqrt function is imported

datetime

time

calendar

All of the above

Python raises a ModuleNotFoundError

Python ignores the error and continues

Python raises an ImportError

Both a and c

It imports the module and all its dependencies

It imports only the module, not the dependencies

It raises an error

It ignores dependencies

It imports the module and all its dependencies

It imports only the module, not the dependencies

It raises an error

It ignores dependencies

Yes, using the import statement

No, Python doesn't allow it

Yes, but only if both modules are in the same directory

No, you need to use external libraries for it

Local scope

Global scope

Enclosing scope

Built-in scope

It makes the code more concise

It avoids naming conflicts

It speeds up execution

Both a and b

sqrt()

math.sqrt()

from math import sqrt

import sqrt from math

The name of the current module

The command-line arguments passed to the Python script

The Python interpreter version

The list of imported modules

All lowercase letters, with words separated by underscores

Uppercase letters with no spaces

CamelCase with the first letter capitalized

Any naming format is allowed

importlib

sys

os

reload

It makes the

code more concise

It avoids naming conflicts

It speeds up execution

Both a and b

Importing modules from the current directory

Importing from a sibling module

Importing from the parent module

All of the above

include module_name

load module_name

require module_name

import module_name

Using the define keyword

Using the create keyword

Using the function keyword

Using the def keyword

reload()

import()

refresh()

update()