Python开发技术详解-笔记_第05章-模块与函数

5 模块与函数

    结构化程序设计可以把复杂的问题分解为若干个子任务,
    针对子任务定义实现的模块和函数.

 - 模块的创建和使用方法
 - Python中的内置模块
 - Python中的常用模块
 - 函数的创建和使用方法
 - lambda 函数
 - generator 函数
 - 函数化程序设计

 5.1 Python的程序结构

    -Python的程序由 包(package)、模块(module)、函数 组成.
    -包   是一系列模块组成的集合.
    -模块 是处理某一类问题的函数和类的集合.

    -包 就是一个完成特定任务的工具箱,Python提供了许多有用的工具包,
     如字符串处理、图形用户接口、web应用、图像图形处理等
     这些自带的工具包和模块安装在Python的安装目录下的Lib目录
    -文件 __init__.py 包的注册文件.
    -包中至少含有一个__init__.py文件,该文件的内容可以为空.
     __init__.py 用于标识当前文件夹是一个包 

5.2 模块

    -Python的程序是由一个个模块组成,一个Python文件就是一个模块.   

 5.2.1 模块的创建

    -模块把一组相关的函数或代码组织到一个文件中.
    -当导入一个模块时,Python 依次查找
        -当前目录, 
        -lib目录,  %python%\lib        
        -site-packages目录 %python%\Lib\site-packages
        -环境变量PYTHONPATH指定的目录
     可通过sys.path语句搜索模块的查找路径        
    -举例,(同一目录)
        -myModule.py    定义函数 和 类
        -callModule.py  导入myModule, 调用函数和类的成员

    --------- myModule.py ---------
    def func():
        print "myModule.func()...."
    class MyClass :
        def myClassFunc(self) :
            print "myModule.MyClass.myClassFunc()"

    --------- callModule.py -------
    import myModule

    myModule.func()
    instance = myModule.MyClass()
    instance.myClassFunc()        

 5.2.2 模块的导入

    在使用一个模块中的函数或类之前, 首先需要导入该模块.
    ① import module_name
    ② from module_name import func_name
    ③ from module_name import *

    注: import语句可以多次导入, 即使导入同一模块
        import语句可以置于程序中的任意位置, 甚至可以置于条件语句

        if 1 > 0 :
            import os        
        print os.path    

 5.2.3 模块的内置属性

    模块有一些内置属性, 用于完成特定的任务, 如:
     __name__   : 判断当前模块是否是程序的入口
     __doc__    : 文档字符串

 5.2.4 模块的内置函数

    内联模块buildin, 定义了一些常用的函数

    1) apply()

       ①语法: 
            apply(func[,args [,kwargs]])
       ②说明: 
            func : 自定义函数
            args : 自定义函数参数的列表或元组,省略则没有任何参数
            kwargs: 参数1=值1,参数2=值2,...
       ③功能: 
            调用可变参数列表的函数, 可替代"*"及"**"的作用

       ④举例:
        >>> def sum(num1,num2) :
        ...     return num1 + num2
        ...
        >>> print apply( sum,(1,2) )
        3       
    

    2) filter()

       ①语法:
            filter(func, sequence) --> list,tuple,string
       ②说明:
            func : 过滤函数, 当为None时,所有itme都为True
            sequence : 待处理的序列
            返回值: 类型与sequence一致
       ③功能:
            对某个序列做过滤处理
       ④举例:
        >>> def isOdd(num) :
        ...     return num % 2
        ...
        >>> print filter( isOdd, range(1, 10) )
        [1, 3, 5, 7, 9]

    3) reduce()

       ①语法:
            reduce(func, sequence[, initial]) ---> value
       ②说明:
            func : 函数, 对sequence的每个元素连续操作
            sequence : 待处理的序列
            initial : 指定时,initial 首先传递给func
       ③功能:
            对序列中元素的连续操作可以通过循环来处理
       ④举例:
        >>> def sum(num1, num2) :
        ...     return num1 + num2
        ...
        >>> print reduce( sum, range(1, 10 + 1) )
        55
        >>> print reduce( sum, range(1, 10 + 1), 10 )
        65

    4) map()

       ①语法:
            map(func, sequence[, sequence, ...]) --> list
       ②说明:
            func : 函数, 对序列每个元素的操作
            sequence : 待处理的序列
            返回值: 每个被处理后的元素组成的列表
       ③功能:
            对多个序列的相同索引元素进行操作,短的补 None, 返回列表
       ④举例:
        >>> def power(num) :
        ...     return num ** num
        ...
        >>> print map( power, range(1, 3 + 1) )
        [1, 4, 27]
        >>> def sum(num1, num2) :
        ...     return num1 + num2
        ...
        >>> print map( sum, range(1, 3 + 1), range(10, 30 + 1, 10) )
        [11, 22, 33]

    5) 常用内置模块函数列表

     abs(x)                             绝对值
     apply(func[, args[ ,kwargs]])      调用可变参数函数
     bool([x])                          转boolean值
     cmp(x, y)                          比较大小
     delattr(obj, name)                 <==> del obj.name
     eval(s[, globals[, locals]])       计算表达式的值
     float(x)                           转float值
     hash(object)                       hash值
     help([object])                     帮助
     id(x)                              返回对象的标识
     input([prompt])                    控制台接收数字,返回数字
     int(x)                             转整型值
     len(obj)                           元素个数
     range([start,][end][,step])        生成并返回一个list
     raw_input([prompt])                控制台接收,返回字符串
     reduce(func, sequence[, initial])  对序列进行累计计算
     round(x, n=0)                      四舍五入
     set([iterable])                    返回一个set集合
     sorted(iterable[, cmp[, key[, reverse]]])  返回排序后的list
     sum(iterable[,start=0])            序列元素值的和
     type(obj)                          对象的类型
     xrange(start[, end[, step]])       类似range(),每次返回一个值
     zip(sequence1[, sequence2,...])    相同索引元素组成元组,返回list

 5.2.5 自定义包

    - 包就是一个 包含 __init__.py文件 的文件夹. 
    - __init__.py 也可以用于提供当前包的模块列表
      如 childpack2.__init__ 中的 __all__ = ["myModule2"]
      当 from...import * 时, 可以导入__all__指定的模块
    - 举例如下:

    ①组织结构
     parentpack
        |-- main.py
        |-- childpack1
             |-- __init__.py
             |-- myModule1.py
        |-- childpack2
             |-- __init__.py
             |-- myModule2.py

    ②main.py

