8.1 Modules

• >Is a file with .py extension containing Python code, they are also called scripts. Simply write some Python code in a file and save the file as .py extension, your module is ready.
• >When you import a module, Python looks in a sequence given below:
  1. >Local Directory: It is where the current .py file is located.
  2. >PYTHONPATH: It is a path to a directory which can be set using this environment variable. It can be used to set additional Python directory paths which Python can use to find modules/packages, it is provided through the command line. eg "PYTHONPATH=/path-to/some-dir".
  3. >Python Installation Directory: This is where your Python is currently installed, it can be viewed with "which python" command from the command line.
     Note: This also means that any module with a repeating name will be given priority according to this sequence.
• >As Python is a Interpreted Language, each time a program is run the .py files are compiled from source code to bytecode. To speed this up, when a .py file is imported the Python interpreter creates a .pyc (byte-compiled version of .py files) file in the "__pycache__" folder (if Python has permission to write files in that directory). So next time Python can directly access the .pyc file instead of re-compiling if that file hasn't been modified. These byte-compiled files are platform-independent.
• >Use the built-in function dir() to find variables/functions/classes inside a module, as modules once imported are objects too. Each imported module's object contains a special variable named __name__ which is set to the module's name. But the current module which is run by the user has a __name__ variable set to "__main__". This helps a programmer to not invoke the script while importing it in another module if they don't intend to. This is similar to the main() function's behaviour in C/C++ language.
• >Check the List of built-in modules available in Python.
• >Importing a module.

# Modules can be imported anywhere in Python, there is no restriction
# but for readability they are imported at the beginning itself
# Eg. 'math' is built-in module, import it using the 'import' keyword
# the 'import' statement creates a module object in this namespace
# any module is only imported once in a program, re-importing has no effect
import math

# Accessing a function from 'math' object any functions/classes/variables
# of 'math' module now can be accessed using '.' operator
my_var = math.sqrt(8)

## Import any specifics from the module using 'from' keyword,
# here we're importing a function
from math import sqrt

# Note: Doing stared import (Eg. from math import *) is not usually recommended
# as it might add name collisions
my_var = sqrt(16)


## Make an import with different access name to avoid name collision
def math(num):
  return pow(num, 2)

# Import a module with different name using 'as' followed by a new name
import math as maths

# So now accessing a function from 'math' module would be
print(maths.sqrt(4))  # 2.0
# And our 'math' function will be
print(math(2))  # 4


## Check the functions/classes/variables of a module using 'dir()'
print(dir(math))

• >Now let's create and import our own module, save this below module as "sample.py" or anything you prefer (but change the import name if so in the next module).

a = 42
def my_fun():
  print("This function was called")


## Check if this module is the executing module
if __name__ == "__main__":
  # do something here
  print("sample module was ran")
  my_fun()

• >"__main__" in Python, save this module as "my_module.py" and run this module.

## Notice: Now importing 'sample' module will not call 'my_fun()'
# as it is only called if '__name__' equals '__main__',
# which is only when running from that module i.e running 'sample.py' script
import sample

print(dir(sample))  # ['__builtins__', '__name__',...]
print(sample.__name__)  # sample
# access variable from 'sample' module
print(sample.a)  # 42

# check '__name__' variable of current module
print(__name__)  # __main__


## Now try doing otherwise, add 'import my_module' in 'sample.py' and
# check the if this print method is called, check what is printed
if __name__ == "__main__":
  # add code here which you don't want to be invoked unless this script is ran
  print("my_module was ran")