Python系列10——高级函数特性

目录

 

一、Python中的函数名

二、python中的内建高阶函数

1、map

2、reduce

3、filter

4、sorted

三、闭包（函数定义在函数内部，并返回函数）

四、装饰器

---

一、Python中的函数名

总结：函数名就是存储空间内一段程序的首地址。python的函数名就是指向函数的变量，可以将函数名赋值给变量，通过变量实现函数的调用。同时，也可以将函数名作为实参，这种函数称之为高阶函数

>>> abs(-3)
3
>>> my_abs = abs

>>> type(my_abs)

<class 'builtin_function_or_method'>
>>> my_abs(-8)

8

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

print(add(-5, 6, abs))

#输出结果： 11

二、python中的内建高阶函数

1、map

 |  map(func, *iterables) --> map object
 |  
 |  Make an iterator that computes the function using arguments from
 |  each of the iterables.  Stops when the shortest iterable is exhausted.
# map()函数接受两个参数，一个是函数，一个是iterable（可迭代对象）。map将传入的函
# 数依次作用到序列的每个元素，并把结果作为新的iterator返回。

>>> map(abs, [1, 2, 3, 4, 5])
<map object at 0x00000259C57CB128>
>>> t= map(abs, [1, 2, 3, 4, 5])
>>> tuple(t)
(1, 2, 3, 4, 5)

>>> next(t)
1
>>> next(t)
2
# 返回的t是惰性计算

2、reduce

reduce(...)
    reduce(function, sequence[, initial]) -> value
    
    Apply a function of two arguments cumulatively to the items of a sequence,
    from left to right, so as to reduce the sequence to a single value.
    For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
    ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
    of the sequence in the calculation, and serves as a default when the
    sequence is empty.

reduce把一个函数作用在一个序列上，这个函数必须接收两个参数。reduce把结果继续和序列的下一个元素做累积计算。

>>> res = reduce(lambda x, y: x*y, [1, 3, 5, 7, 9])
>>> res
945

3、filter

python内建的filter
 

 |  filter(function or None, iterable) --> filter object
 |  
 |  Return an iterator yielding those items of iterable for which function(item)
 |  is true. If function is None, return the items that are true.

和map()一样，filter也接收一个函数和一个iterable（可迭代对象）。但是filter把function依次作用在可迭代对象每个元素。根据返回值是True还是False决定保留还是丢弃元素。返回同样也是一个迭代器。

4、sorted

sorted(iterable, /, *, key=None, reverse=False)
    Return a new list containing all items from the iterable in ascending order.
    
    A custom key function can be supplied to customize the sort order, and the
    reverse flag can be set to request the result in descending order.

返回一个新的数列，数列的内容按照升序排列。还可以接收key函数，进行自定义排序。reverse为false时，升序排列，reverse=True时，降序排列。

以上几个函数的形参均可以接收函数，因此，都是高阶函数。

三、闭包（函数定义在函数内部，并返回函数）

def my_sum(*args):
    # 在函数内部定义函数inner_sum()
    def inner_sum():
        sum_ = 0
        for i in args:
            sum_ += i
        return sum_
    return inner_sum

# 运行到此处时，调用了my_sum函数，但是并未调用inner_sum，故直接跳转到return inner_sum,返回一个函数
f = my_sum(1, 2, 3, 6, 4, 8, 2)
# 该行代码对inner_sum进行了调用，并最终return sum_
f()

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

# (1)调用count()函数 (2)初始化fs (3)for循环，为列表fs添加函数f. 
# (4)for循环结束，返回列表fs (5)解包，将fs列表中的函数分别赋值给变量f1,f2,f3
f1, f2, f3 = count()
# 调用f(),此时局部变量i的值已经变为3，因此三个函数均return 3*3,即9
f1()
f2()
f3()

四、装饰器@语法糖

装饰器就是通过给函数增加功能的工具。这种方法可以不用修改函数的定义，便能增强函数的功能。

def log(func):
    def wrapper(*args, **kwargs):
        print("call %s():" % func.__name__)
        return func(*args, **kwargs)
    return wrapper


# 相当于now = log(now)，使用@可以代表该语句
@log     
def now():
    print("革命尚未成功，同志仍需努力")


# 1 将now作为形参传递给func（func指向原来的now），并调用该函数，返回值为wrapper，并将返回值赋值#   给now，使得now指向新的函数wrapper 
# 2 此时now指向新函数wrapper，now()相当于wrapper()。
# 3 调用wrapper
# 4 在return语句中调用原来的func(),即now().


# 输出结果
#         call now():
#         革命尚未成功，同志仍需努力

def log(text):

    # 此时的func指向的是的now--------------------------
    def decorator(func):    
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def now():
    print('2015-3-25')

# 装饰过后的now指向的是wrapper------------------------
now()

# 输出结果
#         execute now():
#         2015-3-25

now.__name__
# 输出结果： wrapper