In Python, you can save the definitions of functions in a file called a module. It is possible to import module definitions into your program file.
We can save our Python functions in their own file, which is a module, then the module is imported to the main program.
To have the module available within the current program, an import statement is used to transfer it to the running program.
When separate files are used to store functions, the program’s code details are hidden and a higher level of logic for the program code is attained.
Storing your functions in different files has the following advantages:
- The functions can be re-used in other different programs.
- It is easier to share the files in which the functions are stored, without having to share an entire program.
- Through importing functions, one is able to use function libraries that other programmers have written.
We can import these modules in different ways, such as:
- Importing an entire module.
- Importing specific functions.
asto give a function an alias.
asto give a module an alias.
- Importing all functions in a module.
In order to follow through with this article, a clear understanding of Python modules is required.
Importing an entire module
The first step is to create a module, which is a file that has an ending of
.py and containing the program you want to import to your main program.
Below is a module with the function
This is the file
def make_bread(height, *garnish); """ summarrize the bread we are about to make""" print("\Making a "+ str(height) + "-inch bread with the following garnish :") for garnish in garnishes; print("-" + garnish)
We can have another separate file
making_breads.py whose storage directory is similar to that of
bread.py. The file
make_breads.py imports the module and calls the file
This is the file,
import bread bread.make_bread(11,'basil') bread.make_bread(14,'garlic flakes', 'oregano', 'rolled oat flakes')
A command from the line
import bread opens and copys all the functions from the program in the file
Abstraction of the data from the user takes place such that one does not understand what happens in the background.
All one needs to know is that any function that is defined in
bread.py will be made available in the file
We call a function from an imported module by entering the module name imported and the function name separated by a dot.
The result of the program will be similar whether a module is imported or not.
The output should be as follows:
Making a 11-inch bread with the following garnish: -basil
Making a 14-inch bread with the following garnish: -garlic flakes -oregano -rolled oat flakes
Syntax of importing an entire module:
import module_name module_name.name_of_function()
All functions within the module name are imported without an exception.
Importing specific function
You can as also import just a specific function from a module.
The syntax when importing a specific function:
from module_name import name_of_function
Importing various specific functions from a module is made possible by separating the function’s name with a comma:
from module_name import first-function, second_function, third_function
From the file
make_bread.py we import the specific functions we are using which are:
from bread import make_bread make_bread(11,'basil') make_bread(14,'garlic flakes', 'oregano', 'rolled oat flakes')
Note: Anytime we call the function using this syntax, we do not use the dot notation since the function was explicitly imported in the import declaration. We only call it by name any time we need to use the function.
This is a better option when you are not required to import an entire module and all the functions won’t be put into use.
Giving a function an alias using ‘as’
An alias is used mainly when the function name is too long or when the function name is similar to another name in the program.
If in any of the instances occur, we use an alias that is an alternate name similar to that of the function.
The general syntax of using an alias is as shown below:
from module_name import function_name as fn
From the function
make_bread() we give an alias
mb(). We use
mb as the function name since the keyword renames the function to the alias.
from bread import make_bread as mb mb(11,'basil') mb(14,'garlic flakes', 'oregano', 'rolled oat flakes')
The import statement renames the function name to the alias. In this case, the function
make_bread() is renamed as
Anytime we need to call the function
make_bread() we can use the alias
mb() and the program will still run the function
The alias avoids any confusion with another function that might be written in the program as
Giving a module an alias using ‘as’
An alias of a module can be given based on the module name. Providing an alias for a module makes it easier to call the module’s function.
The syntax when giving a module an alias:
import name_of_module as nm
We can call
bread.make_bread() more precisely as
b.make_bread() as shown in the example below:
import bread as b b.make_bread(11,'basil') b.make_bread(14,'garlic flakes', 'oregano', 'rolled oat flakes')
Giving an alias to a module does not change the function names, instead they retain their original names.
Using the alias name for the module is not only concise but also enables you to concentrate on the informative names of the function, thus, redirecting your attention from the name of the module.
These function names will tell you what the function does, to enable the readability of your code rather than using the full name of the module.
Importing all functions in a module
To import all the functions in a module we use the asterisk
(*) in the import statement. The asterisk gives a command that all the function should be copied into the program file.
The syntax of importing all functions in a module is as follows:
from name_of_module import *
Functions can be called without using the dot notation.
In instances where we are working with large modules that you did not write, it is not appropriate to use this approach.
from bread import * make_bread(11,'basil') make_bread(14,'garlic flakes', 'oregano', 'rolled oat flakes')
If several functions are saved under the same name, the code will not import the functions separately. Instead, it will overwrite all the functions.
Errors and the unexpected output may result due to the matching of the function names and other existing names in the function.
In the tutorial above we have been able to look at how easy and important it is to import functions and modules.
We have looked at:
- Importing an entire module that is an entire module and all its properties.
- Importing a specific function, when that is the only function that is needed.
asto give a function an alias, that is giving a shorter or simpler name for the function and using as to implement that change.
asto give a module an alias we used the alias to simplify the module name or make it different.
- Importing all functions in a module we imported all the functions in a module regardless of whether they are being used and we use an asterik.
I hope you find this tutorial helpful!
Peer Review Contributions by: Monica Masae