【Python基础学习篇】Python模块和包

一、Python程序的结构

Python的程序由包（package）、模块（module）和函数组成。包是由一系列模块组成的集合。模块是处理某一类问题的函数和类的集合。如下图所示：

包就是一个完成特定任务的工具箱，Python提供了许多有用的工具包，如字符串处理、图形用户接口、Web应用、图形图像处理等。这些自带的工具包和模块安装在Python的安装目录下的Lib子目录中。

注意：

包必须至少含有一个__int__.py文件按，该文件的内容可以为空。__int__.py用于标识当前文件夹是一个包。

二、模块

Python的程序是由一个个模块组成的。

（一）模块的创建

模块把一组相关的函数或代码组织到一个文件中。一个文件既是一个模块。模块由代码、函数或类组成。

例如，创建一个名为“myModule.py”的文件，即定义了一个名为“myModule”的模块。在该模块中定义一个函数func()和一个类MyClass。MyClass类中定义一个方法myFunc()：

#自定义模块
def func():
    print "MyModule func()"

class Myclass:
    def myFunc(self):
        print "MyModule MyClass myFunc()"

然后在myModule.py所在的目录下创建一个名为“call_myModule.py”的文件。在该文件中调用myModule模块的函数和类：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
#调用自定义模块的类和函数

import myModule

myModule.func()
myClass = myModule.MyClass()
myClass.myFunc()

输出结果：

---------- python2.7 ----------
MyModule.func()
MyModule.MyClass.myFunc()

输出完成 (耗时 0 秒) - 正常终止

注意：

myModule.py和call_myModule.py必须放在同一个目录下或放在sys.path所列出的目录下，否则，Python解释器找不到自定义的模块。

当Python导入一个模块时，Python首先查找当前路径，然后查找lib目录、site-packages目录（Python\Lib\site-packages）和环境变量PATHONPATH设置的目录。如果导入的模块没有找到，在以上路径搜索一下是否含有这个模块。可以通过sys.path语句搜索模块的查找路径。

（二）模块的导入

在使用一个模块中的函数或类之前，首先要导入该模块。模块的导入使用import语句。

模块导入的格式如下：

import module_name

这条语句可以直接导入一个模块。调用模块的函数或类时，需要以模块名作为前缀。

从模块中调用函数和类的格式如下所示：

module_name.func()

如果不想在程序中使用前缀符，可以使用from…import…语句将模块导入。

from…import…语句的格式如下所示：

from module_name import function_name

但是from…import…语句容易造成代码可读性差等问题。

导入模块下所有的类和函数，可以使用如下格式的import语句：

from module_name import *

同一个模块文件支持多条import语句。

例如，定义一个名为myModule的模块。该模块定义一个全局变量count和一个函数func()。每次调用函数func()，使变量count的值加1：

count = 1

def func():
    global count
    count = count + 1
    return count

多次导入myModule模块，以便查看变量count的结果：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]

import myModule

print "count =",myModule.func()
myModule.count = 10
print "count =",myModule.func()

import myModule
print "count =",myModule.func()

输出结果：

---------- python2.7 ----------
count = 2
count = 11
count = 12

输出完成 (耗时 0 秒) - 正常终止

Python中的import语句比Java的import语句更加灵活。Python的import语句可以置于程序中任意的位置，甚至可以放在条件语句中。

例如：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
#import置于条件语句中
if myModule.count > 1:
    myModule.count = 1
else:
    import myModule
print "count =",myModule.count

（三）模块的属性

模块有一些内置属性，用于完成特定的任务，如__name__、__doc__。每个模块都有一个名称。

例如：

__name__用于判断当前模块是否是程序的入库，如果当前程序正在被使用，__name__的值为“__main__”。通常给每个模块都添加一个条件语句，用于单独测试该模块的功能。

例子：创建一个模块myModule

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]

if __name__ == '__main__':
    print 'myModule作为主程序运行'
else:
    print 'myModule被另一个模块调用'

输出结果：

---------- python2.7 ----------
myModule作为主程序运行

输出完成 (耗时 0 秒) - 正常终止

创建另一个模块call_myModule。

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
import myModule
print __doc__

输出结果：

---------- python2.7 ----------
myModule被另一个模块调用
None

输出完成 (耗时 0 秒) - 正常终止

（四）模块的内置函数

Python提供了一个内联模块bulidin，该模块中定义了一些软件开发总经常用到的模块，利用这些函数可以实现数据类型的转换、数据的计算、序列的处理等功能。

1、apply()

apply()可以实现调用可变参数列表的函数，把函数的参数存放在一个元组或序列中。

apply()的声明如下：

apply(func[,args[,kwargs]])

说明

参数func是自定义的函数名称；

参数args是一个包含自定义函数参数的列表或元组。args如果省略，则表示被执行的函数没有任何参数。

参数kwargs是一个字典。字典中的key值为函数的参数名称，value值为实际参数的值。

例子：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
def sum(x = 1,y = 2):
    return x + y

print apply(sum,(1,3))

输出结果：

---------- python2.7 ----------
4

输出完成 (耗时 0 秒) - 正常终止

注意：

apply()的元组参数是有序的。

