python之函数

Posted 2020-08-24

防伪码：忘情公子著

函数是Python为了代码最大程度地重用和最小化代码冗余而提供的基本程序结构。

函数是一种设计工具，能让程序员将复杂的系统分解为可管理的部件，在需要时能够按需去调用这些部件。

函数用于将相关功能打包并参数化

在Python中可以创建4种函数：

 全局函数：定义在模块中

  局部函数：嵌套于其它函数中

  lambda（匿名）函数：仅是一个表达式，可以出现在任何位置，使用的灵活度比函数强得多。它生成一个函数对象，若想多次调用，则应将其赋予某变量名进行调用

  方法：与特定数据类型关联的函数，并且只能与数据类型关联一起使用。说白了就是定义在类(class)中的函数

创建函数，语法如下：

def functionName(parameters):
    suite

def是一个可执行语句，因此可以出现在任何能够使用语句的地方，甚至可以嵌套于其它语句，例如if或while中。

def创建了一个对象并将其赋值给一个变量名（即函数名）。

return用于返回结果对象，其为可选；无return语句的函数自动返回None对象。返回多个值时，彼此间使用逗号分隔，且组合为元组形式返回一个对象。

def语句运行之后，可以在程序中通过函数后附加括号进行调用。如：

In [1]: def printName():    #定义一个函数printName
   ...:     print "hello"
   ...: 

In [2]: printName()         #调用函数printName
hello

Python创建、改变或查找变量名，都是在名称空间中进行的。名称空间（作用域）说白了就是一个变量所能够生效的范围。

在Python中，变量名在程序代码中被赋值的位置，决定了其能够被访问到的范围。

函数定义了本地作用域，而模块定义了全局作用域

  每个模块都是一个全局作用域，因此，全局作用域的范围仅限于单个文件；

  每次对函数的调用都会创建一个新的本地作用域，赋值的变量除非声明为全局变量，否则均为本地变量；

  所有的变量名都可以归纳为本地、全局或内置的（由__builtin__模块提供）

变量名引用分三个作用域进行：首先是本地、之后是函数内、接着是全局，最后是内置。

变量名解析遵循由内而外的法则，也即LEGB原则（如上图）。变量解析时有几点需要注意：

  先从Local(function)中查找，找到则返回解析结果，若找不到则到Enclosing function locals中查找；

  若在Enclosing function locals中找到了则返回解析结果，若找不到则到Global(module)中查找；

  若在Global(module)中找到了则返回解析结果，若找不到则到Built-in中查找；

  若在Built-in中找到了则返回解析结果，若找不到则返回“名称引用错误”异常

变量名解析时，作用域越小，其优先级越高。也就是说，若在Local(function)中找到了，则直接返回其解析结果，而不会再到Enclosing function locals上去查找了。

全局变量：

  全局变量是模块文件内部的顶层变量名；

  如果要在函数内部对全局变量进行赋值的话，必须事先使用global进行声明，global关键字后跟一个或多个由逗号隔开的变量名；

  全局变量名在函数内部不经声明也可以被引用；

  本地变量在函数返回时会消失，而全局变量不会，因此，使用全局变量是保存函数状态信息的最直接办法；

  尽量避免在函数中使用global声明全局变量。

内嵌函数：

  Python中函数可以嵌套，也即可以在一个函数内部定义一个函数；

  在函数内部定义的函数仅能由外层函数进行调用；

  而如果外层函数直接把内层函数使用return返回，则调用外层函数时赋值的变量名引用的是一个内层函数对象，且此内层函数能够记忆其内部引用的外层函数的变量，这种行为叫做工厂函数，也叫闭合函数

In [11]: def maker(N):
    ...:     def action(X):
    ...:         return X ** N
    ...:     return action
    ...:

In [12]: f = maker(2)

In [13]: f(3)
Out[13]: 9

In [14]: f(4)
Out[14]: 16

In [15]: type(f)
Out[15]: function

参数传递：

  参数的传递是通过自动将对象赋值给本地变量实现的

  不可变参数通过“值”进行传递，在函数内部改变形参的值，只是让其引用了另一个对象（如数字）

  可变参数通过“指针”进行传递，在函数内部改变形参的值，将直接修改引用的对象（如列表）

有两种方式可避免可变参数被函数修改：

  1、直接传递可变对象的副本：

In [16]: L = [1,2,3,4]

In [17]: def changer(X):
    ...:     X[2]+=10
    ...:     return X
    ...:

In [18]: changer(L[:])
Out[18]: [1, 2, 13, 4]

In [19]: print L
[1, 2, 3, 4]

  2、在函数内部创建可变参数的副本

In [27]: L = [1,2,3,4]

