What are the Modules in Python?

A file with the python code is a module. The code may take the form of specified variables, functions, or classes. The filename becomes a name for the module.
For instance, A “filename” will be the name of the module within this language. With module features, instead of writing everything within one file, you can split the code into multiple files.
What is the module for importing Python?
A file is called a python module. You have to import it using the import keyword to use the module. By importing the module, the function or variables present inside the file may be used in another file. This feature is available in other languages, such as Typescript, Python, JavaScript, Ruby, etc.
How to create a module in Python and import it?
We’re going to build a module now and import it into a separate file.
The flow for generating and importing the module is as shown in the screenshot:
To build a module in Python Online Training, follow the steps given.
The layout of the folder used in testing the code is as follows:
Modtest/ modtest/ modtest/
Test.py-Test.py
Display.py
Step 1)
Build a file and call it test.py
Phase 2)
Build a function called view message within testpy ()
Display message() def:
Phase 3)
Build another Display.py file now.
Step 4)
Import the moduletest.py file from inside display.py, as shown below:
Import Test ()
You don’t have to mention test.py when importing, but just the name of the file.
Step5)
You need to use the module name.function name. Then you can call the display message() function from test.py inside display.py.
Test.display message, for example ().
Import Test Test
Printing(test.display message())
Phase 6)
You will get the following output when you execute display.py:
Importing a Python class
We’ve seen a simple module with a purpose before. Here a class is generated and the class in another file is referenced.
The following is the folder structure for checking the code.
About myproj/
Car.py, pyy.py
Display.py
Build a file named Car.py with the code below:
Filename: Car.py.py Car.py
Car-class:
"BMW"BMW
"Z4"Z4
"2020"2020
Def init (self, brand name, model, year-manu):
Self.brand name = name of the brand
Model: self.model = model
Self.manu year = manu year
Details(self) def car:
Print(‘Car brand is’, name of self.brand)

Print(‘The year of car manufacture is’, self.manu-year)
Brand(self): def get Car brand(self):
Print(‘Car brand is’, name of self.brand)
Def get-Car-model(self): def def

There are brand name, model, and manual year attributes in the Car.py format. Car details(), get Car brand(), get Car model() are the functions specified within the class ().
Let us use the Car.py file now as a module in another file named display.py.
Filename: display.py, display.py
Importing a Car
Car-det = CarCarCar (“BMW”,“Z5”, 2020)
Printing(car det.brand name)
Printing(car det.car details())
Print(car det.get Car brand())
Print(car det.get Car model())
So using the Car module, we can access all the variables and functions from Car.py.
Using the import module from
Instead of importing the entire code, you can import only a small portion of the module, i.e. only the necessary functions and variable names from the module.
If you just want to import unique items, you can use the “from” keyword to import what you want.
The syntax, therefore is
Importing your feature name from the module, variables,… etc., etc.
The layout of the folder used in testing the code is as follows:
Modtest/ modtest/ modtest/
Test.py-Test.py
Display.py
There are 2 functions in Test.py, as shown:
Filename: test.py, test.py
Defdisplay message():
Display message1() def:
"All about Python!"All about Python!
Now you want a feature called display message(). You can directly access the function or variable you are importing, as shown below:
Name of the file: display.py.py
Display message from test import view message
The print(display message())
Now, if you use the display message1() feature, it will trigger an error that does not define the function as shown below:
Display message from test import view message
Print(message display1()))
Importing from the module all
Import allows you to import a complete module using import, followed by the name of the module, i.e. the filename or library you want to use.
Syntax:
Import module
Or by making use of
Import from module *
The layout of the folder used in testing the code is as follows:
Modtest/ modtest/ modtest/
Test.py-Test.py
Display.py
The code specifics inside test.py.py are as follows.
"Mumbai"Bombay
Defdisplay message():
Display message1() def:
"All about Python!"All about Python!
Use the module for importing
Using only the import module name, the module name must be prefixed to refer to the variables and functions within the module.
Example
Filename: display.py, display.py
Import Test
Printing(test.display message())
Print(test.display message1())) in print
Printing(test.my name)
Printing(test.my address)
The module name test is used within the module test to refer to the function and the variables.
Using importation
Let us see an example that uses import*. The functions and variables are directly accessible using import*, as seen in the example below:
Import from test*
The print(display message())
Print(message display1()))
Print(my name) Print
Print(my address) Print
Operation dir()
The dir() is a built-in-function in python. The dir() function returns all properties and methods, including the built-in properties of the given entity.
So when dir() is used on the module, it gives you the variables, the functions inside the module that are present.
On a module, here is a working example of dir(). Let’s import the car and assign it to dir() to see the performance. We have a class called Car.py.
The layout of the folder to evaluate the code will be as follows.
Test prop/test prop/test prop/
Car.py, pyy.py
Test.py-Test.py
Filename: Car.py.py Car.py
Car-class:
"BMW"BMW
"Z4"Z4
"2020"2020
Def init (self, brand name, model, year-manu):
Self.brand name = name of the brand
Model: self.model = model
Self.manu year = manu year
Details(self) def car:
Print(‘Car brand is’, name of self.brand)
Print(‘The year of car manufacture is’, self.manu-year)
Brand(self): def get Car brand(self):
Print(‘Car brand is’, name of self.brand)
Def get-Car-model(self): def def
Filename: test.py, test.py
Importing a Car
Class Contents = dir Dir Contents (Car)
Print(Contents-Class)
The output gives us the class name and all the functions specified in the Car.py program.
You can also try using dir() on the built-in Python module that is available. As shown in the example below, let us try the same on the JSON module. All properties and methods available in the JSON module will be shown.
Xml imports
Information of json = dir (json)
Printing(json details)
The Packages
A package is a directory containing all the modules that are specified within it. Your directory should have an init.pyfile to allow the Python interpreter to treat it as a package. The directory as a package is generated by init.py. Here is the kit layout that we are going to focus on.
My package is the name of your package. Create a directory called package/ in order to start working with the package. Develop three additional module1.py, module2.py, and module3.py files and describe the features as shown in the screenshot. The descriptions of module1.py, module2.py, and module3.py are given here. The1.py module
Func1():: def mod1 func1():
Print a Print (“Welcome to Module1 function1”)
Func2():: def mod1 func2():
Print a Print (“Welcome to Module1 function2”)
Func3():: def mod1 func3():
Print a Print (“Welcome to Module1 function3”)
The2.py module
Func1():: def mod2 func1():
Print a Print (“Welcome to Module2 function1”)
Func2():: def mod2 func2():
Print a Print (“Welcome to Module2 function2”)
Func3():: def mod2 func3():
Print a Print (“Welcome to Module2 function3”)
The3.py module
Func1():: def mod3 func1():
Print a Print (“Welcome to Module3 function1”)
Func2():: def mod3 func2():
Print a Print (“Welcome to Module3 function2”)
Def mod3 func3()::: def
Print a Print (“Welcome to Module3 function3”)
Packages that are ready for use.
Now, as shown below, call the package inside any of your files:test.py: In this case, mypackage.module1 is imported and the alias name is provided as mod1.
Similarly, you can use module2.py and module3.py from my kit for other modules.
Conclusion
You may get a brief idea about Python modules. You can learn more about Python modules and other topics through Python online training.

#learnpython #pythoncourse #pythononlinetraining #pythoncertification