2、fiter()

filter()可以对某个序列做过滤处理，对自定义函数的参数返回的结果是否为“真”来过滤，并一次性返回处理结果。

filter()的声明如下所示：

filter(func or None,sequence) -> list,tuple,or string

说明

参数func是自定义的过滤函数，在函数func(item)中定义过滤的规则。如果func为None，则过滤项item都为真，返回所有的序列元素。

参数sequence为待处理的序列。

filter()的返回值是由func()的返回值组成的序列，返回的类型与参数sequence的类型相同。例如，参数sequence为元组，则返回的类型也是元组。

例子：从给定的列表中过滤出大于0的数字。

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
def func(x):
    if x > 0:
        return x
print filter(func,range(-9,10))

输出结果：

---------- python2.7 ----------
[1, 2, 3, 4, 5, 6, 7, 8, 9]

输出完成 (耗时 0 秒) - 正常终止

注意：

filter()中的过滤函数func()的参数不能为空，否则，没有可以存储sequence元素的变量，func()也不能处理过滤。

3、reduce()

对序列中元素的连续操作可以通过循环来处理（例如对某个序列中的元素累加操作）。Python提供的reduce()也可以实现连续处理的功能。

reduce()的声明如下所示：

reduce(func,sequence[,initial])->value

说明：

参数func是自定义的函数，在函数func()中实现对参数sequence的连续操作。

参数sequence为待处理的序列。

参数initial可以省略，如果initial不为空，则initial的值将首先传入func()进行计算。如果sequence为空，则对initial的值进行处理。

reduce()的返回值是func()计算后的结果。

例子：实现对一个列表中的数字进行累加的操作。

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
def sum(x,y):
    return x + y

print reduce(sum,range(0,10))#0+1+2+3+4+5+6+7+8+9
print reduce(sum,range(0,10),10)#10+0+1+2+3+4+5+6+7+8+9
print reduce(sum,range(0,0),10)#range(0,0)返回空列表，所以返回结果就是10

输出结果：

---------- python2.7 ----------
45
55
10

输出完成 (耗时 0 秒) - 正常终止

注意：

如果reduce()进行累计计算，必须在sum中定义两个参数，分别对应加法运算符两侧的操作数。

4、map()

map()可以对多个序列的每个元素都执行相同的操作，并组成列表返回。

map()的声明如下所示：

map(func,sequence[,sequence,...])->list

参数func是自定义的函数，实现对序列每个元素的操作。

参数sequence为待处理的序列，参数sequence的个数可以是多个。

map()的返回值是对序列元素处理后的列表。

例子：实现列表中数字的幂运算。

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
def power(x):return x**x
print map(power,range(1,5))
def power2(x,y):return x**y
print map(power2,range(1,5),range(5,1,-1))

输出：

---------- python2.7 ----------
[1, 4, 27, 256]
[1, 16, 27, 16]

输出完成 (耗时 0 秒) - 正常终止

注意：

如果map()中提供了多个序列，则每个序列中的元素一一对应进行计算。如果每个序列的长度不相同，则短的序列后补充None，再进行计算。

常用的内联函数如下表所示：

三、自定义包

包就是一个至少包含__int__.py文件的文件夹。Python包和Java包的作用是相同的，都是为了实现程序的重用。把实现一个常用功能的代码组合到一个包中，调用包提供的服务从而实现重用。

例如，定义一个包parent。在parent包中创建两个子包pack和pack2.pack包中定义一个模块myModule，pack2包中定义一个模块myModule2.最后在包parent中定义一个模块main，调用子包pack和pack2.如下图所示：

包与模块的树形关系图

包pack的__int__.py程序如下所示：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
if __name__ == '__main__':
    print '作为主程序运行'
else:
    print 'pack初始化'

这段代码初始化pack包，这里直接输出一段字符串。当pack包将其他模块调用时，将输出“pack包初始化”。

包pack的myModule模块如下所示：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
def func():
    print "pack.myModule.func()"

if __name__ == '__main__':
    print '作为主程序运行'
else:
    print 'pack初始化'

当pack2包被其他模块调用时，将首先执行__int__.py文件。

pack2包的__int__.py程序如下所示：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
if __name__ == '__main__':
    print '作为主程序运行'
else:
    print 'pack2初始化'

包pack2的myModule2模块如下所示：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
def func2():
    print "pack2.myModule2.func()"

if __name__ == '__main__':
    print '作为主程序运行'
else:
    print 'pack2初始化'

下面的main模块调用了pack、pack2包中的函数：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
from pack import myModule
from pack2 import myModule2

myModule.func()
myModule2.func2()

__init__.py也可以用于提供当前包的模块列表。

例如，在pack包的__init__.py文件前面添加一行代码：

__all__ = ["myModule"]

__all__用于记录当前pack包所包含的模块。其中方括号中的内容是模块名的列表，

如果模块数量超过两个，使用逗号分开。通力，在pack2包也添加一行类似的代码：

__all__ = ["myModule2"]

这样就可以在main模块中一次导入pack、pack2包中所有的模块。

修改后的main模块如下所示：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
from pack import *
from pack2 import *

myModule.func()
myModule2.func2()