zoukankan      html  css  js  c++  java
  • python学习之---匿名函数,返回函数,偏函数

    1. 返回函数:

    所谓的返回函数,指的是函数作为返回值。高阶函数除了可以接受函数作为参数外,同样可以接受函数作为结果返回。以下是一个可变参数的求和例子,一般求和函数是如此这般定义的:

    1 >>> def sum(*args):
    2 ...     ax = 0
    3 ...     for x in args:
    4 ...         ax += x
    5 ...     return ax
    6 ... 

    以上函数一旦定义,在调用这个函数的时候,只要传入参数就会立刻执行。但是,如果条件需要不要立刻求和,而是在后面的代码中,根据需要再计算该怎么办?可以不返回求和的结果,而是返回求和的函数!

     1 >>> def lazy_sum(*args):
     2 ...     def sum():
     3 ...         ax = 0
     4 ...         for n in args:
     5 ...            ax = ax + n
     6 ...         return ax 
     7 ...     return sum
     8 ... 
     9 >>> 
    10 >>> lazy_sum(12)
    11 <function sum at 0x7f810add16e0>
    12 >>> lazy_sum((1,2,3,4,5,6))
    13 <function sum at 0x7f810add17d0>
    14 >>> 
    15 KeyboardInterrupt
    16 >>># 以上是调用lazy_sum()函数的结果返回的不是求和的结果,而是求和函数

    但是该如何才能够返回结果呢?演示如下:

    1 >>> result = lazy_sum(12,13,14,15,16,17,18,19)
    2 >>> result
    3 <function sum at 0x7f810add17d0>
    4 >>> #其实result现在是一个返回函数,要再调用该函数才可以返回结果
    5 ... 
    6 >>> result()
    7 124

    在这个例子中,我们在函数lazy_sum中又定义了函数sum,并且,内部函数sum可以引用外部函数lazy_sum的参数和局部变量,当lazy_sum返回函数sum时,相关参数和变量都保存在返回的函数中,这种称为“闭包(Closure)”的程序结构拥有极大的威力。

    请再注意一点,当我们调用lazy_sum()时,每次调用都会返回一个新的函数,即使传入相同的参数:

    1 >>> result1 = lazy_sum(1,2,3,4,5,6,7,8,9,10)
    2 >>> result2 = lazy_sum(1,2,3,4,5,6,7,8,9,10)
    3 >>> result1
    4 <function sum at 0x7f810add16e0>
    5 >>> result2
    6 <function sum at 0x7f810add1848>
    7 >>> result1 == result2
    8 False
    9 >>> 

    如上代码显示:0x7f810add16e0是不等于0x7f810add1848的,因此比较结果为FALSE。但是,什么是“闭包”呢?记得在离散数学里面学习过闭包的知识,关系闭包.......。

    2. 闭包:

      注意到返回函数在其定义内部引用了局部变量args,所以,当一个函数返回了一个函数后,其内部的局部变量还被新函数引用,所以,闭包用起来简单,实现起来可不容易。另一个需要注意的问题是,返回的函数并没有立刻执行,而是直到调用了result()才执行。我们来看一个例子:

    1 >>> def get_count():
    2 ...     fs = []
    3 ...     for i in range(1,10):
    4 ...         def f ():
    5 ...             return i*i
    6 ...         fs.append(f)
    7 ...     return fs
    8 ... f1,f2,f3 = get_count()

    在上面的例子中,每次循环,都创建了一个新的函数,然后,把创建的3个函数都返回了。

    你可能认为调用f1()f2()f3()结果应该是149,但实际结果是:

    1 >>> f1()
    2 9
    3 >>> f2()
    4 9
    5 >>> f3()
    6 9

    全部都是9!原因就在于返回的函数引用了变量i,但它并非立刻执行。等到3个函数都返回时,它们所引用的变量i已经变成了3,因此最终结果为9

    返回闭包时牢记的一点就是:返回函数不要引用任何循环变量,或者后续会发生变化的变量。

    如果一定要引用循环变量怎么办?方法是再创建一个函数,用该函数的参数绑定循环变量当前的值,无论该循环变量后续如何更改,已绑定到函数参数的值不变:

     1 >>> def count():
     2 ...     fs = []
     3 ...     for i in range(1,4):
     4 ...         def f(j):
     5 ...             def g():
     6 ...                 return j*j
     7 ...             return g
     8 ...         fs.append(f(i))
     9 ...     return fs
    10 ... 
    11 >>> f1,f2,f3 = count()
    12 >>> f1
    13 <function g at 0x7f810add19b0>
    14 >>> f1()
    15 1
    16 >>> f2()
    17 4
    18 >>> f3()
    19 9
    20 >>> 

    缺点是代码较长,可利用lambda函数缩短代码。

    3. 匿名函数:

    当我们在传入函数时,有些时候,不需要显式地定义函数,直接传入匿名函数更方便。

    在Python中,对匿名函数提供了有限支持。还是以map()函数为例,计算f(x)=x2时,除了定义一个f(x)的函数外,还可以直接传入匿名函数:

    1 >>> map(lambda x : x * x,[1,2,3,4,5,6,7,8,9,])
    2 [1, 4, 9, 16, 25, 36, 49, 64, 81]
    3 >>> map(lambda x : x * x,range(10))
    4 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    5 >>> 

    通过对比不难看出,匿名函数lambda x : x * x实际上就是一个求平方的函数:

    1 >>> def f(x):
    2 ...     return x*x
    3 ... 
    4 >>> f(4)
    5 16
    6 >>> f(40)
    7 1600
    8 >>> 

    关键字lambda表示匿名函数,冒号前面的x表示函数参数。

    匿名函数有个限制,就是只能有一个表达式,不用写return,返回值就是该表达式的结果

    用匿名函数有个好处,因为函数没有名字,不必担心函数名冲突。此外,匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量,再利用变量来调用该函数:

    1 >>> hanshu = lambda x : x*x*x
    2 >>> hanshu
    3 <function <lambda> at 0x7f810add1b90>
    4 >>> hanshu(45)
    5 91125
    6 >>> hanshu(450)
    7 91125000
    8 >>> 

    同样,也可以把匿名函数作为返回值返回,比如:

    1 >>> def build(x,y):
    2 ...     return lambda: x*x + y*y
    3 ... 
    4 >>> build(5,6)
    5 <function <lambda> at 0x7f810add1c80>
    6 >>> 

    4. 偏函数

    Python的functools模块提供了很多有用的功能,其中一个就是偏函数(Partial function)。要注意,这里的偏函数和数学意义上的偏函数不一样。通过设定参数的默认值,可以降低函数调用的难度。而偏函数也可以做到这一点。举例如下:

    int()函数可以把字符串转换为整数,当仅传入字符串时,int()函数默认按十进制转换:

    1 >>> 
    2 >>> int('123')
    3 123
    4 >>> int('123454567')
    5 123454567
    6 >>> 

    int()函数还提供额外的base参数,默认值为10。如果传入base参数,就可以做N进制的转换:

    1 >>> int('123',base = 8)
    2 83
    3 >>> int('123',base = 10)
    4 123
    5 >>> int('123',base = 16)
    6 291
    7 >>> int('123123',base = 16)
    8 1192227
    9 >>> 

    假设要转换大量的二进制字符串,每次都传入int(x, base=2)非常麻烦,于是,我们想到,可以定义一个int2()的函数,默认把base=2传进去:

     1 >>> def int2(x ,base = 2):
     2 ...     return int(x,base)
     3 ... 
     4 >>> int2(100)
     5 Traceback (most recent call last):
     6   File "<stdin>", line 1, in <module>
     7   File "<stdin>", line 2, in int2
     8 TypeError: int() can't convert non-string with explicit base
     9 >>> int2('100')
    10 4
    11 >>> 

    注意:在传入参数的时候,要以字符串的形式传入,否则会报出“TypeError”的类型错误。要使用偏函数的时候还得自己定义,是不是感觉很麻烦?因此,python提供了functools.partial就是帮助我们创建一个偏函数的,不需要我们自己定义int2(),可以直接使用下面的代码创建一个新的函数int2

    1 >>> import functools
    2 >>> int2 = functools.partial(int,base = 2)
    3 >>> int3 = functools.partial(int,base = 16)
    4 >>> int2('100')
    5 4
    6 >>> int3('100')
    7 256
    8 >>> 

    所以,简单总结functools.partial的作用就是,把一个函数的某些参数给固定住(也就是设置默认值),返回一个新的函数,调用这个新函数会更简单。

    注意到上面的新的int2函数,仅仅是把base参数重新设定默认值为2,但也可以在函数调用时传入其他值:

    1 >>> int3('100',base = 10)
    2 100
    3 >>> int2('100',base = 10)
    4 100
    5 >>> 

    最后,创建偏函数时,实际上可以接收函数对象*args**kw这3个参数,当传入:

     1 int2 = functools.partial(int, base=2) 

    实际上固定了int()函数的关键字参数base,也就是:

     1 int2('10010') 

    相当于:

     1 kw = { base: 2 } 2 int('10010', **kw) 

    当传入:

     1 max2 = functools.partial(max, 10) 

    实际上会把10作为*args的一部分自动加到左边,也就是:

    1 max2(5, 6, 7)

    相当于:

     1 args = (10, 5, 6, 7)

    2 max(*args) 

    结果 = 10

  • 相关阅读:
    Python os.walk() 方法
    Python os.utime() 方法
    Python os.unlink() 方法
    qtp 自动化测试桌面程序-点滴1(录制设置、共用文件)
    功能测试的一些心得----转载
    sqlmap-学习1 配置环境
    qtp 自动货测试桌面程序-笔记(使用参数 parameters)
    qtp 自动货测试桌面程序-笔记(使用函数)
    QTP键盘操作笔记
    QTP 自动化测试桌面程序--笔记(下拉选择、右键菜单、在控件仓库中查找对应的控件)
  • 原文地址:https://www.cnblogs.com/blogofwyl/p/4294911.html
Copyright © 2011-2022 走看看