【Python基础】06、Python函

发布时间：2019-09-20 07:29:22编辑：auto阅读（1518）

一、函数概述

1、函数的基础概念

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


       函数是一种设计工具，它能让程序员将复杂的系统分解为可管理的部件


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

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

              全局函数：定义在模块中

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

              lambda（匿名）函数：仅是一个表达式

               方法：与特定数据类型关联的函数，并且只能与数据类型关联一起使用

函数和过程的联系：每个Python函数都有一个返回值，默认为None，也可以使用“return value”明确定定义返回值

       python提供了很多内置函数  




二、创建函数

1、语法

    def functionName(parameter1，parameter2):

               suite




2、一些相关的概念   

def是一个可执行语句

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

def创建了一个对象并将其赋值给一个变量名（即函数名上面语法中的functionName） 

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

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




3、parameters(参数)传递形式


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

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

             位置参数：从左向右

In [1]: a=1

In [2]: b=2

In [3]: def f1(x,y):
   ...:     print x,y
   ...:     

In [4]: f1(3,4)
3 4

In [5]: f1(a,b)
1 2

In [6]: f1(b,a)
2 1

             关键字参数：按关键名称匹配

In [7]: f1(x=1,y=2)
1 2

In [8]: f1(x=a,y=b)
1 2

In [9]: f1(y=b,x=a)
1 2

     混用上面两种方式时：必须先写所有位置参数，关键字参数放后面

In [11]: f1(a,y=a)
1 1

In [12]: f1(a,y=b)
1 2

In [14]: f1(a,y=3)
1 3

In [15]: f1(x=a,b)
  File "<ipython-input-15-9a92e2a15371>", line 1
    f1(x=a,b)
SyntaxError: non-keyword arg after keyword arg

     定义函数时使用默认参数：有默认值的参数

混用有默认值和无默认值的参数时，无默认值放前面，有默认值的放后面

In [23]: c=3

In [24]: def f2(x,y,z=10):print x,y,z

In [25]: f2(a,b)
1 2 10

In [26]: f2(a,b,c)
1 2 3

In [27]: f2(a,5,c,)
1 5 3

In [28]: f2(a,)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-27-9538a6a12c98> in <module>()
----> 1 f2(a,)

TypeError: f2() takes at least 2 arguments (1 given)

In [29]: f2(a,b,c,5)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-28-934459b06043> in <module>()
----> 1 f2(a,b,c,5)

TypeError: f2() takes at most 3 arguments (4 given)

In [30]: def f3(x,y=10,z):print x,y,z             
  File "<ipython-input-30-9aff61efd310>", line 1
    def f3(x,y=10,z):print x,y,z
SyntaxError: non-default argument follows default argument

                调用函数时使用可变参数要求：


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

定义函数时使用**开头的参数: 收集关键字参数，返回字典

                        使用可变参数和其它参数混合时，可变参数必须写在后面

In [38]: def f3(*x):print x

In [39]: f3(1,2,3,4,5)
(1, 2, 3, 4, 5)

In [40]: f3(a,b,c)
(1, 2, 3)

In [41]: f3(a,b,c=5)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-41-98bdba155a09> in <module>()
----> 1 f3(a,b,c=5)

TypeError: f3() got an unexpected keyword argument 'c'


In [42]: def f4(**x):print x

In [43]: f4(a,b,c=5)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-43-f755ca76d443> in <module>()
----> 1 f4(a,b,c=5)

TypeError: f4() takes exactly 0 arguments (3 given)

In [44]: f4(a=1,b=2,c=5)
{'a': 1, 'c': 5, 'b': 2}


In [45]: def f5(x,*y):print x,y

In [46]: f5(a,b)
1 (2,)

In [47]: f5(a,b,c)
1 (2, 3)

In [48]: f5(a,b,c=3)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-48-3b74f29f2a11> in <module>()
----> 1 f5(a,b,c=3)

TypeError: f5() got an unexpected keyword argument 'c'

In [49]: def f6(x,**y):print x,y

In [53]: f6(a,b,c=3)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-53-c2c798b5c0d9> in <module>()
----> 1 f6(a,b,c=3)

TypeError: f6() takes exactly 1 argument (3 given)

