python进阶

目录

高阶函数:

map()函数

reduce()函数

filter()函数

自定义排序函数

返回函数

闭包

匿名函数

装饰器

无参数decorator

带参数decorator

完善decorator

任务

偏函数

任务


函数名其实就是指向函数的变量。

高阶函数

能接收函数做参数的函数。(变量可以指向函数,函数的参数可以接收变量,一个函数可以接收另一个函数作为参数,能接收函数作参数的函数就是高阶函数)。

def add(a,b,f):
  return f(a)+f(b)
import math
def add(x,y,f):
  return f(x)+f(y)

print add(25,9,math.sqrt)

输出5+3=8

map()函数

map()是python内置的高阶函数,他接收一个函数f和一个list,并通过函数f依次作用在list的每个元素上,得到一个新的list并返回。

def format_name(s):
  return s[0].upper()+s[1:].lower()

print map(format_name,['adam', 'LISA', 'barT'])

输出:['Adam', 'Lisa', 'Bart']

reduce()函数

reduce()函数也是python内置的一个高阶函数。reduce()函数接收的参数和map类似,一个函数f,一个list,但行为和map()不同,reduce传入的函数f必须接收两个参数,reduce()对list的每个元素反复调用函数f,并返回最终结果值。

def f(x,y):
  return x+y

print reduce(f,[1,3,5,7,9])
输出25

求积函数

def prod(x,y):
  return x*y

print reduce(prod,[2,4,5,7,12])

filter()函数

filter()函数是python内置的另一个有用的高阶函数,filter函数接收一个函数f和一个list,这个函数f的作用是对每个元素进行判断,返回true或false,filter根据判断结果自动过滤掉不符合条件的元素,返回符合条件元素组成的新list。

def is_odd(x):
  return x%2==1

filter(is_odd,[1,4,6,7,9,12,17])

结果:[1,7,9,17]
def is_not_empty(s):
  return s and len(s.strip())>0

filter(is_not_empty,['test','None','','str',' ','End'])

结果:['test','str','End']

s.strip(rm)删除s字符串中开头、结尾处的rm序列的字符,当rm为空时,默认删除空白符('\n','\r','\t','')

过滤1~100中平方根是整数的数。

import math
def is_sqrt(x):
  r=int(math.sqrt(x))
  return r*r==x
print(is_sqrt,range(1,101))

自定义排序函数

python内置的sorted函数可以对list进行排序,但sorted也是一个高阶函数,它可以接收一个比较函数来实现自定义排序,比较函数的定义是传入两个待比较元素x,y,如果x应该排在y的前面,返回-1,如果x应该排在y的后面,返回1.如果相等返回0.

//写一个忽略大小写的字符串比较
def cmp_igmore_case(s1,s2):
  u1=s1.upper()
  u2=s2.upper()
  if(u1u2)
    return 1
  return 0

print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

返回函数

python的函数不仅可以返回int,str,list,dict等数据类型,还可以返回函数。

def myabs():
    return abs   # 返回函数
def myabs2(x):
    return abs(x)   # 返回函数调用的结果,返回值是一个数值
def calc_prod(lst):
    def lazy_prod():
        def f(x, y):
            return x * y
        return reduce(f, lst, 1)
    return lazy_prod
f = calc_prod([1, 2, 3, 4])
print f()

闭包

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

注意: 发现没法把 lazy_sum 移到 calc_sum 的外部,因为它引用了 calc_sum 的参数 lst

像这种内层函数引用了外层函数的变量(参数也算变量),然后返回内层函数的情况,称为闭包(Closure)

闭包的特点是返回的函数还引用了外层函数的局部变量,所以,要正确使用闭包,就要确保引用的局部变量在函数返回后不能变。举例如下:

# 希望一次返回3个函数,分别计算1x1,2x2,3x3:
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

实际结果全是9

正确做法:

def count():
  fs=[]
  for i in range(1,4):
    def f(j):
      def g():
        return j*j
      return g
    r=f(i)
    fs.append(r)
  return fs

