什么是模块？

在Python中，模块是一个包含Python定义和语句的文件。文件名就是模块名加上.py后缀。例如，一个名为my_module.py的文件就是一个名为my_module的模块。

导入模块

基本导入

1
2
3
4
import my_module

# 使用模块中的函数
my_module.say_hello()

导入特定函数

1
2
3
4
from my_module import say_hello

# 直接使用函数
say_hello()

导入所有函数

1
2
3
4
from my_module import *

# 直接使用模块中的所有函数
say_hello()

导入并别名

1
2
3
4
5
6
7
8
9
10
import my_module as mm

# 使用别名访问模块
mm.say_hello()

# 或者
from my_module import say_hello as sh

# 使用别名访问函数
sh()

模块的搜索路径

当你导入一个模块时，Python会按照以下顺序搜索模块：

  1. 当前目录
  2. PYTHONPATH环境变量中指定的目录
  3. 标准库目录
  4. 任何.pth文件中指定的目录

你可以通过sys.path查看Python的搜索路径：

1
2
import sys
print(sys.path)

什么是包？

包是一个包含多个模块的目录，它必须包含一个名为__init__.py的文件（可以是空文件）。包允许你组织模块为层次结构，避免命名冲突。

包的结构

1
2
3
4
5
6
7
my_package/
├── __init__.py
├── module1.py
├── module2.py
└── subpackage/
    ├── __init__.py
    └── module3.py

导入包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 导入整个包
import my_package

# 导入包中的模块
import my_package.module1

# 导入模块中的函数
from my_package.module1 import say_hello

# 导入子包
import my_package.subpackage

# 导入子包中的模块
import my_package.subpackage.module3

__init__.py文件

__init__.py文件在包被导入时执行，它可以用来：

  1. 初始化包的状态
  2. 定义包级别的变量和函数
  3. 控制从包中导入的内容

例如，你可以在__init__.py中定义：

1
2
3
4
5
# my_package/__init__.py
from .module1 import say_hello
from .module2 import say_goodbye

__all__ = ['say_hello', 'say_goodbye']

这样，当你执行from my_package import *时，只会导入__all__列表中指定的函数。

相对导入

在包内部，你可以使用相对导入来导入同一包中的其他模块：

1
2
3
4
# my_package/module2.py
from . import module1  # 导入同一包中的module1
from .module1 import say_hello  # 导入同一包中module1的say_hello函数
from .. import other_module  # 导入父包中的other_module

模块的执行

当你运行一个Python文件时，它会被当作主模块执行，其__name__属性会被设置为__main__。你可以使用这个特性来编写既可以作为模块导入，又可以直接执行的代码：

1
2
3
4
5
6
7
8
# my_module.py
def say_hello():
    print("Hello, world!")

if __name__ == "__main__":
    # 当直接运行此文件时执行
    say_hello()
    print("This is the main module")

标准库模块

Python提供了丰富的标准库模块，例如：

  • os：操作系统接口
  • sys：Python解释器相关
  • math：数学函数
  • random：随机数生成
  • datetime：日期和时间处理
  • json：JSON数据处理
  • csv：CSV文件处理
  • re：正则表达式

第三方模块

除了标准库，Python还有大量的第三方模块，你可以通过pip安装：

1
pip install requests

然后在代码中导入使用：

1
2
3
4
import requests

response = requests.get('https://www.example.com')
print(response.text)

实际应用示例

创建自己的模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# my_calculator.py
def add(a, b):
    """Add two numbers"""
    return a + b

def subtract(a, b):
    """Subtract two numbers"""
    return a - b

def multiply(a, b):
    """Multiply two numbers"""
    return a * b

def divide(a, b):
    """Divide two numbers"""
    if b == 0:
        raise ValueError("Division by zero")
    return a / b

if __name__ == "__main__":
    print(add(5, 3))
    print(subtract(5, 3))
    print(multiply(5, 3))
    print(divide(5, 3))

创建自己的包

1
2
3
4
my_calculator/
├── __init__.py
├── basic.py
└── advanced.py
1
2
3
4
5
# my_calculator/__init__.py
from .basic import add, subtract, multiply, divide
from .advanced import power, square_root

__all__ = ['add', 'subtract', 'multiply', 'divide', 'power', 'square_root']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# my_calculator/basic.py
def add(a, b):
    """Add two numbers"""
    return a + b

def subtract(a, b):
    """Subtract two numbers"""
    return a - b

def multiply(a, b):
    """Multiply two numbers"""
    return a * b

def divide(a, b):
    """Divide two numbers"""
    if b == 0:
        raise ValueError("Division by zero")
    return a / b
1
2
3
4
5
6
7
8
9
10
11
12
# my_calculator/advanced.py
import math

def power(a, b):
    """Raise a to the power of b"""
    return a ** b

def square_root(a):
    """Calculate the square root of a"""
    if a < 0:
        raise ValueError("Cannot calculate square root of a negative number")
    return math.sqrt(a)

使用自己的包

1
2
3
4
from my_calculator import add, power

print(add(5, 3))  # 输出: 8
print(power(2, 3))  # 输出: 8

总结

Python的模块和包是组织代码的重要工具，它们允许你将代码分解为更小、更可管理的部分。通过合理使用模块和包，你可以：

  1. 提高代码的可重用性
  2. 避免命名冲突
  3. 使代码结构更加清晰
  4. 便于维护和测试

通过本文的介绍，你应该已经掌握了Python模块和包的基本概念和使用方法。现在，你可以尝试创建自己的模块和包，组织你的Python代码，使其更加专业和可维护。