In [54]: f6(a,b=2,c=3)
1 {'c': 3, 'b': 2}


In [55]: def f7(*x,**y):print x,y

In [56]: f7(a,b,c)
(1, 2, 3) {}

In [57]: def f8(*x,y=3):print x,y
  File "<ipython-input-57-9024bc5a5148>", line 1
    def f8(*x,y=3):print x,y
              ^
SyntaxError: invalid syntax


In [58]: def f8(y=3,*x):print x,y

In [59]: f8(1,2,3)
(2, 3) 1

                  参数解包：

                          参数解包发生在函数调用时，

                           *用于解包序列为位置参数也可以解包字典为关键字参数

                           **用于解包字典为关键字参数                

In [64]: l1=["Sun","Mon","Tus"]

In [65]: x,y,z=l1                  #变量分解赋值

In [66]: x,y,z
Out[66]: ('Sun', 'Mon', 'Tus')

In [67]: x
Out[67]: 'Sun'

In [68]: print x
Sun


In [76]: def f9(x,y,z):print x,y,z

In [80]: l1=[1,2,3]

In [81]: f9(*l1)
1 2 3

In [82]: l2=[1,2,3,"a","b"]

In [83]: f9(*l2)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-83-be9366550ea7> in <module>()
----> 1 f9(*l2)

TypeError: f9() takes exactly 3 arguments (5 given)

In [84]: l3=[1,2]

In [85]: f9(*l3)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-85-eae6110eaf91> in <module>()
----> 1 f9(*l3)

TypeError: f9() takes exactly 3 arguments (2 given)

In [89]: f9(*l1)
1 2 3

In [90]: f9(**l1)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-90-13c8f289cb2c> in <module>()
----> 1 f9(**l1)

TypeError: f9() argument after ** must be a mapping, not list

In [93]: l3
Out[93]: [1, 2]

In [95]: a
Out[95]: 1

In [96]: f9(a,*l3)
1 1 2

In [97]: f9(x=5,*l3)          
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-97-f946fbd99d70> in <module>()
----> 1 f9(x=5,*l3)

TypeError: f9() got multiple values for keyword argument 'x'


In [6]: def f1(i,j,k):
    print i,j,k
   ...:   
     
In [2]: l1 = [1,2,3]   
   
In [7]: f1(l1)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-98b654179a30> in <module>()
----> 1 f1(l1)

TypeError: f1() takes exactly 3 arguments (1 given)

In [8]: f1(*l1)
1 2 3

In [9]: 

In [9]: d1={"i":2,"j":4,"k":6}

In [10]: f1(d1)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-15487112d5cd> in <module>()
----> 1 f1(d1)

TypeError: f1() takes exactly 3 arguments (1 given)

In [11]: f1(*d1)
i k j

In [12]: f1(**d1)
2 4 6

In [13]: f1(***d1)
  File "<ipython-input-13-8f8ec9970cf0>", line 1
    f1(***d1)
         ^
SyntaxError: invalid syntax

关键字：return

   return只能出现在函数中

        可以返回任何对象

        可以变相的返回多值

        所有函数都有返回值，如果没定义return则默认返回值None

In [35]: def f2():
    "a"
   ....:     

In [36]: x = f2()

In [37]: x

In [38]: print x
None

In [39]: type(x)
Out[39]: NoneType




4、匿名函数lambda


lambda运算符（语法格式）：


     lambda args:expression

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

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

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

  lambda的首要用途是指定短小的回调函数

       lambda将返回一个函数而不是将函数赋值给某变量名

注意：

        lambda是一个表达式而非语句

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

   def语句创建的函数将赋值给某变量名，而lambda表达式直接返回函数

         lambda也支持使用默认参数，关键字参数，容器参数       

In [28]: lambda x,y:x+y
Out[28]: <function __main__.<lambda>>


In [31]: f1=lambda x,y:x+y

In [32]: f1(1,2)
Out[32]: 3

In [33]: f1(1,2,3)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-33-95e364c9da29> in <module>()
----> 1 f1(1,2,3)

TypeError: <lambda>() takes exactly 2 arguments (3 given)

In [34]: f1(1,)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-34-6d213bebf73b> in <module>()
----> 1 f1(1,)

TypeError: <lambda>() takes exactly 2 arguments (1 given)


