python Function(函数)

  • 2020 年 1 月 13 日
  • 筆記

函数是python为了代码最大程度地重用和最小化代码冗余而提供的基本程序结构。函数是一种设计工具,它能让程序员将复杂的系统分解为可管理的部件; 函数用于将相关功能打包并参数化。 在python中可以创建如下4种函数:     1)、全局函数:定义在模块中(直接定义在模块中的函数)。     2)、局部函数:嵌套于其它函数中(在函数中再定义的函数)。     3)、lambda函数:表达式。匿名函数(它仅是一个表达式),它可以出现在任何位置,很高的录活性。     4)、方法:与特定数据类型关联的函数,并且只能与数据类型相关一起使用。定义在类中的函数。    python也提供了很多内置函数 函数与过程的区别:     函数都有return返回值。返回一个对象 创建函数     def functionName(parameters):         suite 相关概念:     def 是一个可执行语句;因此可以出现在任何能够使用的地方,甚至可以嵌套于其它语句,例if或while中。def创建了一个对象  并将其赋值给一个变量名(即函数名);     return用于返回结果对象,其为可选项;无return语句的函数自动返回一个None对象;返回多个值时,彼此间使用逗号分隔,且组合为元组形式返回一个对象。     def语句运行之后,可以在程序中通过函数名后附加括号进行调用 。     例1:

def printName():      print "hello"                  printName()            def testFun():      pass  testFun()

    例2:(注意函数的返回值)

   def login(username):           if username == "Thompson":               print "登录成功"           else:               print "登录失败"                 if __name__ == "__main__" :           uname=raw_input("Please enter your name:")           login(uname)             例3:(注意函数的返回值)       def login(username):           if username == "Thompson":               return "登录成功"           else:               return "登录失败"             def detail(username):           print username,"detail information"                     if __name__ == "__main__" :           uname=raw_input("Please enter your name:")           result = login(uname)           if result == "登录成功" :               detail(uname)           else:               print result

    例4:函数可以定义多个形参,可以为形参设置默认值,但设置默认值的形参必须放置在参数列表的最后一个

    def func1(username,action="听课"):           print username,":",action       func1("tom")       func1("eric","吃饭")      例5:       def func1(username,where="北京",action="听课"):           print username,":去",where,action       func1("tom")       func1("jack","上海")       func1("eric",action="吃饭")

函数的作用域:(变量查找的名称空间)     变量名在程序中赋值的位置决定了其能够被访问到的范围。函数定义了本地作用域,即函数内定义的变量,只能生效于本函数内部。模块定义了全局作用域。即在本python脚本中定义的变量,生效于本脚本的任意位置。     变量名引用分三个作用域:首先本地、然后函数内、接着是全局,最后是内置。     说明:在函数1中嵌套的函数2,在函数2中定义的变量称为“本地”;在函数1中定义的变量称为函数外层的;     Python创建、改变或查找变量名都是在名称空间中进行;在代码中变量名被赋值的位置决定了其能被访问到的范围。

    函数定义了本地作用域,而模块定义了全局作用域;每个模块都是一个全局作用域,因此全局作用域的范围仅限于单个程序文件;每次对函数的调用都会创建一个新的本地作用域,赋值的变量除非声明为全局变量,否则均为本地变量。     所有的变量名都可以归纳为本地、全局或内置(由__builtin__模块提供)

def f1():      y = 3      print y  f1()  print y 抛出异常  #!/usr/bin/python27  x = 32  def f1():      x = 43      print x  f1()  print x  chmod +x  test1.py  ./test1.py  x = 32  def f1():      y = 43      print x,y  f1()  print x,y  global x    将x定义为全局变量(在本地范围内定义全局变量时使用)  x = 43  print x

    LEGB 原则:  local → enclosing → global → builtin  例:

x = 5  z = "global"  def f1():      x = "from f1"      y = 3      print x,z      def f2():          x = "from f2"          print x,y,z      f2()  f1()  输出结果为:  from f1 global  from f2 3 global  def f1():      x =3      def f2():          y = "hello"          print x,y      return f2  a1 = f1()  type(a1)  a1()

函数的参数:     def funcName(arg1,arg2….):    例:

def f1(x):          print x  f1(4)  f1('abcd')    def f2(x,y):          print x+y  f2(3,4)  f2("hello","world")    m=3;n=4  def f3(x,y):      x -= 1      print x,y  f3(m,n)  print m,n   注意:比较结果值。m、n为数值,是不可变类型,所以m、n的数据不变。    l1 = [1,2,3]  def f4(x)      x.pop()      print x  f4(l1)      将l1对象传递给函数f5  print l1    比较两次的结果相同,因为列表为可变类型    l1 = [1,2,3]  def f5(x):      x.pop()      print x  f5(l1[:])       将l1做切片之后的所有值传递给函数f5

