Using Python Libraries

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation
Docstrings are typically written within triple-quoted strings (i.e., using """ or '''), which allows for multiline strings. When the help<module> command is issued in Python, it retrieves and displays the documentation string (docstring) associated with the specified modules, classes, functions, methods.

(b)

Both Assertion and Reason are true but Reason is not the correct explanation of Assertion.

Explanation
The import <module> statement imports the entire module, making its contents available in a new namespace with the same name as the module. They do become accessible in the program's namespace through dot notation, but they are not added directly to the current namespace.

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation
The from <module> import <item> command directly imports the specified item into the current namespace. This means that the imported item becomes part of the program's namespace and can be accessed directly without using the module name.

(a)

Both Assertion and Reason are true and Reason is the correct explanation of Assertion.

Explanation
Python's built-in functions such as print(), len(), range() etc, are automatically added to the program's namespace from the Python's standard library. They can be used directly without importing any modules or specifying their module name.

(e)

Both Assertion and Reason are false or not fully true.

Explanation
The import <module> statement imports the entire module into the new namespace setup with same name as that of module, while the from <module> import <item> statement imports specific items from the module into the current namespace. Hence, they both are different statements.

* operator

Reason — The syntax to import all modules from package is : from <modulename> import *. According to the syntax, * operator is used to import all modules from a package.

__init__.py

Reason — The file __init__.py in a folder, indicates it is an importable Python package, without __init__.py, a folder is not considered a Python package.

import math

Reason — The syntax for importing whole module is : import modulename. According to the syntax, the correct method to load a module math is import math.

from usable import tempc

Reason — The syntax for importing single method form a module is : from <module> import <objectname>. According to the syntax, the correct method is from usable import tempc.

.py

Reason — A Python library module has the .py extension.

module

Reason — A Python module is a file (.py file) containing variables, class definitions, statements and functions related to a particular task and can be used in other programs.

library

Reason — A library refers to a collection of modules and packages that together cater to a specific type of applications or requirements.

docstring

Reason — The docstrings are triple quoted strings in a Python module/program which are displayed as documentation when help (<module-or-program-name>) command is issued.

docstrings

Reason — Docstrings of a module are displayed as documentation, when help <module> statement is issued.

from <module> import <object>
from <module> import *

Reason —

1. from <module> import <object>— This syntax is used to import a specific object from a module into the current namespace.
2. from <module> import * — This syntax is used to import all objects from the module into the current namespace.

import <module>
import <module1>, <module2>

Reason —

1. import <module> — This syntax is used to import an entire module. It creates a new namespace with the same name as that of the module.

2. import <module1>, <module2> — This syntax is used to import multiple modules. It creates separate namespaces for each module, with names corresponding to the module names.

random()
uniform()

Reason — Random module functions random() and uniform() both return random floating point number .

randint()

Reason — Random module function randint() returns a random integer.

__init__.py

Reason — For a folder containing Python files to be recognized as a package, an __init__.py file (even if empty) must be part of the folder.

.py

Reason — A Python module has a .py extension.

randfloat()

Reason — Some most common random number generator functions in random module are random(), randint(), uniform(), randrange(). Hence, randfloat() is not a function of random module.

False

Reason — A Python program is a set of instructions or code written in the Python programming language that performs a specific task or a series of tasks. A Python module is a file containing Python code and is saved with a .py extension. Hence, Python program and module are not same.

True

Reason — A Python program is saved in a .py file, which can be executed to perform a specific task. A Python module is also a .py file containing Python code, but it's meant to be imported and used in other Python programs or modules to reuse code. So, both Python programs and modules share the same file extension, i.e., .py.

False

Reason — The import <module> statement imports entire module but it creates a new namespace with the same name as that of the module.

False

Reason — Not all folders having multiple .py files are packages. In order for a folder containing Python files to be recognized as a package, an __init__.py file must be part of the folder.

True

Reason — The file __init__.py (even if empty) in a folder, indicates it is an importable Python package, without __init__.py, a folder is not considered a Python package.

False

Reason — The statement from <module> import <objects> is used to import some selected items, not all from a module.

The significance of Python modules is as follows:

1. Modules reduce complexity of programs to some degree.
2. Modules create a number of well-defined, documented boundaries within the program.
3. Contents of modules can be reused in other programs, without having to rewrite or recreate them.

The docstrings are triple quoted strings in a Python module/program which are displayed as documentation when help (<module-or-program-name>) command is displayed.

Significance of docstrings is as follows:

1. Documentation — Docstrings are used to document Python modules, classes, functions, and methods.
2. Readability — Well-written docstrings improve code readability by providing clear explanations of the code's functionality.
3. Interactive Help — Docstrings are displayed as documentation when help (<module-or-program-name>) command is displayed.

For example:

# tempConversion.py
"""Conversion functions between fahrenheit and centigrade"""

# Functions
def to_centigrade(x):
    """Returns: x converted to centigrade"""
    return 5 * (x - 32) / 9.0

def to_fahrenheit(x):
    """Returns: x converted to fahrenheit"""
    return 9 * x / 5.0 + 32

# Constants
FREEZING_C = 0.0  #water freezing temp.(in celcius)
FREEZING_F = 32.0  #water freezing temp.(in fahrenheit)

import tempConversion
help(tempConversion)

Help on module tempConversion:

NAME
    tempConversion-Conversion functions between fahrenheit and centigrade
FILE
    c:\python37\pythonwork\tempconversion.py
FUNCTIONS
    to_centigrade(x)
        Returns : x converted to centigrade
    to_fahrenheit(x)
        Returns : x converted to fahrenheit
DATA 
    FREEZING_C = 0.0
    FREEZING_F = 32.0

A package is collection of Python modules under a common namespace, created by placing different modules on a single directory along with some special files (such as __init__.py).

Difference between package and module:

A library refers to a collection of modules that together cater to specific type of requirements or applications.
The procedure to create own library in Python is shown below:

1. Create a package folder having the name of the library.
2. Add module files (.py files containing actual code functions) to this package folder.
3. Add a special file __init__.py to it(even if the file is empty).
4. Attach this package folder to site-packages folder of Python installation.

The use of file __init__.py in a package even when it is empty is that without the __init__.py file, Python will not look for submodules inside that directory, so attempts to import the module will fail. Hence, the file __init__.py in a folder, indicates it is an importable Python package.

The importance of site-packages folder of Python installation is that we can easily import a library and package using import command in Python only if it is attached to site-packages folder as this is the default place from where python interpreter imports Python library and packages.

(a) import X — This statement is used to import entire module X. All the functions are imported in a new namespace setup with same name as that of the module X. To access one of the functions, we have to specify the name of the module (X) and the name of the function, separated by a dot. This format is called dot notation.

(b) from X import * — This statement is used to import all the items from module X in the current namespace. We can use all defined functions, variables etc from X module, without having to prefix module's name to imported item name.

(c) from X import a, b, c — This statement is used to import a, b, c objects from X module in the current namespace. We can use a, b, c objects from X module, without having to prefix module's name to imported item name.

PYTHON PATH VARIABLE is an environment variable used by python to specify directories where the python interpreter will look in when importing modules.

The significance of the PYTHON PATH variable lies in its ability to extend python's module search path. By adding directories to the PYTHON PATH variable, we can make python aware of additional locations where our custom modules or libraries are located. Overall, the PYTHON PATH variable provides flexibility and control over how python locates modules and packages, allowing us to customize the module search path according to our needs.

Python looks for the module names in the below order :

1. Built-in Modules — Python first looks for the module in the built-in modules that are part of the Python standard library.
2. Directories in sys.path — If the module is not found in the built-in modules, Python searches for it in the directories listed in the sys.path variable. The directories in sys.path typically include the current directory, directories specified by the PYTHON PATH environment variable, and other standard locations such as the site-packages directory.
3. Current Directory — Python also looks for the module in the current directory where the Python script or interactive session is running.

help() function — This function is used to display docstrings of a module as documentation. The syntax is : help(<module-name>)

dir() function — This function is used to display all the names defined inside the module. The syntax is : dir(<module-name>)

The Python Library modules required to be imported for these functions are:

After importing a module using import module statement, to access one of the functions, we have to specify the name of the module and the name of the function, separated by a dot. This format is called dot notation.
For example:

import math
print(math.pi)
print(math.sqrt(25))

The from <module> import <object> statement should be avoided to import objects because it imports objects directly into the current namespace. If a program already has a variable or function with the same name as the one imported via the module, the imported object will overwrite the existing variable or function, leading to potential name clashes because there cannot be two variables with the same name in one namespace.

Python standard library is distributed with Python that contains modules for various types of functionalities. Some commonly used modules of Python standard library are math module, random module, cmath module etc.

If we invoke the tempConversion module with two different types of import statements (import tempConversion and from tempConversion import *), the way we call the module's functions will be affected as follows:

1. import tempConversion — This imports the entire module in a new namespace setup with the same name as that of the module tempConversion. To call the module's functions, we need to use the dot notation tempConversion.<function_name>.
For example:

import tempConversion
tempConversion.to_centigrade(32) 
tempConversion.to_fahrenheit(0) 

2. from tempConversion import * — This imports all objects (functions, variables, etc.) from the module into the current namespace. This approach imports all objects directly into the current namespace, so we can call the module's functions without using the module name.
For example:

from tempConversion import *
to_centigrade(32)
to_fahrenheit(0)   

Allchecks.checkMain(3, 'A') and checkMain(4, 'Z') these two function-call statements are different from one another when the function being invoked is same because in Allchecks.checkMain(3, 'A') statement, Allchecks.py module is imported using import Allchecks import statement in a new namespace created with the same name as that of module name and hence they are called by dot notation whereas in checkMain(4, 'Z') statement Allchecks.py module is imported using from Allchecks import checkMain import statement in the current namespace and hence its module name is not specified along with the function name.

# basic.py
"""This module contains basic mathematical operations."""

def square(x):
    """Returns the square of a number."""
    return mul(x, x)

def mul(x, y):
    """Returns the product of two numbers."""
    return x * y

def div(x, y):
    """Returns the result of dividing x by y."""
    return float(x) / y

def fdiv(x, y):
    """Returns the result of floor division of x by y."""
    return x // y

def floordiv(x, y):
    return fdiv(x, y)

The code is saved with .py extension to save it as module.

(a) square(print 3) — print function should not be there as parameter in the function call. So the correct function call statement is square(3). Also, to call square function without prefixing the module name, it must be imported as from basic import square.

(b) basic.div() — The div() function requires two arguments but none are provided. So the correct statement is basic.div(x, y).

(c) basic.floordiv(7.0, 7) — There is no error.

(d) div(100, 0) — This will result in a runtime error of ZeroDivisionError as we are trying to divide a number by zero. The second argument of the function call should be any number other than 0. For example, div(100, 2). Also, to call div function without prefixing the module name, it must be imported as from basic import div.

(e) basic.mul(3, 5) — There is no error.

(f) print(basic.square(3.5)) — There is no error.

(g) z = basic.div(13, 3) — There is no error.

The statements are given in the program below:

import basic

# (a) Compute square of 19.23
square_result = basic.square(19.23)
print("Square of 19.23:", square_result)

# (b) Compute floor division of 1000.01 with 100.23
floor_div_result = basic.floordiv(1000.01, 100.23)
print("Floor division of 1000.01 by 100.23:", floor_div_result)

# (c) Compute product of 3, 4 and 5
product_result = basic.mul(basics.mul(3, 4), 5)
print("Product of 3, 4, and 5:", product_result)

# (d) 
result2 = basic.div(0, 100)
result1 = basic.div(100, 0)
print("Result of basic.div(100, 0):", result1)
print("Result of basic.div(0, 100):", result2)

Square of 19.23: 369.79290000000003
Floor division of 1000.01 by 100.23: 9.0
Product of 3, 4, and 5: 60
Result of basic.div(0, 100): 0.0
ZeroDivisionError

(d) basic.div(100, 0) results in a ZeroDivisionError because division by zero is not defined whereas basic.div(0, 100) results in 0.0 as the quotient of '0 / 100'.

import random
def diff():
    x = random.random() - random.random() 
    return(x)

y = diff()
print(y)

0.006054151450219258
-0.2927493777465524

Output will be a floating-point number representing the difference between two random numbers. Since every call to random() function of random module generates a new number, hence the output will be different each time we run the code.

The outcomes are as follows:

ES#NE#IO#
EC#NB#IS#

NUMBER is assigned a random integer between 0 and 3 using random.randint(0, 3). Therefore, the minimum value for NUMBER is 0 and the maximum value is 3.

Length of STRING having value "CBSEONLINE" is 10. So the character at index 9 is "E". Since the value of N starts at 9 the first letter of output will be "E". This rules out LE#NO#ON# and NS#IE#LO# as possible outcomes as they don't start with "E". NUMBER is a random integer between 0 and 3. So, the second letter of output can be any letter from "CBSE". After that, NUMBER is incremented by 1 and N is decremented by 1.
In next iteration, STRING[N] will be STRING[8] i.e., "N" and STRING[NUMBER] will be the letter coming immediately after the second letter of the output in the string "CBSEONLINE" i.e., if second letter of output is "S" then it will be "E" and if second letter is "C" then it will be "B".
In the third iteration, STRING[N] will be STRING[7] i.e., "I" and STRING[NUMBER] will be the letter coming immediately after the fourth letter of the output in the string "CBSEONLINE" i.e., if fourth letter of output is "E" then it will be "O" and if fourth letter is "B" then it will be "S".
After this the while loop ends as STRING[N] i.e., STRING[6] becomes "L". Thus both, ES#NE#IO# and EC#NB#IS# can be the possible outcomes of this code.

23 24 23 24
21 21 21 21

The lowest value that can be generated is 20 and the highest value that can be generated is 24.

1. import random — This line imports the random module.
2. print(int(20 + random.random() * 5), end=' ') — This line generates a random float number using random.random(), which returns a random float in the range (0.0, 1.0) exclusive of 1. The random number is then multiplied with 5 and added to 20. The int() function converts the result to an integer by truncating its decimal part. Thus, int(20 + random.random() * 5) will generate an integer in the range [20, 21, 22, 23, 24]. The end=' ' argument in the print() function ensures that the output is separated by a space instead of a newline.
3. The next print statements are similar to the second line, generating and printing two more random integers within the same range.

The lowest value that can be generated is 20 because random.random() can generate a value of 0, and (0 * 5) + 20 = 20. The highest value that can be generated is 24 because the maximum value random.random() can return is just less than 1, and (0.999... * 5) + 20 = 24.999..., which is truncated to 24 when converted to an integer.

105 107 105 110
110 105 105 110

The least value that can be generated is 105 and the highest value that can be generated is 110.

print(100 + random.randint(5, 10), end=' ') — This statement generates a random integer between 5 and 10, inclusive, and then adds 100 to it. So, the suggested outputs range from 105 to 110.

The lowest value that can be generated is 100 + 5 = 105.
The highest value that can be generated is 100 + 10 = 110.

(a) If the module wavwrite is imported using the command import music.formats.wavwrite, we can invoke its writefile() function by using the module name followed by the function name:

import music.formats.wavwrite
music.formats.wavwrite.writefile()

(b) If the module wavwrite is imported using the command from music.formats import wavwrite, we can directly invoke its writefile() function without prefixing the module name:

from music.formats import wavwrite
writefile()

DELHI
MUMBAI
CHENNAI
KOLKATA

DELHIDELHI
MUMBAIMUMBAI
CHENNAICHENNAI
KOLKATAKOLKATA

The minimum value for PICK is 0 and the maximum value for PICK is 3.

1. import random — Imports the random module.
2. PICK = random.randint(0, 3) — Generates a random integer between 0 and 3 (inclusive) and assigns it to the variable PICK.
3. CITY = ["DELHI", "MUMBAI", "CHENNAI", "KOLKATA"] — Defines a list of cities.
4. for I in CITY — This loop iterates over each city in the CITY.
5. for J in range(1, PICK) — This loop will iterate from 1 up to PICK - 1. The value of PICK can be an integer in the range [0, 1, 2, 3]. For the cases when value of PICK is 0 or 1, the loop will not execute as range(1, 0) and range(1, 1) will return empty range.
   For the cases when value of PICK is 2 or 3, the names of the cities in CITY will be printed once or twice, respectively. Hence, we get the possible outcomes of this code.

1. The basic structure of above package includes packages's name i.e., Conversion and all modules and subfolders.
2. Create the directory structure having folders with names of package and subpackages. In the above package, we created two folders by names Length and Mass. Inside these folders, we created Lengthconversion.py and MassConversion.py modules respectively.
3. Create __init__.py files in package and subpackage folders. We created an empty file and saved it as "__init__.py" and then copy this empty __init__.py file to the package and subpackage folders.
4. Associate it with python installation. Once we have our package directory ready, we can associate it with Python by attaching it to Python's site-packages folder of current Python distribution in our computer.
5. After copying our package folder in site-packages folder of our current Python installation, now it has become a Python library so that now we can import its modules and use its functions.

Directory structure is as follows:

Conversion/
    ├── __init__.py
    ├── Length/
    │     ├── __init__.py
    │     └── Lengthconversion.py
    └── Mass/
          ├── __init__.py
          └── MassConversion.py