使用示例在 Python 中导入模块

Python中有哪些模块？

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

例如，如果您的文件名为 guru99.py，则模块名称将为 guru99 .使用模块功能，您可以将代码分成不同的文件，而不是将所有内容都写在一个文件中。

在本教程中，您将学习：

Python中有哪些模块？
Python 导入模块
如何在 Python 中创建和导入模块？
在 Python 中导入类
使用 from 导入模块
从模块中导入所有内容
使用导入模块
使用导入 *
dir() 函数
包
PythonModuleSearchPath
在导入中使用模块别名
Python 中的绝对和相对导入
使用AbsoluteImports
使用RelativeImports

什么是 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 中，有属性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 后跟模块名称来导入完整的模块，即要使用的文件名或库。

语法：

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 module name，要引用模块内部的变量和函数，必须以模块名作为前缀。

例子

文件名：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 * ，函数和变量可以直接访问，如下例所示：

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 将目录作为一个包。这是我们将要处理的包的布局。

包的名字是我的包 .要开始使用包，请创建一个名为 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")

包准备好使用。现在调用任何文件中的包，如下所示：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())

输出：

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)

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

输出：

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

相对导入的优点

优点：

使用相对导入很容易。
从当前位置，与绝对导入相比，导入可以缩短。

相对导入的缺点

缺点：

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

总结：

Python 中的导入可帮助您引用代码，即编写在另一个文件中的 .functions/objects。它还用于导入使用 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 中定义的目录。
对于绝对导入，您需要直接从项目根文件夹添加模块的整个路径。
在相对导入中，要导入的模块相对于当前位置，即导入语句所在的位置。

Python 中的多线程示例：在 Python 中学习 GIL Python 调试器：毫不费力地提高您的调试技能

Python