In [28]: def changer(X):
    ...:     aa = X[:]
    ...:     aa[2]+=10
    ...:     return aa
    ...:

In [29]: changer(L)
Out[29]: [1, 2, 13, 4]

In [30]: print L
[1, 2, 3, 4]

参数匹配模型：

默认情况下，参数通过其位置进行传递，从左至右，这意味着，必须精确地传递和函数头部参数一样多的参数

但也可以通过关键字参数、默认参数或参数容器等改变这种机制

  位置：从左至右

  关键字参数：使用“name=value”的语法通过参数名进行匹配

  默认参数：定义函数时使用“name=value”的语法直接给变量一个值，从而传入的值可以少于参数个数

  可变参数：定义是为了整合，调用是为了分解

    定义函数时使用*开头的参数，可用于收集任意多基于位置的参数：

In [31]: def test(*x):
    ...:     print x
    ...: 

In [32]: test(1)
(1,)

In [33]: test(1,2,3)
(1, 2, 3)

    定义函数时使用**开头的参数，可用于收集任意多基于关键字参数，并将其转换成字典：

In [34]: def dict(**x):
    ...:     print x
    ...: 

In [35]: dict(x=1,y=2,z=6)
{‘y‘: 2, ‘x‘: 1, ‘z‘: 6}

   混用位置参数与可变参数：

In [36]: def a(x,*y):
    ...:     print x,y
    ...: 

In [37]: a(1,2,3,4)
1 (2, 3, 4)

In [38]: def b(*x,**y):
    ...:     print x
    ...:     print y
    ...: 

In [39]: b(1,2,3,4,5,i=3,j=9,c=5)
(1, 2, 3, 4, 5)
{‘i‘: 3, ‘c‘: 5, ‘j‘: 9}

  可变参数解包：调用函数时，使用*开头的参数，可用于将参数集合打散，从而传递任意多基于位置或关键字的参数。可以理解为分解参数。

   变量分解赋值：

In [1]: l1 = [‘Sun‘,‘Mon‘,‘Tue‘]

In [2]: x,y,z = l1

In [3]: print x
Sun

In [4]: print y
Mon

In [5]: print z
Tue

In [6]: l2 = [‘Sun‘,‘Mon‘,‘Tue‘]

In [7]: def a(x,y,z):
   ...:     print x,y,z
   ...: 

In [8]: a(*l2)
Sun Mon Tue

可变参数与位置参数混合使用时，不论是定义还是调用，均使用以下顺序：

  位置参数-->任意位置参数（*）-->关键字参数（**）

匿名函数lambda：

语法如下：

lambda args: expression

  args：以逗号分隔的参数列表

  expression：用到args中各参数的表达式

lambda语句定义的代码必须是合法的表达式，不能出现多条件语句（可使用if的三元表达式）和其它非表达式语句，如for和while等。

lambda的首要用途是指定短小的回调函数。lambda将返回一个函数而不是将函数赋值给某变量名。

注意：

  lambda是一个表达式而非语句；

  lambda是一个单个表达式，而不是一个代码块

In [9]: lambda x,y: print x,y    #不能是语句，只能是表达式
  File "<ipython-input-9-323c5186b793>", line 1
    lambda x,y: print x,y
                    ^
SyntaxError: invalid syntax


In [10]: lambda x,y: x + y        #返回的是一个函数
Out[10]: <function __main__.<lambda>>

因为lambda返回的是一个函数，所以如果要调用它的话，则要将lambda表达式赋予一个变量名，通过变量名来调用：

In [11]: a = lambda x,y: x + y

In [12]: a(5,6)
Out[12]: 11

正因为lambda函数调用时必须赋予给某个变量名，通过变量名来调用，而这个变量名又不固定，故此称之为匿名函数。

def语句创建的函数将赋值给某变量名，而lambda表达式则直接返回函数。lambda也支持使用默认参数。

In [13]: def testFunc(x,y,z):
    ...:     return x + y + z
    ...:

In [14]: testFunc(4,5,6)
Out[14]: 15

In [15]: f = lambda x,y,z: x+y+z

In [16]: f(4,5,6)
Out[16]: 15

In [17]: f2 = (lambda x,y,z=10: x+y+z)

In [18]: f2(4,5)
Out[18]: 19

在对某个数据对象作出多种不同处理时，可以把每一种处理机制定义成一个lambda，而后对这个数据对象调用这多个lambda表达式。

In [1]: l3 = [ (lambda x: x*2),(lambda y: y*3) ]

In [2]: for i in l3:        #i取到的是lambda表达式，而不是x和y的值
   ...:     print i(4)
   ...: 
8
12

本文出自 “忘情博” 博客，请务必保留此出处http://itchentao.blog.51cto.com/5168625/1884653