函数参数的匹配模型:     默认情况下,参数通过其位置进行传递,从左至右,这意味着必须精确地传递和函数头部参数一样多的参数。但也可以通过关键字参数、默认参数或参数容器等  改变这种机制。     位置:从左至右     关键字参数:使用"name=value"的语法通过参数名进行匹配(如果关键字参数与位置参数混合时,位置参数必须放在参数列表的左边,所有位置参数写完后,才可以放置关键字参数)     默认参数:定义函数时使用"name=value"的语法直接给变量一个值,从而传入的值可以少于参数个数。(混用有默认和无默认值的参数时,无默认值的参数需放前面)     可变参数:定义函数时使用*开头的参数,可用于收集任意多基于位置的参数;定义函数时使用**,收集关键字参数。     可变参数解包:调用函数时,使用*开头的参数,可用于将参数集合打散,从而传递任意多基于位置或关键字的参数。        例:

def f10(*x):      print x  f10(m)  f10(m,n)  f10(m,n,z)    def f11(**x):      print x  f11(x=1,y=2,z=9)     #收集关键字参数,并以字典的形式返回。    def f12(x,*y):       #可变参数必须写在后面,不可变参数必须写在左侧(前面)      print x,y  f12(m,n,o)           #函数调用时,将m的值传递给x,将n与o的值传递给y,y会以元组的形式返回结果    def f15(*x,**y):      print x      print y  f15(m,n,o,i=3,j=6)   #位置参数被"*x"收集,而关键字参数被"**y"收集    l1=['sun','mon','tus']  x,y,z = l1  print x,y,z          #将列表分解赋值    def f17(x,y,z):      print x,y,z  f17(*l1)             #将l1的值分解,并分别传递给变量x、y、z。要求被分解对象的元素个数 要与 函数定义的形参个数相同。                         #调用函数时使用*是为了分解参数对象,定义时使用*是为了整合。  def f18(x,*y):      print x      print y  f18(m,*l1)      #将m的值传递给x,将 l1对象中的元素分解后,传递给y    d1={'key1':'v1','key2':'v2','key3':77}  def f19(x,*y,**z):      print x      print y      print z  f19(m,*l3,**d1)     #将m的值传递给x,将l3对象中的元素分解后以元组的形式传递给y,将d1字典对象中的键值对儿分解,并以字典的形式传递给z    #顺序必须是:先位置参数、再任意位置参数、最后任意关键字参数  f19(m,n,o,**d1)     #将m传递给x,将n与o传递给y,将字典d1对象分解后传递给z  f19(m,n,z,key1='v1',key2='v2')      #将m传递给x,将n与o传递给y,将关键参数key1='v1',key2='v2'传递给z