# 
# from childpack1 import myModule1
# myModule1.func()
# 
import childpack1.myModule1
childpack1.myModule1.func()

from childpack2 import *
myModule2.func()

    ③childpack1

        |-- __init__.py

if __name__ == "__main__" :
    print "childpack1.__init__", "as main"
else :
    print "childpack1", "is init..."

        |-- myModule1.py

def func() :
    print "childpack1.myModule.func()"

if __name__ == '__main__':
    print "childpack1.myModule as main"    
else :
    print "childpack1.myModule is being called"    

    ④childpack1

        |-- __init__.py

__all__ = ["myModule2"]


if __name__ == "__main__" :
    print "childpack2.__init__", "as main"
else :
    print "childpack2", "is init..."

        |-- myModule2.py

def func() :
    print "childpack2.myModule.func()"

if __name__ == '__main__':
    print "childpack2.myModule2 as main"    
else :
    print "childpack2.myModule2 is being called"    

  5.3.5 递归函数

   (1) 概念

    递归函数可以在函数主体内直接或间接调用自己.
    递归的过程分为两个阶段
     - 递推
     - 回归
    
    第一阶段 递推

        递归函数在内部调用自己.
        每一次函数调用又重新开始执行此函数的代码,
        直到某一级递归程序结束.

    第二阶段 回归   

        递归函数从后往前返回.
        递归函数从最后一级开始返回,
        直到返回到第一次调用的函数体内.
        即递归逐级调用完毕后,再按照相反的顺序逐级返回.

  (2) 注意

        递归函数需要编写递归结束条件,否则递归程序将无法结束.

  (3) 递归函数的结构

        1. 判断是否结束
        2. 递推
        3. 回归

  (4) 普通递归

        #-*- encoding:UTF-8 -*-
        def recursion(num) :
            if num > 1 :    #判断递归是否结束
                num = num * recursion( num - 1 )    #递推
            return num      #回归

        if __name__ == '__main__':
            print recursion(4)    

  (5) 使用reduce()函数快速实现递归

        >>> reduce(lambda x, y : x * y, xrange(1,5+1))
        120

  5.3.6 lambda函数

  (1) 作用

        lambda函数用于创建一个匿名函数,函数名未和标识符进行绑定.
        可以返回一些简单的运行结果.

  (2) 语法

        lambda 形参1,形参2,... : 表达式        

  (3) 注意

        lambda也称之为表达式.
        lambda中只能使用表达式,不能使用判断、循环等多重语句 

  (4) 举例

    num1 = 2
    num2 = 4

    sum = lambda x, y : x + y
    sub = lambda x, y : x - y

    print sum(2,4)
    print sub(2,4)

5.3.7 Generator 函数

    

 (1) 作用

    生成器(Generator)的作用是一次产生一个数据项,并把数据项输出.
    可在 for 中使用, 是迭代器性能更佳.

 (2) 语法

    def 函数名(参数列表) :

        ...

        yield 表达式

 (3) 说明

    使用 yield生成数据项
    当使用 next 时, 当没有数据生成时 抛出 StopIteration

 (4) 举例

    generator.py

#-*- encoding:UTF-8 -*-

def myGenerator(num) :
    for i in xrange(0,num) :
        yield i

def useInFor() :
    for i in myGenerator(3) :
        print i

def useNext() :
    var = myGenerator(3)
    print var.next()
    print var.next()
    print var.next()
    print var.next()

if __name__ == '__main__':
    # useInFor()
    useNext()