f1,f2,f3=count()
print f1(),f2(),f3()

匿名函数

高阶函数可以接收函数做参数,有些时候我们不需要显式的定义函数,直接传入匿名函数更为方面。

map(lambda x: x*x, [1,2,3,4,5,6,7,8,9])

结果:[1,4,9,16,25,36,49,64,81]
print filter(lambda s: s and len(s.strip())>0, ['test', None, '', 'str', '  ', 'END'])

装饰器

python进阶_第1张图片

 

无参数decorator

decorator本质上就是一个高阶函数,它接收一个函数作为参数,然后返回一个新函数。使用decorator用python提供的@语法,这样可以避免手动编写f=decorate(f)这样的代码。

def log(f):
  def fn(x):
    print 'call '+f.__name__+'()...'
    return f(x)
  return fn

//对于阶乘函数

@log
def factorial(n):
  return reduce(lambda x,y: x*y, range(1,n+1))
print factorial(10)

结果:

call factorial()...
3628800

 

但是,对于参数不是一个的函数,调用将报错:

@log
def add(x, y):
    return x + y
print add(1, 2)

结果:

Traceback (most recent call last):
  File "test.py", line 15, in 
    print add(1,2)
TypeError: fn() takes exactly 1 argument (2 given)

因为 add() 函数需要传入两个参数,但是 @log 写死了只含一个参数的返回函数。

要让 @log 自适应任何参数定义的函数,可以利用Python的 *args 和 **kw,保证任意个数的参数总是能正常调用:

def log(f):
    def fn(*args, **kw):
        print 'call ' + f.__name__ + '()...'
        return f(*args, **kw)
    return fn

现在,对于任意函数,@log 都能正常工作。

import time

def performance(f):
    def fn(*args, **kw):
        t1=time.time()
        r=f(*args, **kw)
        t2=time.time()
        print 'call %s() in %fs' %(f.__name__,(t2-t1))
        return r
    return fn

@performance
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

带参数decorator

考察上一节的 @log 装饰器:

def log(f):
    def fn(x):
        print 'call ' + f.__name__ + '()...'
        return f(x)
    return fn

发现对于被装饰的函数,log打印的语句是不能变的(除了函数名)。

如果有的函数非常重要,希望打印出'[INFO] call xxx()...',有的函数不太重要,希望打印出'[DEBUG] call xxx()...',这时,log函数本身就需要传入'INFO'或'DEBUG'这样的参数,类似这样:

@log('DEBUG')
def my_func():
    pass

把上面的定义翻译成高阶函数的调用,就是:

my_func = log('DEBUG')(my_func)

上面的语句看上去还是比较绕,再展开一下:

log_decorator = log('DEBUG')
my_func = log_decorator(my_func)

上面的语句又相当于:

log_decorator = log('DEBUG')
@log_decorator
def my_func():
    pass

所以,带参数的log函数首先返回一个decorator函数,再让这个decorator函数接收my_func并返回新函数:

def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print '[%s] %s()...' % (prefix, f.__name__)
            return f(*args, **kw)
        return wrapper
    return log_decorator

@log('DEBUG')
def test():
    pass
print test()

执行结果:

[DEBUG] test()...
None

对于这种3层嵌套的decorator定义,你可以先把它拆开:

# 标准decorator:
def log_decorator(f):
    def wrapper(*args, **kw):
        print '[%s] %s()...' % (prefix, f.__name__)
        return f(*args, **kw)
    return wrapper
return log_decorator

# 返回decorator:
def log(prefix):
    return log_decorator(f)

拆开以后会发现,调用会失败,因为在3层嵌套的decorator定义中,最内层的wrapper引用了最外层的参数prefix,所以,把一个闭包拆成普通的函数调用会比较困难。不支持闭包的编程语言要实现同样的功能就需要更多的代码。

上一节的@performance只能打印秒,请给 @performace 增加一个参数,允许传入's'或'ms':

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

