Python中有哪些模块？

模块是带有python代码的文件。 代码可以采用变量，函数或定义的类的形式。 文件名成为模块名称。

例如，如果文件名是guru99.py，则模块名称将是guru99。 借助模块功能（functionality），您可以将代码分成不同的文件，而无需将所有内容写入一个文件中。

什么是Python导入模块？

文件被视为python中的模块。 要使用该模块，必须使用import关键字将其导入。 通过导入模块，文件中存在的函数或变量可以在另一个文件中使用。 此功能（functionality ）可用于其他语言，例如typescript，JavaScript，java，ruby等。

如何在Python中创建和导入模块？

现在，我们将创建一个模块并将其导入另一个文件。

这是创建和导入模块的流程，如屏幕截图所示：

按照给定的步骤在python中创建模块。

用于测试代码的文件夹结构如下：

modtest/
	test.py
	display.py	

步骤1）创建一个文件并将其命名为test.py

步骤2）在test.py内部，创建一个名为display_message（）的函数

Def display_message():
    return "Welcome to Guru99 Tutorials!"

步骤3）现在创建另一个文件display.py。

步骤4）在display.py内部，导入moduletest.py文件，如下所示：

import test

导入时，您不必提及test.py，而只需提及文件名。

步骤5）

然后，您可以从display.py中的test.py调用函数display_message（），您需要使用module_name.function_name。

例如test.display_message（）。

Import test
print(test.display_message())

步骤6）

执行display.py时，将获得以下输出：

Welcome to Guru99 Tutorials!

用Python导入类

之前，我们已经看到了一个带有一个函数的简单模块。 这里将创建一个类并在另一个文件中引用该类。

测试代码的文件夹结构如下：

myproj/
	Car.py
	display.py

使用以下代码创建一个名为Car.py的文件：

Filename : Car.py

class Car:
	brand_name = "BMW"
	model = "Z4"
	manu_year = "2020"

	def __init__(self, brand_name, model, manu_year):
		self.brand_name = brand_name
		self.model = model
		self.manu_year = manu_year

	def car_details(self):
		print("Car brand is ", self.brand_name)
		print("Car model is ", self.model)
		print("Car manufacture year is ", self.manu_year)
			
			
	def get_Car_brand(self):
		print("Car brand is ", self.brand_name)

	def get_Car_model(self):
		print("Car model is ", self.model) 

在文件Car.py中，有属性brand_name，model和manu_year。 在类内部定义的函数是car_details（），get_Car_brand（），get_Car_model（）。

现在让我们将文件Car.py用作另一个名为display.py的文件中的模块。

Filename : display.py

import Car
car_det = Car.Car("BMW","Z5", 2020)
print(car_det.brand_name)
print(car_det.car_details())
print(car_det.get_Car_brand())
print(car_det.get_Car_model())

Output:

BMW
Car brand is  BMW
Car model is  Z5
Car manufacture year is  2020
Car brand is  BMW
Car model is  Z5

因此，我们可以使用Car模块从Car.py访问所有变量和函数。

使用from导入模块

您只能导入模块的一小部分，即仅导入模块中所需的函数和变量名称，而不是导入完整的代码。

当您只想导入特定内容时，可以使用“ from”关键字来导入想要的内容。

所以语法是

from  module import your function_name , variables,... etc.

用于测试代码的文件夹结构如下：

modtest/
	test.py
	display.py	

在test.py中，有2个函数，如下所示：

Filename : test.py

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
def display_message1():
	return "All about Python!"

现在，您需要display_message（）函数。 可以直接访问要导入的函数或变量，如下所示：

File Name : display.py

from test import display_message
print(display_message())

Output:

Welcome to Guru99 Tutorials!

现在，如果您碰巧使用了函数display_message1（），它将引发一个错误，该函数未按如下所示进行定义：

from test import display_message
print(display_message1())

Output:

Traceback (most recent call last):
File "display.py", line 3, in <module>
print(display_message1())
Name Error: name 'display_message1' is not defined

从模块导入所有内容

导入允许您通过使用导入后跟模块名称（即要使用的文件名或库）来导入整个模块。

语法：

Import module

或使用

from module import *

用于测试代码的文件夹结构如下：

以下是test.py中的代码详细信息modtest/
	test.py
	display.py	

以下是test.py中的代码详细信息

my_name = "Guru99"
my_address = "Mumbai"

defdisplay_message():
	return "Welcome to Guru99 Tutorials!"
	
	
def display_message1():
	return "All about Python!"

使用导入模块

仅使用导入模块名称来引用模块内部的变量和函数，它必须以模块名称作为前缀。

例

display.py

Import test
print(test.display_message())
print(test.display_message1())
print(test.my_name)
print(test.my_address)

模块名称测试用于引用模块测试中的函数和变量。

