Python学习笔记整理(十二)

一、函数基础 函数可以计算出一个返回值。作用：最大化代码重用，最小化代码冗余，流程的分解 1、函数相关的语句和表达式 语句        例子 Calls        myfunc(‘diege','eggs',meat=lit) #使用函数 def,return,yield      def adder(a,b=1,*c):                           return a+b+c[0] global        changer():                 global x;x='new' lambda        Funcs=[lambad x:x**2,lambad x:x*3] 2、编写函数 def是可执行的代码，实时执行的，Python中所有语句都是实时执行的，if,while，def可嵌套,可以出现在任何地方，但往往包含在模块文件中， 并早模块导入时运行，函数还可以通过嵌套到if语句中去实现不同的函数定义。 def创建了一个对象并将其赋值给某一个变量名。 return将一个结果对象发送给调用者。 函数是通过赋值（对象引用)传递的。

参数通过赋值传递给函数。 global声明了一个模块级的变量并被赋值。 参数，返回值以及变量并不是声明 def语句 def语句将创建一个函数对象并将其赋值给一个变量名。一般格式如下： def <name>（arg1,age2,...,agrN):     <statements>      return <value> 函数主体往往都包含了一个return语句（不是必须的），如果它没有出现，那么函数将会在控制流执行完函数主体时结束，技术上，没有返回值的函数自动返回了none对象。 return可以在函数主体中的任何地方出现。它表示函数调用的结束，并将结果返回至函数调用处。 函数通过嵌套到if语句中去实现不同的函数定义的格式： if test:     def func():         ... else:     def func() func()    #call 3、例子1 定义 >>> def Dtest(x,y): ...     return x*y 使用(call) >>> Dtest(3,5) 15 >>> Dtest(3.14,3) 9.42 >>> Dtest('A',4)     'AAAA' 这里又看到Python中的多态了 Dtest函数中的表达式x*y的意义完全取决于x和y的对象类型。 类似的多态操作还包括：print，index,*操作符 >>> Dtest('A','A') #会报错，但不要尝试判断传入参数的对象类型，这样实质上破坏了函数的灵活性，把函数限制在特定的类型上。任何支持函数所预期的结果的对象都能用。（结果一词是指函数所执行的一组方法和表达式运算符） 4、例子2 寻找序列的交集 定义 >>> def Intersect(seq1,seq2): ...     res=[] ...     for x in seq1: ...             if x in seq2: ...                     res.append(x) ...     return res 调用 >>> Intersect([1,3,5,6,7,9],[2,4,5,7,8,10]) [5, 7] >>> s1='SPAM' >>> s2='sCaM' >>> Intersect(s1,s2)                         ['M'] 重访多态，这些编写这个函数是多态，它可以支持多种类型 >>> Intersect([1,3,5,6,7,9],(1,4))              [1] 技术上讲，文件也可以做为该函数的第1个参数，但不能作为第2个参数。在一个文件中搜索2个参数 >>> Intersect(open('/etc/rc.conf').read(),'apache') 5、本地变量 例子2中.res变量在python中称为本地变量，这个变量只是在def内的函数中是可见的，并且仅在函数运行时是存在的。所有函数内部进行赋值的变量名 都默认为本地变量，。 *req是明显被赋值过的，所以它是一个本地变量 *参数也是通过赋值被传入的，所以seq1和seq2也是本地变量。 *for循环将元素赋值给了一个变量，所以变量x也是本地 二、作用域和参数 （一）作用域 python作用域：变量定义以及查找的地方 参数传递：传递给函数作为其输入对象的方式 1、作用域法则 Python创建，改变或者查找变量名都是在所谓的命名空间（一个保存变量名的地方）中进行。作用域这个术语指的就是命名空间。 也就说，在代码中变量名被赋值的位置决定了这个变量名能被访问到的范围 一个函数所有变量名都与函数的命名空间相关联。 *def内定义变量名def内使用 *def之中的变量名与def之外的变量名不发生冲突，使用别处相同的变量名也没问题。 x=99 def func()     x=88 函数定义了本地作用域，而模块定义了全局作用域。两作用域关系。 *内嵌的模块是全局作用域：对于外部的全局变量就成为了一个模块对象的属性。 *全局作用域的作用范围仅限单个文件：不要被全局迷惑，这里的全局是一个文件的顶层的变量名，仅对这个文件内部的代码而言是全局。 Python中，没有一个无所不包的情景文件作用域。替代的方法是，变量名由模块文件隔开，必须精准地导入一个模块文件才能偶使用这文件中 定义的变量名， *每次对函数的调用都创建了一个新的本地作用域。 *赋值的变量名废除声明为全局变量，否则均为本地变量。 *所用的变量名都可以归纳为本地，全局，或者内置。（内置：ptyhon预定义的__builtin__模块提供的） 2、变量名解析：LEGB原则 对一个def语句 *变量名引用分为三个作用域进行查找：首先查找本地，然后是函数内（如果有），之后全局，最后内置。 *默认情况下，变量名赋值会创建或改变本地变量 *全局声明将赋值变量名映射到模块文件内部的作用域。 3、作用域实例 #定义全局作用域 >>> X=99 >>> def func(Y): ...     Z=X+Y   #本地作用域 ...     return Z ... >>> func(1)     100 全局变量：X,func 本地变量：Y,Z 4、内置作用域 需要导入__builtin__ >>> import  __builtin__ >>> dir(__builtin__) 里面前一半是内置异常，后一半是内置函数 5、global global语句包含关键字global *全局变量是位于模块文件内部顶层的变量名 *全局变量如果是在函数内部被赋值的话，并需经过声明 *全局变量名在函数的内部不经过声明也可以被引用 >>> X=88      >>> def func(): ...     global X ...     X=99 ... >>> func() >>> print X 99 >>> y,z=1,2 >>> def Ftest(): ...     global x ...     x=y+z ... >>> Ftest() >>> x 3 6、最小化全局变量 (二)传递参数 *参数的传递是通过自动将对象赋值给本地变量来实现的。 *在函数内部的参数名的赋值不会影响调用者。 *改变函数的可变对象参数的值也许会对调用者有影响。 换句话说，因为参数是简单的通过赋值进行对象的传递，函数能够改变传入的可变对象，因此其结果会影响调用者。 *不可变参数是“通过值”进行传递。 像整数和字符串这样的对象是通过对象引用而不是拷贝进行传递的，但是因为你无论如何都不可能在原处改变不可变对象，实际的效果就是很像创建了一份拷贝。 可变对象是通过“指针”进行传递的。 1、参数和共享引用 >>> def changer(a,b): ...     a=2 ...     b[0]='diege' ... >>> X=1 >>> L=[1,2] >>> changer(X,L) >>> X,L (1, ['diege', 2]) 函数内部对参数或者参数的分片赋值了，X没改变，L改变了，X,Y都是全局变量。这说明了数字字符串不可变参数函数无法改变。 而列表，字典等可改变参数可以在执行函数调用后改变。 这里a是函数的本地变量名，第一个赋值对函数调用者没有影响。它仅简单的修改了本地变量名a,并没有改变参数a绑定的函数调用者的变量名X。 b也是一个本地变量名，但是他被传递给了一个可变对象。因为第二个赋值是一个在原处发生的对象改变（如果是b='diege'就没有改变,因为这样只改变本地变量名），对函数中b[0]进行赋值的结果是在函数返回后影响L的值。事实上我们没有修改b，修改是是b当前所引用 对象的一部分，并且这个改变将影响调用者。 2、避免可变参数的修改 在Python中，默认通过引用（也就是指针)进行函数的参数传递。如果不想在函数内部在原处的修改影响传递给它的对象。那么，能够简单的创建一个可变对象的拷贝。我们总是能够在调用时对列表进行拷贝L=[1,2] changer(X,L[:]) 如果不想改变传入的对象，无论函数是如何调用的，我们可以在函数内部进行拷贝，避免可变参数的修改 >>> def changer(a,b): ...     a=2 ...    b=b[:] ...     b[0]='diege' ... 3、对参数输出进行模拟 return能够返回任意种类的对象，它也能返回多个值，如这些值被封装进一个元组或者其他的集合类型 >>> def mul(x,y): ...     x=2 ...     y=[3,4] ...     return x,y ... >>> X=1 >>> L=[1,2] >>> mul(X,L) (2, [3, 4]) >>> X,L=mul(X,L)  >>> X,L (2, [3, 4]) 4、特定参数匹配模型 参数在ptyhon中总是通过赋值进行传递，传入的对象赋值给了在def头部的变量名。尽管这样，在模型的上层，python提供了额外的工具，该工具改变了调用过中，赋值时参数对象匹配在头部的参数名的优先级。这些工具是可选的。 默认情况下，参数是通过其位置进行匹配的，从左到右，而且必须精确地传递和函数头部参数名一样多的参数。还能够定义变量名进行匹配，默认参数值（arg2=10),以及对于额外参数的容器，必须要根据变量名匹配对象，匹配完成后在传递机制的底层依然是赋值。这些工具对于编写库文件的人来说，要比应用程序开放者更有用。 规则 *位置：从左到右进行匹配 *关键字参数：通过参数名进行匹配。 【调用者】可以定义那个函数接受这个值，通过在调用时使用参数的变量名，使用name=value这种语法。 *默认参数：为没有传入值得参数定义参数值【定义函数时】 如果调用时传入的值过于少的话，函数能够为参数定义接受的默认值，在函数定义中使用name=value *可变参数：收集任意多基于位置或关键字的参数 以*开头，收集任意多的额外参数 *可变参数：传递任意多的基于位置或关键字的参数。【调用时】 调用者能够再使用*语法去将参数集合打散，分成参数。这个*与函数头部的*恰恰相反。在函数头部他意味着收集任意多的参数，而在调用者中意味着传递任意多的参数。 总结与特定模式有关的语法： 语法            位置    解释 func(value)        调用者    常规参数，通过位置进行匹配 func(name=value)    调用者    关键字参数，通过变量名匹配 func(*name)        调用者    以name传递所有的对象，并作为独立的基于位置的参数 func(**name)        调用者    以name成对的传递所有的关键字/值，并作为独立的关键字的参数 def func(name)        函数    常规参数：通过位置或变量名进行匹配 def func(name=value)    函数    默认参数值：如果没有在调用中传递的话，就是用默认值 def func(*name)        函数    匹配并收集(在元组中）所有包含位置的参数 def func(**name)    函数    匹配并收集（在字典中）所有包含位置的参数。 5、关键字参数和默认参数的实例 >>> def f(a,b,c): ...     print a,b,c ... >>> f(1,3,4) 1 3 4 关键词参数 >>> f(c=5,a=8,b=9)       8 9 5 >>> f(4,c=8,b=9)    4 9 8 >>> def func(name,age,job): ...     print 'name','age','job' ... >>> func('diege',18,'op') name age job >>> func(age=18,job='op',name='diege') name age job 关键字参数在调用中起到了数据标签的作用 默认参数，如果调用时没有传入值得话，在函数运行前，参数就被赋了默认值。 >>> def f(a,b=2,c=5): ...     print a,b,c ... >>> f(4) 4 2 5 >>> def f(a,b=2,c=5): ...     print a+b+c ... >>> f(4) 11 >>> f(6,5)  16 >>> f(a=10) 17 >>> f(a=3,b=4) 12 >>> f(2,c=6)     10 >>> f(6,7,8) 21 6、任意参数的实例 *和** 让函数支持接收任意数目的参数。 收集参数 第一种用法：在函数定义中，在元组中收集不匹配的位置参数 >>> def f(*args):print args ... >>> f() () **特性类似，但是它只对关键字参数有效。将这些关键字参数传递给一个新的字典。 >>> def f(**agrs):print args >>> f() >>> def f(**args):print args ... >>> f() {} min调用 def min1(*args):     res=args[0]     for arg in args[1:]:         if arg < res:             res=arg     return 三、函数的高级话题 （一）、匿名函数：lamdba lambad 创建了一个之后能够被调用的函数，它返回了一个函数而不是将这个函数赋值给一个变量名。 1、lambda表达式 lanbda arg1,arg2,...,argN:expression using arguments lambda 是一个表达式，而不是一个语句 lambda的主体是一个单个的表达式，而不是代码块 >>> def func(x,y,z):return x+y+z ... >>> func(2,3,4) 9 等同于 >>> f=lambda x,y,z:x+y+z >>> f(2,3,4) 9 默认参数也能够再lambda参数中使用，就像在def中使用一样。 >>> x=(lambda a='free',b='file',c='feel':a+b+c)   >>> x('well') 'wellfilefeel 为什么要使用lambda lambda 通常用来编写跳转表，也就是行为的列表或字典，能够按照需要执行相应的动作。 L=[(lambda x:x**2),(lambda x:x**3),(lambda x:x**4)] >>> for f in L: ...     print f(2) ... 4 8 16 >>> print L[0](3) 9 2、嵌套lambda和作用域 >>> def action(x): ...     return (lambda y:x+y) ... >>> act=action(99) >>> act <function <lambda> at 0x285066f4> >>> act(2) 101 (二) 作参数来应用函数 1、内置函数apply 当需要变得更加动态的话，可以通过将一个函数作为一个参数传递给apply来调用一个生成的函数，并且也将传给那个函数的参数作为一个元组传递给apply函数（） 2、传入关键字参数 >>> echo(1,2,a=3,b=4) (1, 2) {'a': 3, 'b': 4} >>> arg1=(1, 2) >>> arg2={'a': 3, 'b': 4} >>> apply(echo,arg1,arg2) (1, 2) {'a': 3, 'b': 4} 3、和apply类似的调用语法 >>> apply(func,args) 9 >>> func(args) 9 >>> apply(echo,arg1,arg2) (1, 2) {'a': 3, 'b': 4} (三) 在序列中映射函数：map >>> L=[1,2,3,4,5] >>> updated=[] >>> for x in L:            ...     updated.append(x+10) ... >>> updated [11, 12, 13, 14, 15] 使用内置工具map，map函数会对一个序列对象中的每一个元素应用被传入的函数，并且返回一个包含了所有函数调用结果的一个列表。 >>> def inc(x):return x+10 ... >>> L=[1,2,3,4,5] >>> map(inc,L) [11, 12, 13, 14, 15] map（函数，传入函数的序列对象） >>> map(None,S1,S2) >>> L=[1,2,3,4,5]  map嵌套lambda       >>> map((lambda x:x+3),L) [4, 5, 6, 7, 8] 高级功能：提供了多个序列作为参数，它能够并行返回分别以每个序列的元素作为【函数对应参数】得到的结果的列表 >>> pow(3,4) 81 >>> map(pow,[1,2,3],[2,3,4])    #1**2，2**3,3**4 [1, 8, 81] (四) 函数式编程工具：filter和reduce 函数式编程的意思就是对序列应用一些函数的工具。 基于某一测试函数过滤出一些元素-filter 对每对元素都应用函数并运行到最后结果-reduce >>> range(-5,5) [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4] >>> filter((lambda x:x>0),range(-5,5)) [1, 2, 3, 4] 这个等效于for range:if语句 reduce稍微复杂一点。这里两个reduce调用，计算在一个列表中所有元素加起来和以及乘起来的乘积 >>> reduce((lambda x,y:x+y),[1,2,3,4]) 10 >>> reduce((lambda x,y:x*y),[1,2,3,4]) 24 (五)重访列表解析：映射 1、列表解析基础 >>> [x**2 for x in range(10)] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> map((lambda x:x**2),range(10)) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 2、增加测试和嵌套循环 在for之后编写if分支，用来增加逻辑选择，if分支相当filter >>> [x for x in range(5) if x%2==0] [0, 2, 4] >>> filter((lambda x:x%2==0),range(5)) [0, 2, 4] filter出来的列表可以作为map的第2个参数 >>> map((lambda x:x**2),filter((lambda x:x%2==0),range(5))) [0, 4, 16] 3、列表解析和矩阵 4、理解列表解析 对ptyhon初学者，通常使用简单的for循环，在其他大多数情况下，使用map调用（除非它们会变得过于复杂） 列表解析比map快，map比for循环快2倍 (六)重访迭代器：生成器 编写的函数能够返回一个值，并且稍后还可以从它刚才离开的地方仍然返回值。这样的函数被认作是生成器，因为它们随时间生成一个序列的值。 大多数方面生成器函数就像一般函数，在Python它们被自动用作实现迭代协议，因它只能够再迭代的语境中出现。 生成器和一般的函数之间代码上最大的不同就是一个生成器yield一直，而不是return一个值。yield语句将会将函数关起，并向它的调用者返回一个值 但是保存足够的状态信息为了让其能够在函数从它挂起的地方恢复。 包含yield的语句的函数将会特地编译成为生成器。当调用它时，他们返回一个生成器对象，这个生成器对象支持迭代器对象接口。 1、生成器实例的。 >>> def Dtest(N): ...     for i in range(N): ...             yield i**2 使用 >>> for i in Dtest(5): ...     print i,':', ... 0 : 1 : 4 : 9 : 16 : 查看过程 >>> x=Dtest(4) >>> x.next() 0 >>> x.next() 1 >>> x.next() 4 >>> x.next() 9 >>> x.next() for循环和生成器是一样的:通过重复调用next方法，知道捕获一个异常。 2、扩展生成器协议send和next 生成器函数协议中增加了一个send方法，send方法生成一系列结果的下一个元素，这一点就像next方法一样，但是它也提供了 一种调用者与生成器之间的进行通信的方法，从而能偶影响它的操作。 yiled是一个表达式，可以返回传入的元素来发送，而不是一个语句。值是通过调用本身send(value)方法传给生成器的。 之后恢复生成器的代码，并且yield表达式返回了为了发送而传入的值。如果调用了正常的放next()方法，yield返回None 3、迭代器和内置类型 内置的数据类型设计了对应于内置函数iter的迭代器对象。字典迭代器在每次迭代中产生关键字列表元素。 >>> D={'a':1,'b':2,'c':3} >>> x=inter(D) >>> x.next()  'a' >>> x.next() 'c' >>> x.next() 'b' >>> x.next() Traceback (most recent call last):   File "<stdin>", 所有迭代内容（包括for循环，map调用，列表解析等）一次设计用来自动调用iter函数。 通过支持迭代协议的类来实现任意的生成器对象是可能的，并且已经有很多这样的对象，在for循环和其他的迭代环境中使用。 这样的类定义了一个特别的__iter__方法，它将返回一个迭代对象。 4、生成器表达式：迭代器遇到列表解析 迭代器和列表解析的概念形成了这个语言的一个新的特性，生成器表达式。 (八)函数设计概念 *耦合性：对于输入使用参数，并且对于输出使用return语句 *耦合性：只有在真正必要的情况下使用全局变量。 *耦合性：不要改变可变类型的参数，除非调用者希望这样做。 *聚合性：每一个函数都应该有一个单一的，同一的目标 *大小：每一个函数应该相对较小。 *耦合：避免直接改变在另一个模块文件中的变量。 函数是对象：简洁调用 (九)函数陷阱 1、本地变量是静态检测的 >>> X=99 >>> def selector(): >>> def selector(): ...     import __main__ ...     print __main__.X ...     X=88 ...     print X ... >>> selector() 99 88 >>> X 99 所有的全局变量都再 __main__。 __main__就是顶层的命名空间.__main__.X得到了全局变量版本的X。 这里使用模块的属性标记来获得其全局变量。 2、默认和可变对象。 默认参数是在def语句运行时被评估并保存的，而不是在这个函数调用时。从内部来将，Python会将每一个默认 参数保存成一个对象。附加在这个函数本身。 3、没有return语句的函数 函数中return和yield语句是可选择。没有返回值函数自动返回None对象。 这样的函数被当做语句，就像他们只执行任务而不要计算有用的结果一样。 4、嵌套作用域的循环变量