import time

def performance(unit):
    def perf_decorator(f):
        def warpper(*args, **kw):
            t1=time.time()
            r=f(*args,**kw)
            t2=time.time()
            t=(t2-t1)*1000 if unit == 'ms' else (t2-t1)
            print 'call %s() in %f %s' %(f.__name__,t,unit)
            return r
        return warpper
    return perf_decorator

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

完善decorator

@decorator可以动态实现函数功能的增加,但是,经过@decorator“改造”后的函数,和原函数相比,除了功能多一点外,有没有其它不同的地方?

在没有decorator的情况下,打印函数名:

def f1(x):
    pass
print f1.__name__

输出: f1

有decorator的情况下,再打印函数名:

def log(f):
    def wrapper(*args, **kw):
        print 'call...'
        return f(*args, **kw)
    return wrapper
@log
def f2(x):
    pass
print f2.__name__

输出: wrapper

可见,由于decorator返回的新函数函数名已经不是'f2',而是@log内部定义的'wrapper'。这对于那些依赖函数名的代码就会失效。decorator还改变了函数的__doc__等其它属性。如果要让调用者看不出一个函数经过了@decorator的“改造”,就需要把原函数的一些属性复制到新函数中:

def log(f):
    def wrapper(*args, **kw):
        print 'call...'
        return f(*args, **kw)
    wrapper.__name__ = f.__name__
    wrapper.__doc__ = f.__doc__
    return wrapper

这样写decorator很不方便,因为我们也很难把原函数的所有必要属性都一个一个复制到新函数上,所以Python内置的functools可以用来自动化完成这个“复制”的任务:

import functools
def log(f):
    @functools.wraps(f)
    def wrapper(*args, **kw):
        print 'call...'
        return f(*args, **kw)
    return wrapper

最后需要指出,由于我们把原函数签名改成了(*args, **kw),因此,无法获得原函数的原始参数信息。即便我们采用固定参数来装饰只有一个参数的函数:

def log(f):
    @functools.wraps(f)
    def wrapper(x):
        print 'call...'
        return f(x)
    return wrapper

也可能改变原函数的参数名,因为新函数的参数名始终是 'x',原函数定义的参数名不一定叫 'x'。

任务

请思考带参数的@decorator,@functools.wraps应该放置在哪:

def performance(unit):
    def perf_decorator(f):
        def wrapper(*args, **kw):
            ???
        return wrapper
    return perf_decorator
import time, functools

def performance(unit):
    def pre_decorator(f):
        @functools.wraps(f)
        def wrapper(*args,**kw):
            t1=time.time()
            r=f(*args,**kw)
            t2=time.time()
            t=(t2-t1)*1000 if unit=='ms' else (t2-t1)
            print 'call %s() in %f %s' %(f.__name__,t,unit)
            return r
        return wrapper
    return pre_decorator

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial.__name__

偏函数

当一个函数有很多参数时,调用者就需要提供多个参数。如果减少参数个数,就可以简化调用者的负担。

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

>>> int('12345')
12345

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

>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

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

def int2(x, base=2):
    return int(x, base)

这样,我们转换二进制就非常方便了:

>>> int2('1000000')
64
>>> int2('1010101')
85

functools.partial就是帮助我们创建一个偏函数的,不需要我们自己定义int2(),可以直接使用下面的代码创建一个新的函数int2:

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

所以,functools.partial可以把一个参数多的函数变成一个参数少的新函数,少的参数需要在创建时指定默认值,这样,新函数调用的难度就降低了。

任务

在第7节中,我们在sorted这个高阶函数中传入自定义排序函数就可以实现忽略大小写排序。请用functools.partial把这个复杂调用变成一个简单的函数:

import functools

sorted_ignore_case = functools.partial(sorted,cmp=lambda s1,s2: cmp(s1.upper(),s2.upper()))

print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])

 

 

你可能感兴趣的:(Python)