{"id":5963,"date":"2022-04-16T19:04:52","date_gmt":"2022-04-16T17:04:52","guid":{"rendered":"http:\/\/miro.borodziuk.eu\/?p=5963"},"modified":"2026-01-23T20:55:32","modified_gmt":"2026-01-23T19:55:32","slug":"modules-in-python","status":"publish","type":"post","link":"http:\/\/miro.borodziuk.eu\/index.php\/2022\/04\/16\/modules-in-python\/","title":{"rendered":"Modules in Python"},"content":{"rendered":"

So what is a module? The Python Tutorial<\/a> defines it as a file containing Python definitions and statements<\/b>, which can be later imported and used when necessary.<\/p>\n

<\/p>\n

1. If you want to import a module as a whole, you can do it using the import module_name statement. You are allowed to import more than one module at once using a comma-separated list. For example:<\/p>\n

import mod1\r\nimport mod2, mod3, mod4<\/pre>\n
although the latter form is not recommended due to stylistic reasons, and it’s better and prettier to express the same intention in more a verbose and explicit form, such as:<\/p>\n
import mod2\r\nimport mod3\r\nimport mod4<\/pre>\n
 <\/p>\n
2. If a module is imported in the above manner and you want to access any of its entities, you need to prefix the entity’s name using dot notation. For example:<\/p>\n
import my_module\r\n\r\nresult = my_module.my_function(my_module.my_data)<\/pre>\n
The snippet makes use of two entities coming from the my_module<\/code><\/strong> module: a function named my_function()<\/code><\/strong> and a variable named my_data<\/code><\/strong>. Both names must be prefixed by my_module<\/code><\/strong>. None of the imported entity names conflicts with the identical names existing in your code’s namespace.<\/p>\n
 <\/p>\n
3. You are allowed not only to import a module as a whole, but to import only individual entities from it. In this case, the imported entities must not be prefixed when used. For example:<\/p>\n
from module import my_function, my_data\r\n\r\nresult = my_function(my_data)<\/pre>\n
The above way – despite its attractiveness – is not recommended because of the danger of causing conflicts with names derived from importing the code’s namespace.<\/p>\n
 <\/p>\n
4. The most general form of the above statement allows you to import all entities offered by a module:<\/p>\n
from my_module import *\r\n\r\nresult = my_function(my_data)<\/pre>\n
Note: this import’s variant is not recommended due to the same reasons as previously (the threat of a naming conflict is even more dangerous here).<\/p>\n
 <\/p>\n
5. You can change the name of the imported entity “on the fly” by using the as<\/code><\/strong> phrase of the import<\/code><\/strong>. For example:<\/p>\n
from module import my_function as fun, my_data as dat\r\n\r\nresult = fun(dat)<\/pre>\n
 <\/p>\n
Exercise 1<\/em><\/p>\n
You want to invoke the function make_money()<\/code> <\/strong>contained in the module named mint<\/strong><\/code>. Your code begins with the following line:<\/p>\n
import mint<\/pre>\n
What is the proper form of the function’s invocation?<\/p>\n
 <\/p>\n
mint.make_money()<\/pre>\n
 <\/p>\n
Exercise 2<\/em><\/p>\n
You want to invoke the function make_money()<\/code><\/strong> contained in the module named mint<\/strong><\/code>. Your code begins with the following line:<\/p>\n
from mint import make_money<\/pre>\n
What is the proper form of the function’s invocation?<\/p>\n
 <\/p>\n
make_money()<\/pre>\n
 <\/p>\n
Exercise 3<\/em><\/p>\n
You’ve written a function named make_money<\/code> <\/strong>on your own. You need to import a function of the same name from the mint<\/code> <\/strong>module and don’t want to rename any of your previously defined names. Which variant of the import statement may help you with the issue?<\/p>\n
 <\/p>\n
# sample solution\r\nfrom mint import make_money as make_more_money<\/pre>\n
 <\/p>\n
Exercise 4<\/em><\/p>\n
What form of the make_money<\/code> <\/strong>function invocation is valid if your code starts with the following line:<\/p>\n
from mint import *<\/pre>\n
?<\/p>\n
 <\/p>\n
make_money()<\/pre>\n
 <\/p>\n
Working with standard modules<\/strong><\/p>\n
1. A function named dir()<\/code><\/strong> can show you a list of the entities contained inside an imported module. For example:<\/p>\n
import os\r\ndir(os)<\/pre>\n
prints out the list of all the os module’s facilities you can use in your code.<\/p>\n
2. The math module couples more than 50 symbols (functions and constants) that perform mathematical operations (like sine()<\/code>, pow()<\/code>, factorial()<\/code>) or providing important values (like \u03c0<\/code> and the Euler symbol e<\/code>).<\/p>\n
3. The random module groups more than 60 entities designed to help you use pseudo-random numbers. Don’t forget the prefix “random<\/code>“, as there is no such thing as a real random number when it comes to generating them using the computer’s algorithms.<\/p>\n
4. The platform module contains about 70 functions which let you dive into the underlaying layers of the OS and hardware. Using them allows you to get to know more about the environment in which your code is executed.<\/p>\n
5. Python Module Index (https:\/\/docs.python.org\/3\/py-modindex.html is a community-driven directory of modules available in the Python universe. If you want to find a module fitting your needs, start your search there.<\/p>\n
 <\/p>\n
Exercise 1<\/em><\/p>\n
What is the expected value of the result variable after the following code is executed?<\/p>\n
import math\r\nresult = math.e == math.exp(1)<\/pre>\n
 <\/p>\n
True<\/code><\/p>\n
Exercise 2<\/em><\/p>\n
(Complete the sentence) Setting the generator’s seed with the same value each time your program is run guarantees that…<\/p>\n
… the pseudo-random values emitted from the random module will be exactly the same.<\/p>\n
 <\/p>\n
Exercise 3<\/em><\/p>\n
Which of the platform module’s functions will you use to determine the name of the CPU running inside your computer?<\/p>\n
The processor()<\/code> function<\/p>\n
 <\/p>\n
Exercise 4<\/em><\/p>\n
What is the expected output of the following snippet?<\/p>\n
import platform\r\nprint(len(platform.python_version_tuple()))<\/pre>\n
 <\/p>\n
3<\/code><\/p>\n
 <\/p>\n
Exercise 5<\/p>\n
What is the expected output of the following code?<\/p>\n
import math\r\n     \r\ndef my_func(x,y):\r\n    z = math.trunc(x) + math.ceil(x) - math.floor(y)\r\n    return z\r\n     \r\nprint(my_func(-1.6,-3.2))<\/pre>\n
trunc(x)<\/code> :\u00a0 returns the value of x truncated <\/strong>to an integer.<\/p>\n
ceil(x)<\/code> :\u00a0 returns the smallest <\/strong>integer greater than or equal to x<\/strong>.<\/p>\n
floor(x)<\/code> :\u00a0 returns the largest <\/strong>integer less than or equal to x.<\/strong><\/p>\n
So:<\/p>\n
math.trunc(-1.6)<\/code> returns -1<\/code><\/p>\n
math.ceil(-1.6)<\/code> returns -1<\/code><\/p>\n
math.floor(-3.2)<\/code> returns -4<\/code><\/p>\n
and my_func(-1.6,-3.2)<\/code> returns 2<\/code> (-1 -1 -(-4) = 2)<\/p>\n
 <\/p>\n
Exercise 6.<\/p>\n
You want to use a function named hyppo()<\/code> that resides in a module named animals <\/code>, and it has been imported using the following line:<\/p>\n
import animals as hyppos<\/code><\/p>\n
 <\/p>\n
hyppos.hyppo()<\/code><\/strong><\/p>\n
Here the animals <\/code>module is imported using aliasing.\u00a0Aliasing causes the module to be identified under a different name than the original – in this case the alias is hyppos<\/code>.<\/p>\n
Because the whole module is imported, calling any entity from that module must be made using both the module name and the entity name as module.entity <\/em>where module is the name of the module OR its alias.<\/p>\n
So calling the hyppo()<\/code> function is done as hyppos.hyppo()<\/code>.<\/p>\n
hyppo()<\/code> would have been a correct answer if the module had been imported as : from animals import hyppo<\/code>.<\/p>\n
animals.hyppo()<\/code> wouldd have been a correct answer if the module had been imported without an alias : import animals<\/code><\/p>\n
 <\/p>\n
Exercise 7.<\/p>\n
Consider the code below :<\/p>\n
from random import random\r\nfrom math import floor\r\n     \r\nfor i in range(5):\r\n    print(floor(random()*10),end=',')<\/pre>\n
What would be a possible result from the above code ? (Pick 2)<\/p>\n
\n
\n
\n
\n
\n
\n
A. 1,6,5,2,0,<\/code>
\nB. 2,7,3,10,2,<\/code>
\nC. 1,4,4,0,8,<\/code>
\nD. 0,10,20,40,10,<\/code><\/p>\n<\/div>\n
A and C<\/p>\n
Explanation:<\/p>\n
The random()<\/code> function (from the random module) returns a random floating point number in the range [0.0, 1.0)<\/strong> (in other words: (0.0 <= x < 1.0).<\/p>\n
The floor()<\/code> method (from the math module) returns the largest integer not greater than x<\/strong>.<\/p>\n
For example :<\/p>\n
floor(3.4)<\/code> returns 3<\/code><\/p>\n
floor(-3.6)<\/code> returns -4<\/code><\/p>\n
So, floor(random()*10)<\/code>\u00a0 would returns an integer between 0 and 9 (10 is not included since 1.0 is not included in the range of the random() function).<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
 <\/p>\n
Ex. 8<\/p>\n
What is the expected output of the following snippet ?<\/p>\n
    from math import factorial\r\n     \r\n    try:\r\n        print(factorial(-4))\r\n    except:\r\n        print(\"Error #1\")\r\n    except ValueError:\r\n        print(\"Error #2\")<\/pre>\n
A. 24<\/code><\/p>\n
\n
\n
\n
\n
B. Error #1<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
C. None of the other answers are correct.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
D.Error #2<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
Explanation:<\/em><\/p>\n
The factorial()<\/code> function is part of the math <\/code>module and allows to compute the factorial of a number. This number must be a positive integer; if not a ValueError <\/em>exception is raised.<\/p>\n
In the above code, the unnamed except<\/code> branch is placed before <\/em>a named except<\/code> branch : this is not a correct syntax and the code will generate a syntax error<\/strong>. When using multiple except<\/code> branches, if using an unnamed <\/strong>except<\/strong><\/code> branch, it must be placed last.<\/strong><\/p>\n
Try it yourself:<\/p>\n
    # this will raise a Syntax Error:\r\n    from math import factorial\r\n     \r\n    try:\r\n        print(factorial(-4))\r\n    except:\r\n        print(\"Error #1\")\r\n    except ValueError:\r\n        print(\"Error #2\")\r\n    # SyntaxError: default 'except:' must be last\r\n     \r\n    # Corrected code should be as below:\r\n    from math import factorial\r\n     \r\n    try:\r\n        print(factorial(-4))\r\n    except ValueError:\r\n        print(\"Error #2\")    # Error #2\r\n    except:\r\n        print(\"Error #1\")<\/pre>\n
C.<\/p>\n<\/div>\n
 <\/p>\n
Ex. 9<\/p>\n
\n
You are being asked to create a Python program that will ask a user for the leg lengths of a right-angle triangle and returns the length of the hypotenuse.<\/p>\n
Which code snippet below will achieve this requirement ?<\/p>\n
A.<\/p>\n
    import math\r\n     \r\n    x=float(input(\"Enter first length: \"))\r\n    y=float(input(\"Enter second length: \"))\r\n    print(\"Length of hypotenuse is: \", math.hypotenuse(x,y))<\/pre>\n
B.<\/p>\n
    import hypot\r\n     \r\n    x=float(input(\"Enter first length: \"))\r\n    y=float(input(\"Enter second length: \"))\r\n    print(\"Length of hypotenuse is: \", hypot(x,y))<\/pre>\n
C.<\/p>\n
    import math\r\n     \r\n    x=input(\"Enter first length: \")\r\n    y=input(\"Enter second length: \")\r\n    print(\"Length of hypotenuse is: \", math.hypot(x,y))<\/pre>\n
D.<\/p>\n
    from math import hypot\r\n     \r\n    x=float(input(\"Enter first length: \"))\r\n    y=float(input(\"Enter second length: \"))\r\n    print(\"Length of hypotenuse is: \", hypot(x,y))<\/pre>\n
Explanation:<\/strong><\/p>\n
Function hypot()<\/code>, from the math <\/strong>module, returns the length of the hypotenuse of a right-angle triangle with the leg lengths equal to x and y.<\/p>\n
This function can be imported either as : from math import hypot<\/code>\u00a0 (in this case the function can be used as hypot()<\/code> in the program) or : import math<\/code>\u00a0 (in this case the function can be used as math.hypot()<\/code> in the program).<\/p>\n
Additionally, when using the input()<\/code> function, keep in mind that the function always returns a string<\/em> – so the output of input()<\/code> must be converted (in this case to a float<\/em>) to be used with the hypot()<\/code> function.<\/p>\n
Based on this, only the following answer is correct :<\/p>\n
    from math import hypot\r\n     \r\n    x=float(input(\"Enter first length: \"))\r\n    y=float(input(\"Enter second length: \"))\r\n    print(\"Length of hypotenuse is: \", hypot(x,y))<\/pre>\n
D.<\/p>\n<\/div>\n
 <\/p>\n
Ex. 10<\/p>\n
\n
You are being asked to create a Python program that will randomly return five unique integers between 0 and 100 (both 0 and 100 are included as possible choices).<\/p>\n
Which code will achieve this requirement ?<\/p>\n
A.<\/p>\n
\n
\n
\n
\n
\n
\n
import random\r\nprint(\"Selected numbers are: \", random.randrange(0,101,5))<\/pre>\n
B.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
\n
\n
import random\r\nprint(\"Selected numbers are: \", random.choices(range(101),k=5))<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
C.<\/span><\/div>\n
\n
\n
\n
\n
import random\r\nprint(\"Selected numbers are: \", random.sample(range(101),k=5))<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
D.<\/span><\/div>\n
\n
\n
\n
\n
import random\r\nprint(\"Selected numbers are: \", [random.randint(0,101) for x in range(5)])<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
<\/code><\/p>\n
\n
Explanation:<\/strong><\/p>\n
Let’s review each suggested answers:<\/p>\n
–> print(\"Selected numbers are: \", random.randrange(0,101,5))<\/code><\/p>\n
Function randrange(start<\/em>, stop<\/em>[, step<\/em>])<\/code>\u00a0 (or randrange(stop<\/em>)<\/code>) returns one <\/strong>randomly selected element from range(start, stop, step)<\/code>.\u00a0 So, random.randrange(0,101,5))<\/code> will return one integer from range(0,101,5)<\/code> . The requirement calls for five integers, not one – so this will not work.<\/p>\n
–> print(\"Selected numbers are: \", [random.randint(0,101) for x in range(5)])<\/code><\/p>\n
Function randint(a<\/em>, b)<\/code>\u00a0returns a random integer N<\/em> such that a <= N <= b<\/code>.\u00a0 So, [random.randint(0,101) for x in range(5)]<\/code>\u00a0 (a list comprehension) will return a list of five integers between 0 and 101 (included) – also those elements will not necessarily be unique. So this is not complying with the requirements and it is not the correct answer.<\/p>\n
–> print(\"Selected numbers are: \", random.choices(range(101),k=5))<\/code><\/p>\n
Function choices(population<\/em>, k=1<\/em>)<\/code>\u00a0returns a k<\/em> sized list of elements chosen from the population – those elements may be repeated. So, random.choices(range(101),k=5)<\/code>\u00a0 will return a list of five non-unique integers between 0 and 100 (included). Because the requirement calls for uniqueness, this answer is incorrect. Note : the choices()<\/code> function has some additional optional weight parameters not discussed here.<\/p>\n
–> print(\"Selected numbers are: \", random.sample(range(101),k=5))<\/code><\/p>\n
Function sample(population<\/em>, k<\/em>)<\/code>\u00a0returns a k length list of unique elements chosen from the population sequence. So, random.sample(range(101),k=5)<\/code>\u00a0 will return a list of five unique integers between 0 and 100 (included). This is exactly what the requirement calls for and this is the correct answer. Note : the sample()<\/code> function has one additional optional parameter not discussed here.<\/strong><\/p>\n
More details on the random module available at https:\/\/docs.python.org\/3\/library\/random.html<\/a><\/p>\n
Try it yourself:<\/p>\n
    # Because we are dealing with random numbers here, your output may\r\n    # be different from the one below !\r\n    import random\r\n     \r\n    print(\"Selected numbers are: \", random.randrange(0,101,5))\r\n    # Selected numbers are:  55\r\n     \r\n    print(\"Selected numbers are: \", [random.randint(0,101) for x in range(5)])\r\n    # Selected numbers are:  [96, 46, 41, 87, 3]\r\n     \r\n    print(\"Selected numbers are: \", random.choices(range(101),k=5))\r\n    # Selected numbers are:  [49, 0, 99, 61, 41]\r\n     \r\n    print(\"Selected numbers are: \", random.sample(range(101),k=5))\r\n    # Selected numbers are:  [62, 92, 22, 47, 13]<\/pre>\n
 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
So what is a module? The Python Tutorial defines it as a file containing Python definitions and statements, which can be later imported and used when necessary.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[100],"tags":[],"_links":{"self":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5963"}],"collection":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/comments?post=5963"}],"version-history":[{"count":18,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5963\/revisions"}],"predecessor-version":[{"id":6284,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5963\/revisions\/6284"}],"wp:attachment":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/media?parent=5963"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/categories?post=5963"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/tags?post=5963"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}