python闭包:lexical closure     在函数嵌套环境中,如果外层函数直接返回内层函数(即把内层函数做为一个对象当做返回值),而且内层函数调用了外层函数的变量,那么内层函数会自动记忆外层函数的变量值。 它称为函数的闭合,也称为工厂函数。          例:        def f1(x):            def f2(y):                return y ** x            return f2       函数有嵌套,外层函数会将整个内层函数做为一个函数对象返回,而且内层函数还调用了外层函数定义的变量,此时内层函数会记忆外层函数的相关变量值,这种函数称为闭合函数。        f3=f1(3)    执行f1(3),将3传递给x,然后外层函数将“内层函数整体”作为一个对象的方式返回并赋值给f3变量。此时的f3 就是内层函数对象,此时的内层函数对象已记忆了x的值为3。        type(f3)    查看f3的类型为函数对象        f3(2)      调用f3这个函数对象,并将2传递给y变量,则最终结果返回 2 ** 3 (即2的3次方)        f3(3)       本次调用就是计算 3 ** 3        f3(4)       本次调用就是计算 4 ** 3        以上的函数也称为工厂函数或闭合函数或函数的闭合特性。        例: f3 = f1(4)        f3(3)       本次就是计算的 3 ** 4 (即3的4次方)     内层函数才是一个真正的函数,而外层函数仅仅是内层函数运行的环境而已。外层函数主要是为内层函数提供运行环境。                def startPos(m,n):            def newPos(x,y):                print "The old position is (%d,%d),and the new position is (%d,%d)." % (m,n,m+x,n+y)            return newPos        action = startPos(10,10)        action(1,2)        action(-1,3) 匿名函数lambda:     lambda仅仅是个表达式,但它有函数的特性;def是个语句。     lambda运算符     lambda args: expression         args: 以逗号分隔的参数列表         expression : 用到args中各参数的表达式     lambda语句定义的代码必须是合法的表达式,不能出现多条件语句(可使用if的三元表达式)和其它非表达式语句,如for和while等。     lambda的首要用途是指定短小的回调函数     lambda将返回一个函数而不是将函数赋值给某变量名。     注意:lambda是一个表达式而非语句;lambda是一个单个表达式,而不是一个代码块     例:        f20 = lambda x,y: x+y       lambda本身没有名称,在调用时才为它赋一个变量名(函数名)。        f20(3,4)        它返回3+4的结果;它的效果等同于以下函数:        def f20(x,y):            return x+y        f20(3,4)        f=lambda x,y,z: x+y+z        f(4,5,6)        f2=(lambda x,y,z=10: x+y+z)        f2(4,5)     def 语句创建的函数将赋值给某变量名,而lambda表达式则直接返回函数。lambda可以实现简单函数速写的功能。                     l3 = [ (lambda x: x*2), (lambda y: y*3) ]     for i in l3:         print i(4)      i的值为lambda函数,i(4)表示将4传递到函数中,最终返回函数的值 装饰器     也称为函数装饰器,它自身是个函数,作用是能够增强其它函数的功能。     函数代码重用,函数功能在不同场景中重用。     1)、装饰器本身是一个函数,用于装饰其它函数     2)、增强被装饰函数的功能:     装饰器需要接收一个函数对象做为参数,然后对其函数做包装(即增强该函数的功能)。     装饰器是一个很著名的设计模式,经常被用于有切面需求的场景,较为经典的有插入日志、性能 测试、事务处理等。装饰器是解决这类问题的绝佳设计,有了装饰器,就可以  抽离出大量函数中  与函数功能本身无关的雷同代码  并继续重用。概括的讲,装饰器的作用是  为已经存在的对象添加额外的功能。 例1:使用装饰函数在函数执行前和执行后分别附加额外功能

def myfunc():      print "myfunc called"  def deco(func):      print "before myfunc() called"      func()      print "after myfunc() called"      return func  deco(myfunc)
       In [5]: def f1():             ...:     print "hello uplooking"             ...:     print "welcome to python"             ...:               In [6]: def f2(func):             ...:     print "before ........"             ...:     func()             ...:     print "after........"             ...:               In [7]: f2(f1)          before ........          hello uplooking          welcome to python          after........

例2:使用语法糖@来装饰函数

def deco(func):      print "before myfunc() called"      func()      print "after myfunc() called"      return func  @deco  def myfunc():      print "myfunc called"
       In [11]: def f3(func):              print "before .............."              func()                            print "after ..............."             ....:          In [12]: @f3                    def f4():                                      print "xxxxxxxxxxxx"              print "yyyyyyyyyyyyy"             ....:               before ..............          xxxxxxxxxxxx          yyyyyyyyyyyyy          after ...............                        或:          def myfunc(x):              return x          def deco(func):              def _deco(x):                  return func(x)*x                   # 不需要返回func,实际上应返回原函数的返回值              return _deco           myfunc=deco(myfunc) #前一个myfunc仅是自定义的变量名,后一个myfunc是上面的函数名;等号右侧的表达式返回一个函数          print myfunc(2) #执行返回的新函数(也就是说将上面定义的myfunc函数代入deco的_deco本地函数,然后执行)                    In [21]: def f1(number):              return number+10             ....:           In [22]: def deco(func):              def _deco(x):                  return func(x)*x              return _deco             ....:           In [23]: f2=deco(f1)          In [24]: f2(5)          Out[24]: 75

例3:使用内嵌包装函数来确保每次新函数都被调用 内嵌包装函数的形参和返回值与原函数相同,装饰函数返回内嵌包装函数对象

def deco(func):      def _deco():          print "before myfunc() called"          func()          print "after myfunc() called"      return _deco  @deco  def myfunc():   #将myfunc()函数作为参数的形式传递给deco函数的func参数      print "myfunc called"  myfunc()

例4:对带参数的函数进行装饰 内嵌包装函数的形参和返回值与原函数相同,装饰函数返回内嵌包装函数对象

def deco(func):      def _deco(a,b):          print "before myfunc() called"          ret=func(a,b)          print "after myfunc() called"          return ret      return _deco  @deco  def myfunc(a,b):      print "myfunc(%s,%s) called" % (a,b)      return a+b  myfunc(1,2)
       In [27]:  def deco(func):              def _deco(x,y):                 print ".....function before......."                 result=func(x,y)                 print ".....function after ......"                 return result              return _deco             ....:           In [28]: @deco             ....: def f1(i,j):             ....:     print "%d * %d = %d" % (i,j,i*j)             ....:     return i*j             ....:           In [31]: f1(4,6)          .....function before.......          4 * 6 = 24          .....function after ......          Out[31]: 24

