第十二章模块和包

上一关，我们介绍了类和对象：

这一关，我们将为大家介绍模块和包：

在开发大型软件时，随着代码写的越来越多，如果将所有的代码都放在一个文件里，势必为以后的维护带来很大的困难。正如仓颉造字一样，仓颉是黄帝的史官，用祖传结绳记事的老办法记载史实。时间一长，那些大大小小，奇形怪状的绳结都记了些什么，连他自己也没法辨认了。于是，仓颉开始想新的办法，用什么方式可以帮助大家分辨清不同的事物，在仓颉的努力下，他创造了文字，解决了这个问题。而在 Python 中，为了编写易于维护的代码，我们会将代码拆分放到不同的文件里，这样每个文件包含的代码相对就会减少。在 Python 中，一个 .py 文件称为一个模块（Module）。

模块化能够带来很多好处：

简化问题求解

将所有代码放在一个文件中时，我们需要考虑的是整个问题的求解，代码实现的复杂度大大增加。将代码拆分放在多个文件中时，每个文件只需要对子问题进行求解，代码实现的复杂度大大降低。

提高代码可维护性

由于解决不同子问题的代码放在了不同的文件中，代码之间的依赖性小，其中一个文件的修改对其他文件产生影响的几率大大降低。维护人员可以对其中一个文件的代码进行修改，而不必熟悉其他文件中的代码。由于每个文件专注于解决一个子问题，文件之间的并行开发成为可能。

提高代码可重用性

一个模块编写完成后，可以被其他地方引用。我们在编写程序的时候，也可以引用其他模块，包括 Python 内置的模块和来自第三方的模块。这样就不需要重复造轮子。大大提高了代码的复用性和开发效率。

减少代码冲突

模块提供了一个独立的命名空间，独立命名空间的好处是可以避免函数名和变量名冲突。相同名字的函数和变量可以放在不同的模块中。因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。

了解了模块是什么之后，我们一起来看下如何创建模块？

# 1 模块的创建

模块的创建非常简单，一个 .py 文件便是一个模块（Module）。将下面的代码保存在 utils.py 文件中，这个操作是非常简单的，只需要我们创建一个文件名为 utils 的 py 文件，然后将代码复制到 utils 的 py 文件中就完成了一个模块的创建。

# utils.py模块
def max_num(a, b):
    if a >= b:
        return a
    else:
        return b


def min_num(a, b):
    if a > b:
        return b
    else:
        return a

1
2
3
4
5
6
7
8
9
10
11
12
13

这样我们便创建了一个名为 utils 的模块，在这个模块中，定义了两个函数： max_num和min_num ，两个函数分别为求两个数中的大数和小数。

# 2 模块的导入

# 2.1 `import <module_name>`

模块创建完成后，可以使用 import 关键字来导入模块，例如：

import utils

我们看到通过 import 模块名 的方式完成了模块导入。

执行上述指令后，Python 首先会从自己内置模块中查找是否含有该模块的定义，若未查询到会从 sys.path 对应的模块路径查询是否含有对应模块的定义，如果搜索完成，仍然没有对应的模块时，则抛出 import 的异常。

也就是说当执行 import utils 这条指令时，Python 会从以下路径中搜索模块 utils.py 。

在当前目录下搜索该模块。
在环境变量 PYTHONPATH 指定的路径列表中依次搜索。
在 Python 安装路径的 lib 库中搜索。

上述路径可以通过变量 sys.path 获得，该变量位于模块 sys 中。sys.path是 Python 的一个系统变量，是 Python 搜索模块的路径列表。其获取的方法如下：

import sys

print(sys.path)

1
2
3

为了让创建的模块能够被找到，需要将模块放到上述路径中的一个，因为 Python 只会在这些路径中去查找模块，如果没有将模块创建在这些路径中，则找不到对应的模块，也就没办法应用模块中的对象和方法了。

现在呢，我们想要去调用模块 utils 中的 max_num 和 min_num 方法，第一步为导入模块 utils，第二步为调用模块 utils 中的两个方法，具体语句如下：

#导入模块utils
import utils

print(utils.max_num(4, 5))
print(utils.min_num(4, 5))

1
2
3
4
5

我们看到为了调用模块中的函数 max_num 和 min_num，需要在函数名前面添加 utils. 前缀。如果不添加 utils. 前缀，则会报错。

# 2.2 `from <module_name> import <name(s)>`

下面，我们一起来看模块导入的另一种方法，直接导入模块中的对象，语句为：from 模块名 import 方法名，我们一起看下方实例：

from utils import max_num, min_num

