Python学习笔记整理(十二)Python的函数

741057228我QQ

　　一、函数基础
　　函数可以计算出一个返回值。作用：最大化代码重用，最小化代码冗余，流程的分解
　　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 &quot;<stdin>&quot;,
　　所有迭代内容（包括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、嵌套作用域的循环变量