【100天精通python】Day14：python 标准模块，自定义模块

目录

[1 python 模块](#1 python 模块)

[2 标准模块](#2 标准模块)

[2.1 常见的标准模块](#2.1 常见的标准模块)

[2.2 标准模块的导入](#2.2 标准模块的导入)

[3 自定义模块](#3 自定义模块)

[3.1 创建模块](#3.1 创建模块)

[3.2 导入模块](#3.2 导入模块)

[3.2.1 使用import 语句导入模块](#3.2.1 使用import 语句导入模块)

[3.2.2 使用from... import 语句导入模块](#3.2.2 使用from... import 语句导入模块)

[3.2.3 导入模块的全部定义](#3.2.3 导入模块的全部定义)

[3.2.4 导入两个包含同名函数的模块](#3.2.4 导入两个包含同名函数的模块)

---

模块与函数的关系

1 python 模块

在Python中，模块可以分为以下几种类型：

1. 标准模块（Built-in Modules）：这些是Python解释器内置的模块，无需额外安装即可使用。例如，math、random、datetime等模块就是标准模块。

2. 第三方模块（Third-party Modules）：这些模块是由其他开发者或组织创建并发布的，可以通过pip等包管理工具安装。第三方模块提供了丰富的功能和工具，帮助我们更轻松地开发应用程序。例如，requests用于进行网络请求，numpy用于数值计算，pandas用于数据分析等。

3. 自定义模块（Custom Modules）：这些模块是开发者自己编写的，用于封装功能和代码重用。我们可以将一组相关的函数、类或变量放在一个.py文件中，并通过import语句在其他地方重复使用这些代码。

4. 包（Packages）：包是一种特殊的模块，它是由一组相关的模块和子包组成的目录结构。包允许我们组织代码，使得项目更加模块化和结构化。包含__init__.py文件的目录被视为一个包。我们可以通过点号语法从包中导入模块和子包。

总结：Python中的模块类型包括标准模块、第三方模块、自定义模块和包。这些模块使得Python具有丰富的功能和灵活性，能够满足不同类型的应用程序开发需求。

模块是一个包含Python代码的文件。模块可以包含函数、变量和类等定义，以及执行代码的语句。它们用于将代码组织成可重用的单元，使代码更加模块化和易于维护。

Python中的每个文件都可以被视为一个模块，文件名即为模块名，不过需要注意的是，文件名不能以数字开头，并且不能包含特殊字符如空格等。模块的后缀通常是.py。

模块可以通过import语句导入到其他Python程序中使用。导入模块后，可以使用模块中定义的函数、变量和类等内容。

下面是一个简单的示例：

假设我们有一个名为mymodule.py的模块文件，其中包含以下代码：

# mymodule.py

def say_hello():
    print("Hello, I am from mymodule!")

name = "John"

现在，我们可以在另一个Python文件中导入并使用这个模块：

# main.py

import mymodule

mymodule.say_hello()
print("Name:", mymodule.name)

当我们运行main.py，输出将是：

Hello, I am from mymodule!
Name: John

在这个例子中，我们首先使用import mymodule语句导入了mymodule模块。然后，我们调用了mymodule.say_hello()函数和访问了mymodule.name变量。这样，我们就可以在main.py中重复使用mymodule.py中定义的代码，实现了模块化的编程。

2 标准模块

在Python中，标准模块是指Python语言自带的、不需要额外安装就可以直接使用的模块。这些模块包含了各种功能，可以在不同的应用场景下使用。

这些模块提供了各种功能，包括文件I/O、网络通信、日期和时间处理、数学运算、数据结构、正则表达式、多线程、数据库连接等等。标准库是Python开发者常用的工具集，因为它们已经内置在Python中，无需额外安装，可以直接在Python程序中使用。

2.1 常见的标准模块

以下是Python中一些常用的标准库模块：

1. os：提供与操作系统交互的功能，比如文件和目录操作。

2. sys：提供与Python解释器交互的功能，比如命令行参数、模块导入等。

3. math：提供数学运算相关的函数和常量。

4. datetime：处理日期和时间的模块。

5. random：生成随机数的模块。

6. re：提供正则表达式的功能，用于字符串匹配和替换。

7. json：用于JSON数据的编码和解码。

8. urllib：用于发送HTTP请求和处理URL。

9. socket：用于网络编程，实现套接字通信。

10. sqlite3：用于连接和操作SQLite数据库。

11. csv：用于读写CSV文件。

12. multiprocessing：用于实现多进程编程。

这只是标准库中的一小部分，Python还有许多其他有用的标准库模块，可以根据具体需求进行查阅和使用。要使用标准库中的模块，只需使用import语句导入相应的模块即可，例如：import os。然后就可以通过os来调用其中的函数和变量，例如：os.listdir()。

2.2 标准模块的导入

在Python中，标准模块是指随着Python解释器一起安装的模块，无需额外安装即可使用。这些模块包含了Python的核心功能和许多常用的工具和库。要导入Python标准模块，只需使用import语句后跟模块的名称。

以下是一些常用的Python标准模块的导入示例：

# 导入数学相关的标准模块
import math

# 使用数学模块中的函数
print(math.sqrt(25))  # 输出：5.0

# 导入日期和时间相关的标准模块
import datetime

# 获取当前日期和时间
current_time = datetime.datetime.now()
print(current_time)  # 输出：2023-07-11 15:30:00.123456

# 导入随机数生成的标准模块
import random

# 生成一个随机整数
random_number = random.randint(1, 100)
print(random_number)

# 导入操作系统相关的标准模块
import os

# 获取当前工作目录
current_directory = os.getcwd()
print(current_directory)

# 导入正则表达式相关的标准模块
import re

# 使用正则表达式匹配字符串
pattern = r'\d+'
text = 'The price is $50'
match = re.search(pattern, text)
print(match.group())  # 输出：50

通过导入标准模块，我们可以轻松地访问和使用其中提供的功能和工具。这些模块在Python的安装中已经包含，因此无需另外安装即可使用。在编写Python程序时，标准模块是非常有用且常用的工具。

3 自定义模块

自定义模块是指在Python中创建自己的模块，以便在不同的程序中重复使用代码。通过将相关函数、类或变量封装在一个模块中，可以提高代码的可维护性和重用性。

要创建自定义模块，可以按照以下步骤进行：

1. 创建一个Python文件，并在文件中编写相关的函数、类或变量。

2. 在需要使用该模块的程序中，使用import语句导入自定义模块。

3. 调用模块中定义的函数、类或变量，以实现代码的功能。

下面是一个简单的例子来演示如何创建和使用自定义模块：

3.1 创建模块

假设我们创建一个名为math_operations.py的自定义模块，其中包含一些数学运算函数：

# math_operations.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b != 0:
        return a / b
    else:
        raise ValueError("Cannot divide by zero.")

现在，我们可以在另一个Python文件中使用这个自定义模块：

3.2 导入模块

3.2.1 使用import 语句导入模块

# main.py

# 导入自定义模块
import math_operations

# 使用模块中的函数
result = math_operations.add(5, 3)
print("5 + 3 =", result)

result = math_operations.subtract(10, 4)
print("10 - 4 =", result)

result = math_operations.multiply(2, 6)
print("2 * 6 =", result)

result = math_operations.divide(10, 2)
print("10 / 2 =", result)

执行main.py，将会输出：

5 + 3 = 8
10 - 4 = 6
2 * 6 = 12
10 / 2 = 5.0

这样，我们就成功地在Python程序中使用了自定义模块math_operations.py中定义的函数。自定义模块可以在多个程序中共享和重复使用，使得代码更加整洁和易于维护。

3.2.2 使用from... import 语句导入模块

使用from ... import语句是Python中导入模块的一种方式。它允许直接从模块中导入指定的函数、类或变量，而不需要在使用时添加模块名作为前缀。

语法格式为：

from module_name import name1, name2, ...

下面以前面提到的math_operations.py为例，演示如何使用from ... import语句导入模块中的函数：

# 导入模块中的特定函数
from math_operations import add, subtract

result = add(5, 3)
print("5 + 3 =", result)

result = subtract(10, 4)
print("10 - 4 =", result)

执行上述代码，将会输出：

5 + 3 = 8
10 - 4 = 6

在此例中，我们只导入了math_operations.py模块中的add和subtract函数，因此在使用时无需添加模块名作为前缀。可以根据需要选择导入模块中的特定函数、类或变量，以提高代码的可读性和简洁性。

3.2.3 导入模块的全部定义

如果希望导入一个模块的全部定义（函数、类、变量等），可以使用

from ... import *

这将导入模块中的所有定义，使得你在使用时无需添加模块名作为前缀。

然而，尽管使用import *可以方便地使用模块中的所有定义，但它并不是一个推荐的做法。这是因为这样可能会导致命名冲突和代码可读性降低，特别是当你导入多个模块时。

例如，假设你有一个名为math_operations_sample.py的模块，其中定义了一个函数add和一个变量PI：

# math_operations_sample.py

def add(a, b):
    return a + b

PI = 3.1415926

若你使用from math_operations_sample import *来导入该模块：

from math_operations_sample import *

result = add(5, 3)
print("5 + 3 =", result)

print("PI =", PI)

执行上述代码，会输出：

5 + 3 = 8
PI = 3.1415926

虽然使用from ... import *能够直接使用模块中的所有定义，但这样的做法会造成潜在的问题。例如，如果你在另一个模块中math_operations也定义了一个名为add的函数，那么导入的math_operations_sample模块中的add函数将会覆盖掉原有定义，导致代码行为不可预测。

因此，为了避免潜在的命名冲突，推荐的做法是使用import module_name来导入模块，并在使用时使用模块名作为前缀来访问模块中的定义。如：

import math_operations

result = math_operations.add(5, 3)
print("5 + 3 =", result)

print("PI =", math_operations.PI)

3.2.4 导入两个包含同名函数的模块

当你导入两个包含同名函数的模块时，为了避免命名冲突，可以使用不同的别名来区分它们。Python提供了as关键字，允许你给导入的模块或函数指定别名。

假设有两个模块，分别是module1.py和module2.py，它们都定义了一个名为add的函数：

# module1.py

def add(a, b):
    return a + b

# module2.py

def add(a, b):
    return a * b

现在，你可以通过给导入的模块指定别名来导入它们：

import module1 as m1
import module2 as m2

result1 = m1.add(5, 3)
print("Module 1: 5 + 3 =", result1)

result2 = m2.add(5, 3)
print("Module 2: 5 * 3 =", result2)

执行上述代码，会输出

Module 1: 5 + 3 = 8
Module 2: 5 * 3 = 15

通过给导入的模块指定别名，你可以清晰地区分它们，避免了命名冲突，使得代码更加可读和易于维护。