导入模块 Python 与例子
模块有哪些 Python?
模块是包含 Python 代码的文件。代码可以是变量、函数或定义类的形式。文件名成为模块名称。
例如,如果你的文件名是 guru99.py,模块名称将是 guru99. 使用模块功能,您可以将代码分成不同的文件,而不必将所有内容都写在一个文件中。
什么是 Python 导入模块?
在 Python 中,文件被视为模块。要使用该模块,您必须使用以下命令导入它: 进口 关键字。通过导入模块,文件中存在的函数或变量可在另一个文件中使用。此功能在其他语言中也可用,例如 typescript, Java脚本、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 中,有属性 brand_name、model 和 manu_year。类内部定义的函数是 car_details()、get_Car_brand()、get_Car_model()。
现在让我们将文件 Car.py 用作另一个名为 display.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 中有 2 个函数如下所示:
文件名: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 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!"
使用导入模块
只需使用导入模块名称,即可引用模块内的变量和函数,它必须以模块名称为前缀。
例如:
文件名: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 *
让我们看一个例子 进口 *。 运用 进口 *,函数和变量可直接访问,如下例所示:
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 中定义的所有函数。
您还可以尝试在内置模块上使用 dir() Python。让我们尝试同样的 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 将目录视为包。 以下是我们将要处理的包的布局。
该包的名称是 我的包裹。要开始使用该包,请创建一个名为 package/ 的目录。在该目录中,创建一个名为 __init__.py 的空文件。再创建 3 个文件 module1.py、module2.py 和 module3.py,并定义函数,如屏幕截图所示。以下是 module1.py、module2.py 和 module3.py 的详细信息
模块1.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")
模块2.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")
模块3.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")
这款 包已准备好使用。现在,在任意文件中调用该包,如下所示:test.py:
这里,导入了 mypackage.module1,并赋予了别名 模式1。 类似地,您可以使用我的包中的其他模块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 遇到 导入模块名称,解释器尝试定位模块。它在内置模块列表中搜索模块。 Later 总之,在 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)
用于测试模块的别名是 t 。因此,可以使用别名 t 引用 test.py 中的函数和变量。
输出:
Welcome to Guru99 Tutorials! All about Python! Guru99 Mumbai
绝对导入和相对导入 Python
现在您知道如何将一个文件作为模块导入另一个文件。现在让我们看看如何管理文件夹中的文件。可以使用绝对或相对导入来导入文件夹中的文件。
假设您有项目文件夹结构,如下所示:
根文件夹是我的项目/。它有两个子文件夹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()
使用绝对导入的优点和缺点
使用绝对导入的优点如下:
- 可以轻松追溯模块以进行代码检查。
- 易于使用且非常简单。
- 如果项目移动到不同的路径,导入仍然保持不变。
使用绝对导入的缺点
以下是使用绝对导入的缺点:
缺点:
- 如果模块嵌套,并且模块名称很长,则导入路径可能会变得很长。
使用相对导入
考虑到下面提到的相同文件夹结构,我们将看到如何使用相对导入来导入相同的内容。
在相对导入中,要导入的模块是相对于当前位置,即导入语句所在的位置。
句法
在相对导入中,使用以下方式导入时需要在模块名称前添加句点 (.) 在.
如果模块位于当前位置的上一级,则模块名称前会有 2 个句点 (..)。
参考上面提到的文件夹结构图,我们有以下模块及其功能,我们需要参考它们。
- 在module1.py中,有一个名为myfunc1的函数。
- 在module2.py中,有一个名为myfunc2的函数。
- 在module3.py中,有一个名为myfunc3的函数。
- 在module4.py中,有一个名为myfunc4的函数。
要使用函数 myfunc1,您需要按如下方式导入:
from .module1 import myfunc1
要使用函数 myfunc3,您需要按如下方式导入:
from .subpkg.module3 import myfunc3
相对导入的优点
优点:
- 使用相对导入进行操作非常容易。
- 从当前位置来看,与绝对导入相比,导入可以缩短。
相对导入的缺点
缺点:
- 使用相对导入,很难追溯代码所在的位置
总结
- 导入 Python 帮助您引用代码,即在另一个文件中编写的 .functions/objects。它还用于导入使用 pip(python 包管理器)安装的 python 库/包,然后在代码中使用。
- 导入功能在其他语言中也有用,比如 typescript, Java脚本、java、ruby等。
- python 中的模块是写在文件内的代码,例如 (test.py)。在文件中,您可以定义变量、函数或类。整个文件成为一个模块,可以导入另一个文件以引用代码。
- 使用模块功能,您可以将代码分成不同的文件,而不是将所有内容都写在一个文件中。 Later,使用import,你可以引用你需要的文件里面的代码。
- Python 有内置模块,还有使用以下方式安装的外部库/包 python 包管理器 (pip),例如 pandas、NumPy 等被称为模块。
- 您可以只导入模块的一小部分,即仅从模块中导入所需的函数和变量名,而不必导入完整的代码。
- 您还可以通过为模块名称赋予别名,将其转换为更短的形式。可以使用关键字来设置别名。
- 包是一个目录,其中包含所有定义的模块。要制作一个 Python 解释器将其视为一个包,您的目录应该有 __init.py 文件。init.py 将目录作为一个包。以下是我们将要处理的包的布局。
- 在执行过程中,当 python 遇到 导入模块名称,解释器尝试定位模块。它在内置模块列表中搜索模块。 Later 总之,在 sys.path 内定义的目录。
- 对于绝对导入,您需要从项目根文件夹添加模块的完整路径。
- 在相对导入中,要导入的模块是相对于当前位置,即导入语句所在的位置。