In [36]: f1(1,2,)
Out[36]: 3

相当于：

In [37]: def f2(x,y):return x+y

In [38]: f2(1,2)
Out[38]: 3




5、python函数式编程

函数式编程（高阶函数）：

       就是将函数当参数提供给另一个函数 

       也称作泛函编程，是一种编程范型

       它将电脑运算视为数学上的函数计算，并且避免状态一级可变数据

       函数式编程语言最重要的基础是lambda演算，而且lambda演算的函数可以接受函数当作输入和输出




python支持有限的函数式编程功能：`


filter(func,seq)    过滤器   

          调用一个布尔函数func来迭代遍历每个seq中的元素，返回一个使func返回值为true的元素序列 

          filter（）为已知的序列的每个元素调用给定的布尔函数


          调用中，返回值为非零值的元素将被添加至一个列表中

In [5]: def f1(x):
    if x>5:
        return True
    else:
        return False
   ...:     

In [6]: l1=[1,2,3,5,7,9]

In [7]: s1=(1,3,5,7,9,11)

In [8]: filter(f1(),l1)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-8-f9b5bc7e0cd6> in <module>()
----> 1 filter(f1(),l1)

TypeError: f1() takes exactly 1 argument (0 given)

In [9]: filter(f1,l1)
Out[9]: [7, 9]

In [10]: filter(f1,s1)
Out[10]: (7, 9, 11)

映射器

             map()将函数调用“映射”到每个序列的对应元素上并返回一个含有所有返回值的列表

map（func,seq1[,seq2...]）


            将函数func作用于给定序列（s）的每个元素，并用一个列表来提供返回值；如果func为None，func表现为一个身份函数，返回一个含有每个序列中元素集合的n个元祖的列表值的列表      

In [45]: l1=[0,1,2,3,4,5,6,7]

In [47]: l2=["S","M","T","W","T","F","S"]

In [48]: map(none,l1,l2)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-48-c9fb480193d7> in <module>()
----> 1 map(none,l1,l2)

NameError: name 'none' is not defined

In [49]: map(None,l1,l2)
Out[49]: 
[(0, 'S'),
 (1, 'M'),
 (2, 'T'),
 (3, 'W'),
 (4, 'T'),
 (5, 'F'),
 (6, 'S'),
 (7, None)]        #两个序列元素不相等时，补None
 
 
In [54]: s1=(0,1,2,3,4,5,6,7)

In [55]: s2=("S","M","T","W","T","F","S")

In [56]: map(None,s1,s2)   #None不对元素做运算
Out[56]: 
[(0, 'S'),
(1, 'M'),
(2, 'T'),
(3, 'W'),
(4, 'T'),
(5, 'F'),
(6, 'S'),
(7, None)]

reduce(func,seq[,init])

      折叠器

             将二元函数作用于seq序列的元素，每次携带一对（先前的结果以及下一个序列元素），连续地将现有结果和下一个值作用在获得的随后结果上，最后减少我们的序列为一个单一的返回值，如果初始值init给定，第一个比较会是init和第一个序列元素而不是序列的头两个元素

In [21]: l1
Out[21]: [0, 1, 2, 3, 4, 5, 6, 7]

In [22]: l2
Out[22]: ['S', 'M', 'T', 'W', 'T', 'F', 'S']

In [23]: def f2(x,y):return x+y

In [24]: reduce(f2,l1)
Out[24]: 28

In [25]: reduce(f2,l1,10)
Out[25]: 38

装饰器


    装饰器本身是一个函数，用于装饰其它函数，增强被装饰函数的功能


    一般接受一个函数对象作为参数，以对其进行功能增强

In [2]: def deco(func):
    def wrapper():
        print "Plz say something: "
        func()
        print "No zuo no die.."
    return wrapper
   ...: 

In [5]: @deco    #相当于new_func=deco(func),作为deco(func)的参数
def show():                   
    print "I am from Mars"
   ...:     

In [6]: show()
Plz say something: 
I am from Mars
No zuo no die..

可以看到show函数是作为deco函数的参数，是函数闭包的进一步应用



递归


       函数体内调用自身的函数       

       递归函数需要有合适的推出条件

       python递归深度最大为1000

       python中应尽量避免递归（能转化为迭代尽量转化为迭代）

       递归需要边界条件，递归前进段和递归返回段  

In [8]: def fact(n):
    if n<=1:return 1
    else:return n*(n-1)       #5x4
   ...:     

In [9]: fact(5)
Out[9]: 20

In [10]: def fact(n):
    if n<=1:return 1
    else:return n*fact(n-1)
   ....:     

In [11]: fact(5)        #5x4x3x2x1
Out[11]: 120

Python的闭包（工厂函数）：闭包叫lexical closure（词法闭包）

        外层函数主要为内层函数提供环境

        定义在外层函数内，却由内层函数引用的变量，在外层函数返回时，如果外层函数返回的值是内层函数，再次调用内层函数时，会记忆下内层函数调用的外层函数的变量。

In [1]: def f1(x):
   ...:     def f2(y):
   ...:         return y**x
   ...:     return f2
   ...: 
In [2]: type(f1)
Out[2]: function
In [3]: type(f2)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-3-de28406b4c7f> in <module>()
----> 1 type(f2)
NameError: name 'f2' is not defined
In [5]: f3=f1(3)
In [6]: type(f3)
Out[6]: function
In [7]: f3(2)
Out[7]: 8
In [8]: f3(3)
Out[8]: 27
In [9]: f3(4)
Out[9]: 64




三、函数的设计规范

耦合性：


   （1）通过参数接受输入，以及通过return产生输出以保证函数的独立性

        （2）尽量减少使用全局变量进行函数间通信

        （3）不要在函数中修改可变类型的参数

         （4）避免直接改变定义在另外一个模块中的变量




聚合性：

   （1）每个函数都应该有一个单一的，统一的目标

        （2）每个函数的功能都应该相对简单




函数执行环境：

       函数可以通过多种办法获得输入以及产生输出

     输入                  函数                           输出

参数                                                     return语句

全局变量              本地变量                  可变参数

文件/流                其它函数                   全局变量

                                                            文件/流




练习：

1、将/etc/passwd文件中的每一行都分隔为一个列表


2、将任意文件按用户指定的分隔符把每一行都分隔为一个列表

3、用折叠的方式(reduce)求阶乘




四、命名空间与LEGB

1、命名空间 

       理解Python的LEGB原则是理解Python命名空间的关键，而理解Python的命名空间又是理解Python中许多语法规定的关键。所以，Python的LEGB原则就成为Python中一个非常核心的内容

白话一点讲：命名空间是对变量名的分组划分。
       不同组的相同名称的变量视为两个独立的变量，因此隶属于不同分组（即命名空间）的变量名可以重复。
命名空间可以存在多个，使用命名空间，表示在该命名空间中查找当前名称。




       命名空间表示变量的可见范围，一个变量名可以定义在多个不同的命名空间，相互之间并不冲突，但同一个命名空间中不能有两个相同的变量名。

比如：两个叫“张三”的学生可以同时存在于班级A和班级B中，如果两个张三都是一个班级，那么带来的麻烦复杂很多了，在Python中你不能这么干。

      在Python中用字典来表示一个命名空间，命名空间中保存了变量（名字）和对象的映射关系，在Python中命名空间出现在哪些地方呢？有函数范围内的命名空间（local），有模块范围内的命名空间（global），有python内建的命名空间（built-in），还有类对象的所有属性组成的命名空间

Python一切皆对象，所以在Python中变量名是字符串对象

例如：

In [25]: a=10

      表示建立字符串对象a与Number对象10之间的对应关系。由于这是一种映射关系，所以，可以使用键-值的形式来表示，即{name : object}。
前面已经说过，命名空间是对变量名的分组划分，所以，Python的命名空间就是对许多键-值对的分组划分，即，键值对的集合，因此：

Python的命名空间是一个字典，字典内保存了变量名称与对象之间的映射关系




2、命名空间的生命周期

       所有的命名空间都是有生命周期的，对于python内建的命名空间，python解析器启动时创建，一直保留直至直python解析器退出时才消亡。而对于函数的local命名空间是在函数每次被调用的时候创建，调用完成函数返回时消亡，而对于模块的global命名空间是在该模块被import的时候创建，解析器退出时消亡。




3、作用域


  一个作用域是指一段程序的正文区域，可以是一个函数或一段代码。

       一个变量的作用域是指该变量的有效范围。Python的作用域是静态作用域，因为它是由代码中得位置决定的，而命名空间就是作用域的动态表现。

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


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

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

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

      

4、LEGB原则


LEGB含义解释：
       L-Local(function)；函数内的名字空间
       E-Enclosing function locals；外部嵌套函数的名字空间(例如closure)
       G-Global(module)；函数定义所在模块（文件）的名字空间
       B-Builtin(Python)；Python内置模块的名字空间，builtin作用域，对应builtin命名空间，python内部定义的最顶层的作用域，在这个作用域里面定义了各种内建函数：open、range、xrange、list等等      

 前面讲到，Python的命名空间是一个字典，字典内保存了变量名与对象之间的映射关系，

因此，查找变量名就是在命名空间字典中查找键-值对。
Python有多个命名空间，因此，需要有规则来规定，按照怎样的顺序来查找命名空间，LEGB就是用来规定命名空间查找顺序的规则。


  LEGB规定了查找一个名称的顺序为：local-->enclosing function locals-->global-->builtin

举例来说明：

[root@Node3 src]# vi test1.py

[root@Node3 src]# cat test1.py 
#!/usr/local/bin/python2.7

x=1

def foo():
    x=2                  
    def innerfoo():
        x=3
        print "locals",x                  #函数内x,同时也有外部嵌套函数foo()的x，全局x
    innerfoo()
    print "enclosing function locals",x    #函数内x ,全局x
foo()
print 'global',x                           #全局x

[root@Node3 src]# chmod +x test1.py 
[root@Node3 src]# ./test1.py 
locals 3
enclosing function locals 2
global 1

对上例稍加改动：

[root@Node3 src]# cat test1.py 
#!/usr/local/bin/python2.7

x=1

def foo():
    x=2
    def innerfoo():
#        x=3                   #注释掉
        print "locals",x
    innerfoo()
    print "enclosing function locals",x
foo()
print 'global',x

运行结果：

[root@Node3 src]# ./test1.py 
locals 2                                        #使用了外部嵌套的foo函数中的x
enclosing function locals 2           
global 1

     x = 3 属于函数内部命名空间，当被注释掉之后，函数innerfoo内部通过print x 使用x这个名称时，触发了名称查找动作。
首先在Local命名空间查找，没有找到，然后到Enclosing function locals命名空间查找，查找成功，然后调用。

对上例再修改一下：

[root@Node3 src]# cat test1.py 
#!/usr/local/bin/python2.7

x=1

def foo():
    x=2
    def innerfoo():
        global x                  #声明为全局变量
        x=3
        print "locals",x
    innerfoo()
    print "enclosing function locals",x
foo()
print 'global',x

[root@Node3 src]# ./test1.py 
locals 3
enclosing function locals 2
global 3                        #修改了全局变量


[root@Node3 src]# cat test1.py 
#!/usr/local/bin/python2.7

x=1

def foo():
    x=2
    def innerfoo():
        global x               #声明全局变量
       # x=3
        print "locals",x      
    innerfoo()
    print "enclosing function locals",x
foo()
print 'global',x
[root@Node3 src]# ./test1.py 
locals 1             #直接使用了全局变量
enclosing function locals 2    
global 1

[root@Node3 src]# cat ./test1.py
#!/usr/local/bin/python2.7

x=1

def foo():
    y=2
    def innerfoo():
        x=3
        print "locals",x,y
    innerfoo()
    print "enclosing function locals",x,y
foo()
print 'global',x,y

[root@Node3 src]# ./test1.py 
locals 3 2
enclosing function locals 1 2
global 1
Traceback (most recent call last):  #这里为什么会报错？内置模块和内置函数并不相等
  File "./test1.py", line 13, in <module>
    print 'global',x,y
NameError: name 'y' is not defined

[root@Node3 src]# cat test3.py
#!/usr/local/bin/python2.7

l1=[1,2,3]
a=3

def f1(x,y):
    x.pop()
    print x,y
f1(l1,a)
print l1,a
l1,a
[root@Node3 src]# ./test3.py 
[1, 2] 3                       #可变对象会发生改变
[1, 2] 3

关键字：