print(max_num(4, 5))
print(min_num(4, 5))

1
2
3
4

使用这种方式导入时，调用 max_num 和 min_num 函数便不需要添加前缀 utils.。

有时候，为了方便，会使用 from <module_name> import * 来导入模块中的所有对象。

from utils import *

print(max_num(4, 5))
print(min_num(4, 5))

1
2
3
4

# 2.3 `from <module_name> import as <alt_name>`

大家在成长过程中，都会有一些别名，仓颉也有，仓颉又被称为“造字圣人”，“造字圣人”就是仓颉的别名。

Python 中模块内的对象和方法也可以有自己的别名，实现语句为： from 模块名 import *** as 别名 ，该命令为导入的对象起一个别名。这样就可以通过别名来使用对象。例如：

from utils import max_num as max_n, min_num as min_n

print(max_n(4, 5))
print(min_n(4, 5))

1
2
3
4

在上面的例子中，分别为 max_num,min_num 取了别名 max_n,min_n。这样在调用函数时，便可以使用 max_n,min_n。

# 2.4 `import <module_name> as <alt_name>`

我们还可以为导入的整个模块起一个别名，这样便可以通过模块的别名来使用模块，使用方法是一样的，都是将 模块名. 作为前缀。例如：

import utils as ul

print(ul.max_num(4, 5))
print(ul.min_num(4, 5))

1
2
3
4

在上面的例子中，为模块 utils 取了别名 ul，这样在调用函数时，便可以使用 ul. 前缀。

# 2.5 包含单个类的模块

我们一起来看下包含单个类的模块，我们创建一个模块(car.py)，包含类 car ，语句如下：

class Car:
    def __init__(self, mk, md, y, c):
        self.make = mk
        self.model = md
        self.year = y
        self.color = c
        self.mileage = 0

    def get_description(self):
        description = f'{self.year} {self.color} {self.make} {self.model}'
        print(description)

    def get_mileage(self):
        print(f"This car has {self.mileage} miles on it")

    def update_mileage(self, mile):
        self.mileage = mile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

导入类(my_car.py)：

from car import Car

my_car = Car('audi', 'a4', 2016, 'white')
my_car.get_description()
my_car.update_mileage(30)
my_car.get_mileage()

1
2
3
4
5
6

# 2.6 包含多个类的模块

我们创建模块(car.py)，其中包含父类 car 和继承类 Electriccar ，语句如下：

class Car:
    def __init__(self, mk, md, y, c):
        self.make = mk
        self.model = md
        self.year = y
        self.color = c
        self.mileage = 0

    def get_description(self):
        description = f'{self.year} {self.color} {self.make} {self.model}'
        print(description)

    def get_mileage(self):
        print(f"This car has {self.mileage} miles on it")

    def update_mileage(self, mile):
        self.mileage = mile


class ElectricCar(Car):
    def __init__(self, mk, md, y, c):
        super().__init__(mk, md, y, c)
        self.battery_size = 100

    def get_battery(self):
        print(f"This car has {self.battery_size} -kWh battery.")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

导入单个类(my_electirc_car.py):

from car import ElectricCar

my_tesla = ElectricCar('tesla', 'model 3', 2018, 'white')
my_tesla.get_description()
my_tesla.get_battery()

1
2
3
4
5

导入多个类(my_cars.py):

from car import ElectricCar, Car

my_car = Car('audi', 'a4', 2016, 'white')
my_car.update_mileage(30)
my_car.get_mileage()

my_tesla = ElectricCar('tesla', 'model 3', 2018, 'white')
my_tesla.get_description()
my_tesla.get_battery()

1
2
3
4
5
6
7
8
9

导入整个模块：

import car

my_car = car.Car('audi', 'a4', 2016, 'white')
my_car.update_mileage(30)
my_car.get_mileage()

my_tesla = car.ElectricCar('tesla', 'model 3', 2018, 'white')
my_tesla.get_description()
my_tesla.get_battery()

1
2
3
4
5
6
7
8
9

导入模块中的全部类：

from car import *

my_car = Car('audi', 'a4', 2016, 'white')
my_car.update_mileage(30)
my_car.get_mileage()

my_tesla = ElectricCar('tesla', 'model 3', 2018, 'white')
my_tesla.get_description()
my_tesla.get_battery()

1
2
3
4
5
6
7
8
9

# 3 包