例5:对参数数量不确定的函数进行装饰

def deco(func):      def _deco(*args,**kwargs):          print "before %s called." % func.__name__          ret=func(*args,**kwargs)          print "after %s called. result: %s" % (func.__name__, ret)          return ret      return _deco  @deco  def myfunc(a, b):      print "myfunc(%s,%s) called." % (a, b)      return a+b  @deco  def myfunc2(a, b, c):      print "myfunc2(%s,%s,%s) called." % (a, b, c)      return a+b+c  myfunc(1, 2)  myfunc(3, 4)  myfunc2(1, 2, 3)  myfunc2(3, 4, 5)

例6:在例5的基础上,让装饰器带参数,和上一示例相比在外层多了一层包装。装饰函数名实际上应更有意义些

def deco(arg):      def _deco(func):          def __deco():              print "before %s called [%s]." % (func.__name__, arg)              func()              print "after %s called [%s]." % (func.__name__, arg)          return __deco      return _deco  @deco("mymodule")  def myfunc():      print(" myfunc() called.")  @deco("module2")  def myfunc2():      print(" myfunc2() called.")  myfunc()  myfunc2()
      In [48]: def deco(arg):             ....:     def _deco(func):             ....:         def __deco(*args):             ....:             print "======function before======"             ....:             func(*args)             ....:             print "function after: %s , %s " % (func.__name__,arg)             ....:         return __deco             ....:     return _deco             ....:           In [49]: @deco("module1")             ....: def f1(var):             ....:     print "enter arguments:%s" %var             ....:               In [50]: @deco("module2")             ....: def f2(x,y):             ....:     print "%d * %d = %d" % (x,y,x*y)             ....:               In [55]: f1("test")          ======function before======          enter arguments:test          function after: f1 , module1           In [56]: f2(4,6)          ======function before======          4 * 6 = 24          function after: f2 , module2           In [57]:

例7:让装饰器带 类 参数

class locker:      def __init__(self):          print("locker.__init__() should be not called.")      @staticmethod      def acquire():          print("locker.acquire() called.(这是静态方法)")      @staticmethod      def release():          print("  locker.release() called.(不需要对象实例)")  def deco(cls):      '''cls 必须实现acquire和release静态方法'''      def _deco(func):          def __deco():              print("before %s called [%s]." % (func.__name__, cls))              cls.acquire()              try:                  return func()              finally:                  cls.release()          return __deco      return _deco  @deco(locker)  def myfunc():      print(" myfunc() called.")  myfunc()  myfunc()

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

def fact(n):      if n<=1: return 1      else: return n*fact(n-1)

       fact(3)  就相当于 3 * fact(3-1) = 3 * 2 * face(1) = 3 * 2 * 1        fact(6)        fact(10) Python函数式编程: 函数式编程:也称为泛函编程,是一种编程范型。它将电脑运算视为数据上的函数计算,并且避免状态以及可变数据。函数式编程语言最重要的基础是lambda演算,而且lambda演算的函数可以接受函数当作输入、输出。     python支持有限的函数式编程功能:     filter(func,seq)    调用一个布尔函数func来迭代遍历每上seq中的元素;返回一个使func返回值为true的元素的序列。     map(func,seq1[,seq2…]) 将函数func作用于给定序列(seq1)的每个元素,并用一个列表来提供返回值;如果func为None,func表现为一个身份函数,返回一个含有每个序列中元素集合的n个元组的列表。     reduce(func,seq[,init]) 将二元函数作用于seq序列的元素,每次携带一对(先前的结果以及下一个序列元素),连续地将现有的结果和下一个值作用在获得的随后的结果上,最终将序列减少到一个单一的返回值;如果指定初始值init,第一个比较会是init和序列中的第一个元素,而不是序列的前两个元素。 filter过滤器 例:

def f1(x):      if x > 20:          return True      else:          return False  l1=[1,5,10,30,80,100]  filter(f1,l1)       返回一个符合条件的列表

       filter()为已知序列的每个元素调用给定的布尔函数        调用中,返回值为非零值的元素将被添加至一个列表中        作业:/etc/passwd文件中,返回 /bin/bash字串的用户名         map()映射器        map() 将函数调用"映射"到每个序列的对应元素上,并返回一个含有所有返回值的列表        map()将使用func函数对不同序列的同一个元素作运算处理,并将每个元素的处理结果整合成一个元组,最后将所有元组再返回成一个元组列表  例:

l1=[0,1,2,3,4,5,6]  l2=['Sun','M','Tu','W','T','F','S']  map(None,l1,l2)     由于func为None,所以将返回[(0,'Sun'),(1,'M'),(2,'Tu'),(3,'W'),(4,'T'),(5,'S'),(6,'S')] 的一个元组列表  def f3(x):      return x*2  map(f3,l1)  map(f3,l2)    def f4(x,y):      return x*2,y*2  map(f4,l1,l2)

reduce() 只接收两个参数,返回一个值

def f5(x,y):      return x+y  reduce(f5,l1)       即将l1列表中的每个元素相加,返回结果  reduce(f5,l1,10)    将初始值加上l1 列表中的每个元素,返回最终结果。   >>> list1=range(10)  >>> print list1  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  >>> filter(lambda x:x%2==0,list1)  [0, 2, 4, 6, 8]  >>> map(lambda x:x**2,list1)  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]  >>> list2=map(lambda x:x**2,list1)  >>> reduce(lambda x,y:x+y, list2)

zip函数

list1=[1,2,3,4]  list2=['a','b','c','d']  list3=[11,22,33,44]  print zip(list1,list2,list3)  输出结果为:[(1, 'a', 11), (2, 'b', 22), (3, 'c', 33), (4, 'd', 44)]

    随机函数:        import random        print random.random()        #生成0至1之间的小数        print random.randint(1,5)        #生成1至5的整数        print random.randrange(1,5)        #生成1至4的整数        例:生成六位随机数        code=[]        for i in range(6):            if i==random.randint(1,5):                code.append(str(i))            else:                code.append(chr(random.randint(65,90)))        print "".join(code) 内置md5函数:        import hashlib        hash=hashlib.md5()        hash.update("admin")        print hash.hexdigest()        print hash.digest() 常用内置函数:        print 3*4        print eval("3*4")        #算术运算字符串表达式        print divmod(9,4)        #返回表达式的商及余数        print pow(2, 10)        #返回2的10次方        print chr(65)        #返回Ascii码65对应的字符        print ord("a")        #返回字符"a"对应的Ascii码        list2=["aa","bb","cc"]        for item in enumerate(list2):            print item         #遍历出列表中每个元素的值与对应下标        id  type    import      reload      help        dir     var        dir()和vars()的区别就是dir()只打印属性(属性,属性……)而vars()则打印属性与属性的值(属性:属性值……)        自定义字符串的格式化输出:        str1='I am {0},the working of the {1}'        print str1.format("tom","computer")        输出结果为:I am tom,the working of the computer        执行函数时也可以使用apply(function_name())的方式 总结:    在python语言中,定义(声明)函数时,使用def语句。    def function_name(arg1,….):        func_suite    当程序遇到def时就会生成一个函数对象,并且这个函数对象被命名为func_name(该名称从某种角度上也可以理解成一个变量名,只是该变量名是为了引用一个函数对象而建立的),并生成函数体。此函数对象靠函数名来引用。函数体内部的语句只有在函数被调用时才会被执行,而函数结束时( 函数返回后),其内部生成的数据都会被销毁。     列表解析与生成器:     for i in ( j**2 for j in range(1,11)):         print i     生成器不能相列表解析一样将某个元素弹出或添加新元素或切片等。因为生成器并不是列表,它只是模拟了列表的一些行为。所以列表的很多功能在生成器中是无法实现的。     可以使用list将生成器转换成列表     list((i**2 for i in range(1,11)))     生成器本身是延迟计算。可以使用自定义函数实现生成器的功能,如下:     def genNum(x):         y = 0         while y <= x:             yield y         yield将返回一个生成器对象。而且每次函数执行都会记录前一次的结果。             y +=1             g1=genNum(10)     type(g1)     g1.next()     g1.next()     def genNum2(n):         m = 1         while m <= n:             yield m**2             m +=1     g2 = genNum2(20)     for i in g2:         print i     函数中使用yield,会返回一个生成器对象。     协程:yield写在表达式右侧,实现协程目的     函数的设计规范:     耦合性:     (1)尽可能通过参数授受输入,适就更多场景。以及通过return产生输出,以保证函数的独立性。     (2)尽量减少使用全局变量进行函数间通信。     (3)不要在函数中修改可变类型的参数。     (4) 避免直接改变定义在另外一个模块中的变量。     聚合性:     (1)每个函数都应该有一个单一的、统一的目标。     (2)每个函数的功能都应该相对简单。     输入:参数、全局变量、文件/流     输出:return语句、可变参数、全局变量、文件/流