输出：

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

使用import *

让我们来看一个使用import *的示例。 使用import *，可以直接访问函数和变量，如下例所示：

from test import *

print(display_message())
print(display_message1())
print(my_name)
print(my_address)

Output:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

dir（）函数

dir（）是python中的内置函数。 dir（）返回所有属性和方法，包括给定对象的内置属性。

因此，在模块上使用dir（）时，它将为您提供模块中存在的变量，函数。

这是模块上dir（）的工作示例。 我们有一个名为Car.py的类，让我们导入Car并分配给dir（）来查看输出。

用于测试代码的文件夹结构如下：

test prop/
	Car.py
	test.py	

Filename: Car.py

class Car:
	brand_name = "BMW"
	model = "Z4"
	manu_year = "2020"

	def __init__(self, brand_name, model, manu_year):
		self.brand_name = brand_name
		self.model = model
		self.manu_year = manu_year

	def car_details(self):
		print("Car brand is ", self.brand_name)
		print("Car model is ", self.model)
		print("Car manufacture year is ", self.manu_year)
			
			
	def get_Car_brand(self):
		print("Car brand is ", self.brand_name)

	def get_Car_model(self):
		print("Car model is ", self.model) 

Filename: test.py

import Car

class_contents = dir(Car)
print(class_contents)

输出为我们提供了类的名称以及Car.py中定义的所有函数。

您也可以尝试在Python中提供的内置模块上使用dir（）。 让我们在json模块上尝试相同的方法，如下例所示。 它将显示json模块中可用的所有属性和方法。

Import json
json_details = dir(json)
print(json_details)

Output:

['JSONDecodeError', 'JSONDecoder', 'JSONEncoder', '__all__', '__author__', '__bu
iltins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__pac
kage__', '__path__', '__spec__', '__version__', '_default_decoder', '_default_en
coder', 'codecs', 'decoder', 'detect_encoding', 'dump', 'dumps', 'encoder', 'loa
d', 'loads', 'scanner']

包

包是一个目录，其中定义了所有模块。 为了使Python解释器将其视为一个包，您的目录应具有init.py文件。 init.py将目录打包。 这是我们要处理的程序包的布局。

包的名字是my package。 要开始使用软件包，请创建一个名为package /的目录。 在目录内，创建一个名为__init__.py的空文件。 再创建3个文件module1.py，module2.py和module3.py，并定义函数，如屏幕快照所示。 以下是module1.py，module2.py和module3.py的详细信息

module1.py

def mod1_func1():
print("Welcome to Module1 function1")

def mod1_func2():
print("Welcome to Module1 function2")

def mod1_func3():
print("Welcome to Module1 function3")

module2.py

def mod2_func1():
print("Welcome to Module2 function1")

def mod2_func2():
print("Welcome to Module2 function2")

def mod2_func3():
print("Welcome to Module2 function3")

module3.py

def mod3_func1():
print("Welcome to Module3 function1")

def mod3_func2():
print("Welcome to Module3 function2")

def mod3_func3():
print("Welcome to Module3 function3")

这些packages 可以使用了。 现在，在您的任何文件内调用包，如下所示：test.py：

在这里，导入了mypackage.module1，并为其指定了别名为mod1。 同样，您可以从我的软件包中使用其他模块module2.py和module3.py。

import mypackage.module1 as mod1

print(mod1.mod1_func1())
print(mod1.mod1_func2())
print(mod1.mod1_func2())

Output:

Welcome to Module1 function1
None
Welcome to Module1 function2
None
Welcome to Module1 function2
None

我们刚刚用一个简单的模块演示了该程序包，其中包含函数。 根据您的项目，您还可以打包带有sub-packages。 子文件夹/具有定义了类的模块。

Python模块搜索路径

在执行期间，当python遇到导入模块名称时，解释器将尝试查找模块。 它在内置模块列表中搜索模块。 稍后，将在sys.path中定义目录。

综上所述，解释器进行以下搜索以找到模块：

• 在当前目录中。
• 在内置模块列表中
• 在sys.path目录中

您可以通过导入sys模块并打印sys.path来获取sys.path的详细信息。 它会为您提供目录列表，如下所示：

importsys
print(sys.path)

Output:

['Python Latest\\task2', 'Users\\AppData\\Local\\Programs\\Python\
\Python37\\python37.zip', 'Users\\AppData\\Local\\Programs\\Python\\P
ython37\\DLLs']

您还可以根据需要修改路径并保留目录。

在导入中使用模块别名

您也可以通过为其指定别名来将模块名称转换为较短的格式。 可以使用关键字完成别名。

句法：

import filename as alias name

用于测试代码的文件夹结构如下：

Mod test/
	test.py
	display.py	

以下是test.py中的代码

my_name = "Guru99"
my_address = "Mumbai"

def display_message():
	return "Welcome to Guru99 Tutorials!"	
	
def display_message1():
	return "All about Python!"

现在将在display.py中为test.py使用别名

Import test as t

print(t.display_message())
print(t.display_message1())
print(t.my_name)
print(t.my_address)

用于测试模块的别名为t。 因此，可以使用别名t引用来自test.py的函数和变量。

Output:

Welcome to Guru99 Tutorials!
All about Python!
Guru99
Mumbai

Python中的绝对和相对导入

您现在知道了如何将文件作为模块导入另一个文件中。 现在让我们看看如何管理文件夹中的可用文件。 可以使用绝对导入或相对导入来导入文件夹中的文件。

考虑您具有项目文件夹结构，如下所示：

根文件夹是我的项目/。 它具有两个子文件夹package1和package2。

文件夹package1有两个模块，module1.py和module2.py。

文件夹package2具有一个类myclass.py，带有module3.py的子包subpkg和最后一个module4.py。

• 在module1.py中，有一个名为myfunc1的函数。
• 在module2.py中，有一个名为myfunc2的函数。
• 在module3.py中，有一个名为myfunc3的函数。
• 在module4.py中，有一个名为myfunc4的函数。

使用绝对导入

对于绝对导入，您需要直接在项目根文件夹中添加模块的整个路径。

现在让我们看看如何使用绝对导入来引用每个模块中存在的函数。

要使用函数myfunc1，您需要导入如下：

from package1.module1  import  myfunc1
or
from package1 import module1
module1.myfunc1()  

要使用函数myfunc3，您需要导入如下：

from package1.subpkg.module3  import  myfunc3
or
from package1.subpkg import module3
module3.myfunc3()  

使用绝对导入的优点和缺点

使用绝对导入的优点如下：

• 追溯模块进行代码检查变得很容易。
• 易于使用，非常简单。
• 如果项目移至其他路径，则导入仍将保持不变。

使用绝对导入的缺点

这是使用绝对导入的缺点：

缺点：

• 导入路径可能很长，以防万一，模块是嵌套的，并且模块的名称很长。

使用相对导入

考虑以下相同的文件夹结构，我们将看到如何使用相对导入来导入相同的文件夹。

在相对导入中，要导入的模块相对于当前位置，即存在导入语句的位置。

句法：

在相对导入中，使用from导入时，需要在模块名称之前添加句点（。）。

如果模块位于当前位置的上一层，它将在模块名称之前2个句点（..）。

参考上面提到的文件夹结构图，我们有以下模块及其函数，需要参考。

• 在module1.py中，有一个名为myfunc1的函数。
• 在module2.py中，有一个名为myfunc2的函数。
• 在module3.py中，有一个名为myfunc3的函数。
• 在module4.py中，有一个名为myfunc4的函数。

要使用函数myfunc1，您需要导入如下：

from  .module1  import  myfunc1

要使用函数myfunc3，您需要导入如下：

from  .subpkg.module3  import  myfunc3

相对Imports的优势

优点：

• 使用相对导入很容易。
• 从当前位置开始，与绝对Imports相比，进口可以缩短。

相对Imports的劣势

缺点：

• 使用相对导入，很难追溯到代码所在的位置

摘要：

• 使用Python导入可以帮助您引用代码，即在另一个文件中编写的.functions / objects。它还用于导入使用pip（python软件包管理器）安装的python库/软件包，然后需要在代码中使用。
• 导入功能（functionality ）支持其他语言，例如typescript，JavaScript，java，ruby等。
• python模块是写在文件内部的代码，例如（test.py）。在文件内部，可以定义变量，函数或类。整个文件成为一个模块，可以导入另一个文件中以引用该代码。
• 借助模块功能（functionality），您可以将代码分成不同的文件，而无需将所有内容写入一个文件中。以后，使用导入，您可以引用所需文件中的代码。
• Python具有其内置模块，并且使用python包管理器（pip）安装的外部库/包（例如pandas，NumPy等）也称为模块。
• 您只能导入模块的一小部分，即仅导入模块中所需的函数和变量名，而不是导入完整的代码。
• 您也可以通过为其指定别名来将模块名称转换为较短的格式。可以使用关键字完成别名。
• 包是一个目录，其中定义了所有模块。为了使Python解释器将其视为一个包，您的目录应具有__init.pyfile。 init.py将目录打包。这是我们要处理的程序包的布局。
• 在执行期间，当python遇到导入模块名称时，解释器将尝试查找模块。它在内置模块列表中搜索模块。稍后，将在sys.path中定义目录。
• 对于绝对导入，您需要直接在项目根文件夹中添加模块的整个路径。
• 在相对导入中，要导入的模块相对于当前位置，即存在导入语句的位置。