仓颉在创造出文字之前，也摸索了很多办法，他先是在绳子上打结，用各种不同颜色的绳子，表示各种不同的牲口。但时间一长，就不奏效了。增加的数目在绳子上打个结很方便，而减少数目时，在绳子上解个结就麻烦了。仓颉又想到了在绳子上打圈圈，在圈子里挂上各式各样的贝壳，来代替他所管的东西。增加了就添一个贝壳，减少了就去掉一个贝壳。但是随着仓颉管理事情的增多，这个方法也不好用了，他只能寻找其他办法，有一天，他看到猎人用动物的脚印来判断动物的踪迹，受到启发，创造了用符号表示事物，也就是文字。

在程序中呢，也会遇到和仓颉一样的问题，就是假设我们开发了一个很庞大的应用程序，程序包含了非常多的模块。随着模块数量的增长，如果将模块都放在同一个目录下，将变得越来越难管理。特别当模块具有相似的名称或相似的功能。这时候我们非常希望对这些模块进行分组管理，Python 中的包实现了对模块分组管理的功能。包的创建非常简单，它利用了操作系统的分层文件结构。我们只要将模块放在一个目录下便可。

在上图中，目录 pkg 下有两个模块，utils1.py 和 utils2.py，pkg 便是一个包。（包相当于一个文件夹，模块则相当于文件夹中的文件）

两个模块中的语句如下：（语句相当于文件中的内容）

utils1.py:

def max_num(a, b):
    if a >= b:
        return a
    else:
        return b


def min_num(a, b):
    if a > b:
        return b
    else:
        return a

1
2
3
4
5
6
7
8
9
10
11
12

utils2.py:

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


def abs_num(a):
    if a >= 0:
        return a
    else:
        return -a

1
2
3
4
5
6
7
8
9

# 3.1 `import <module_name>[, <module_name> ...]`

导入包中的模块，语法规则为：import 包.模块名，我们一起看下方语句：

import pkg.utils1
import pkg.utils2

print(pkg.utils1.max_num(4, 5))
print(pkg.utils2.sum_num(4, 5))

1
2
3
4
5

导入包 pkg 中的模块 utils1 和模块 utils2，并调用两个模块中的方法，将 pkg.utils1. 作为前缀放在 max_num()方法前，表示是在 pkg 包中的模块 utils1 内的方法。

# 3.2 `from <package_name> import <modules_name>[, <module_name> ...]`

我们也可以通过 from 语句来实现模块的导入，我们一起看下方语句：

from pkg import utils1, utils2

print(utils1.max_num(4, 5))
print(utils2.sum_num(4, 5))

1
2
3
4

# 3.3 `from <module_name> import <name(s)>`

我们再来一起看下，定义包之后，导入指定模块中的对象，我们看下方语句：

from pkg.utils1 import max_num

print(max_num(4, 5))

1
2
3

和第二部分模块导入相比，就是在模块名前将包的名字作为前缀 pkg.utils1 来实现的，其余语句均与模块导入一致。

# 3.4 `from <module_name> import as <alt_name>`

为模块内的对象和方法设置别名，语句如下：

from pkg.utils1 import max_num as max_n

print(max_n(4, 5))

1
2
3

# 3.5 `from <package_name> import <module_name> as <alt_name>`

为导入的整个模块设置别名，语句如下：

from pkg import utils1 as ul1

print(ul1.max_num(4, 5))

1
2
3

# 4 总结

本关，我们主要给大家介绍了模块和包，我们一起来回顾下本关内容：

# 5 练习题

自定义一个模块，并在另一个文件中导入这个模块。

# 1 模块的创建

# 2 模块的导入

# 2.1 import <module_name>

# 2.2 from <module_name> import <name(s)>

# 2.3 from <module_name> import as <alt_name>

# 2.4 import <module_name> as <alt_name>

# 2.5 包含单个类的模块

# 2.6 包含多个类的模块

# 3 包

# 3.1 import <module_name>[, <module_name> ...]

# 3.2 from <package_name> import <modules_name>[, <module_name> ...]

# 3.3 from <module_name> import <name(s)>

# 3.4 from <module_name> import as <alt_name>

# 3.5 from <package_name> import <module_name> as <alt_name>

# 4 总结

# 5 练习题

# 2.1 `import <module_name>`

# 2.2 `from <module_name> import <name(s)>`

# 2.3 `from <module_name> import as <alt_name>`

# 2.4 `import <module_name> as <alt_name>`

# 3.1 `import <module_name>[, <module_name> ...]`

# 3.2 `from <package_name> import <modules_name>[, <module_name> ...]`

# 3.3 `from <module_name> import <name(s)>`

# 3.4 `from <module_name> import as <alt_name>`

# 3.5 `from <package_name> import <module_name> as <alt_name>`