Python中的函数、装饰器

xiayu

• 
  map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
  

>>> s = ['AASDa', 'dendY']

>>> def formatStr(ss):

return ss[0].upper() + ss[1:len(ss)].lower()



>>> v = formatStr('aaaB')

>>> v

'Aaab'

>>> map(formatStr, s)

<map object at 0x000000000320A668>

>>> for v in map(formatStr, s):

print(v)





Aasda

Dendy

• 
  reduce把一个函数作用在一个序列[x1, x2, x3...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
  

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)





>>> L = [2, 3, 4]

>>> def prod(a, b):

return a * b

>>>

>>> from functools import *

>>> reduce(prod, L)

24

>>>

• 
  filter函数，方法同map，目的是过滤list中符合条件的元素：
  

>>> s = [1, 2, -3, -5]

>>> def notLt0(x):

return x >= 0



>>> filter(notLt0, s)

<filter object at 0x000000000320A940>

>>> for v in filter(notLt0, s):

print(v)





1

2

>>>





如上的示例，定义一个notLt0的方法，该方法用于判断元素是否大于等于0，是则返回True，否则返回False。而filter则会将列表s的每一个元素作为参数调用notLt0方法，最后将所有返回True的元素重新组装成一个list返回。

• 
  匿名函数：无须定义函数的名称，格式如下：
  

fn = lambda 函数参数列表: 函数体




其中fn为返回的匿名函数，例如：


'''

匿名函数

'''

f = lambda x : x * x

print(f(2))

• 
  函数的闭包，类似javascript的闭包，即外部函数返回内部函数的引用，内部函数可能持有外部函数变量的引用，例如：
  

'''

闭包

'''

def count():

    fs = []

    for i in range(1, 4):

        def f():

            print(i)

            return i * i

        fs.append(f)        

    return fs



f1, f2, f3 = count()

print('before execute...')   

print(f1()) # 输出：9

print(f2()) # 输出：9

print(f3()) # 输出：9

print('after execute...')





由于每次执行fn()时，i的值都变为了3，所以输出的结果并非预期的1,4,9，解决这种问题有多种方式，可以再定义一层闭包，也可以将fs中的元素修改为f函数的执行结果，而不是函数引用。

• 
  装饰器(decorator)，包装目标函数，在不改变原目标函数的情况下，对其进行包装，实现更多的功能。
  

  例如：实现一个打印日志的装饰器：






'''

装饰器

'''

# 定义一个装饰器(decorator)

def log(fn):

    def wrapper(*args, **kw):

        print('call : %s' % (fn.__name__))

        return fn(*args, **kw)

    return wrapper



@log

def func():

    print ('hello!')



func()





其中，log函数为一个装饰器，除了完成fn函数本身的功能外，还添加了打印日志的功能，log函数返回一个装饰函数wrapper，打印的结果：




call : func

hello!





Python中使用@符号来表示装饰器（不是java的注解，形式类似），在执行func函数时，解释器看到@符号标识，会先执行log方法，并将func函数作为参数，此时func函数依然存在，但是同名的func变量会指向wrapper函数：



print(func.__name__)




输出wrapper，同：




func = wrapper(*args, **kw):

         print('call : %s' % (fn.__name__))

         return fn(*args, **kw)





所以，执行func()函数其实执行的是wrapper函数。







上边为最简单的装饰器，如果我们要实现可自定义参数的装饰器呢？


# 自定义文本的装饰器

def log(text):

    def decorator(fn):

        def wrapper(*args, **kw):

            print('log : %s, function name : %s. ' % (text, fn.__name__))

            fn(*args, **kw)

        return wrapper

    return decorator



@log('this is a log text.')

def func():

    print ('hello!')



func()

print(func.__name__) # 输出：wrapper





如上，我们需要再定义一个函数decorator来接收我们定义的参数信息，除了上边的执行过程外，在调用func函数时，解释器会先执行log和decorator函数，最后在执行wrapper函数，形式如下：



func = log(自定义参数)(func)

• 偏函数，functools.partial，固定函数参数，形成新的函数：
  

如果我们需要在转换为int的时候确定进制，Python提供了int方法：

int(x, base = 10)




base为此时x的进制数，默认为10，我们写一个将二进制字符串转换为int的方法：




def int2(x):

    return int(x, base = 2)

s = int2('110')

print (s) # 输出6





但是，其实Python已经为我们做了这样的事情，那就是利用functools.partial的方法：




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

s = int2('110')

print (s) # 输出6





当然，该函数用法有很多，例如将max函数默认与一些元素比较：




max2 = functools.partial(max, 10, 20, 30)

s = max2(1, 2, 3, 40)

print(s) # 输出：40


s = max2(1, 2, 3)

print(s) # 输出：30









这样，max函数在比较的元素中，默认会加入10,20,30了。