Python 导入模块及示例
Anna Blake Python中有哪些模块？
模块是包含Python代码的文件。代码可以是变量、函数或类的形式。文件名即模块名。
例如，如果你的文件名是guru99.py，那么模块名就是guru99。通过模块功能，你可以将代码分解成不同的文件，而不是将所有内容都写在一个文件中。
什么是Python导入模块？
在Python中，一个文件被视为一个模块。要使用该模块，您必须使用import关键字导入它。文件中的函数或变量可以通过导入模块在另一个文件中使用。此功能在其他语言中也可用，如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 的文件，并包含以下代码
文件名： 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 文件中，有 attributes brand_name, model 和 manu_year。类中定义的函数是 car_details(), get_Car_brand(), get_Car_model()。
现在让我们在另一个名为 display.py 的文件中使用 Car.py 文件作为模块。
文件名： 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())
输出
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 中，有两个函数，如下所示
文件名： test.py
defdisplay_message(): return "Welcome to Guru99 Tutorials!" def display_message1(): return "All about Python!"
现在您需要 display_message() 函数。您可以直接访问正在导入的函数或变量，如下所示
文件名： display.py
from test import display_message print(display_message())
输出
Welcome to Guru99 Tutorials!
现在，如果您尝试使用函数 display_message1()，它将引发一个错误，提示该函数未定义，如下所示
from test import display_message print(display_message1())
输出
Traceback (most recent call last): File "display.py", line 3, in <module> print(display_message1()) Name Error: name 'display_message1' is not defined
导入模块中的所有内容
Import 允许您使用 import 后跟模块名（即文件名或要使用的库）来导入整个模块。
语法
Import module
或者通过使用
from module import *
用于测试代码的文件夹结构如下
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!"
使用 import 模块
仅使用 import 模块名，要引用模块内的变量和函数，必须以模块名作为前缀。
示例
文件名： display.py
Import test print(test.display_message()) print(test.display_message1()) print(test.my_name) print(test.my_address)
模块名 test 用于引用模块 test 内的函数和变量。
输出
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)
输出
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
文件名： 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)
文件名： 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)
输出
['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 使目录成为一个包。这是我们将要使用的包的布局。
包的名称是mypackage。要开始使用包，请创建一个名为 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")
package已准备就绪。现在，在任何文件中调用该包，如下所示：test.py
在这里，我们导入了 mypackage.module1 并为其指定了别名mod1。类似地，您可以从 mypackage 使用其他模块 module2.py 和 module3.py。
import mypackage.module1 as mod1 print(mod1.mod1_func1()) print(mod1.mod1_func2()) print(mod1.mod1_func2())
输出
Welcome to Module1 function1 None Welcome to Module1 function2 None Welcome to Module1 function2 None
我们仅展示了一个包含函数简单模块的包。根据您的项目，您还可以包含子包。子文件夹/包含具有已定义类的模块。
Python模块搜索路径
在执行过程中，当Python遇到import module name时，解释器会尝试定位该模块。它会在内置模块列表中搜索该模块。然后，在 sys.path 中定义的所有目录中搜索。
总而言之，解释器执行以下搜索来定位模块
- 在您当前的目录中。
- 在内置模块列表中
- 在 sys.path 目录中
您可以通过导入 sys 模块并打印 sys.path 来获取 sys.path 的详细信息。它将为您提供目录列表，如下所示
importsys print(sys.path)
输出
['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)
用于 test 模块的别名是 t。因此，可以通过别名 t 来引用 test.py 中的函数和变量。
输出
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
Python中的绝对导入和相对导入
您现在知道如何将一个文件作为模块导入到另一个文件中。现在让我们看看如何管理文件夹中的文件。文件夹中的文件可以通过绝对导入或相对导入来导入。
假设您的项目文件夹结构如下所示
根文件夹是 myproject/。它有两个子文件夹 package1 和 package2。
package1 文件夹有两个模块：module1.py 和 module2.py。
package2 文件夹包含一个类 myclass.py，一个子包 subpkg 包含 module3.py，最后是 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导入时，您需要在模块名称前添加一个点（.）。
如果模块在当前位置的上一级，则需要在模块名称前添加两个点（..）。
参照上面提到的文件夹结构图，我们有以下模块及其函数，我们需要引用它们。
- 在 module1.py 中，有一个名为 myfunc1 的函数。
- 在 module2.py 中，有一个名为 myfunc2 的函数。
- 在 module3.py 中，有一个名为 myfunc3 的函数。
- 在 module4.py 中，有一个名为 myfunc4 的函数。
要使用 myfunc1 函数，您需要如下导入
from .module1 import myfunc1
要使用 myfunc3 函数，您需要如下导入
from .subpkg.module3 import myfunc3
相对导入的优点
优点
- 使用相对导入很容易。
- 与绝对导入相比，从当前位置开始，导入可以缩短。
相对导入的缺点
缺点
- 使用相对导入时，很难追溯代码所在的位置
摘要
- Python中的导入可帮助您引用另一个文件中编写的代码，即函数/对象。它还用于导入使用 pip（Python 包管理器）安装的Python库/包，然后您需要在代码中使用它们。
- 导入功能在其他语言中也可用，如 TypeScript、JavaScript、Java、Ruby 等。
- Python中的模块是文件内的代码，例如（test.py）。在您的文件中，您可以定义自己的变量、函数或类。整个文件成为一个模块，并可以在另一个文件中导入以引用该代码。
- 通过模块功能，您可以将代码分解成不同的文件，而不是将所有内容都写在一个文件中。稍后，使用 import，您可以引用您需要的文件的代码。
- Python具有内置模块，也包括使用 python包管理器 (pip) 安装的外部库/包，例如 pandas、NumPy 等，这些都被称为模块。
- 您可以仅导入模块的一小部分，即仅从模块中导入所需的函数和变量名，而不是导入全部代码。
- 您还可以通过为其指定别名来将模块名转换为更短的形式。可以使用关键字实现别名。
- 包是包含所有已定义模块的目录。要使Python解释器将其视为一个包，您的目录应包含 __init__.py 文件。__init__.py 使目录成为一个包。这是我们将要使用的包的布局。
- 在执行过程中，当Python遇到import module name时，解释器会尝试定位该模块。它会在内置模块列表中搜索该模块。然后，在 sys.path 中定义的所有目录中搜索。
- 对于绝对导入，您需要从项目根文件夹开始添加模块的完整路径。
- 在相对导入中，要导入的模块相对于当前位置，即存在导入语句的位置。
