2018-08-31 Day10-函数基础03

函数就是一种特殊的类型。声明函数的时候，其实就是声明一个类型为function的变量，所以变量能做的事情，函数都能做。

一、回调函数

1、函数作为函数的参数

ef clean_floor(time):
    print('%s,做地板清洁服务'%time)
    print('收费100')
    return 100
def clean_kitchen(time):
    print('%s,做厨房清洁服务'%time)
    print('收费200')
    return 200
def call_service(time:str,service):
    service(time)

#将函数作为参数，传给其他函数
call_service('上午十点',clean_floor)
call_service('下午五点',clean_kitchen)

结果：
上午十点,做地板清洁服务
收费100
下午五点,做厨房清洁服务
收费200

2、函数作为函数的返回值

def operation(operator:str):
    if operator == '+':
        def my_sum(*nums):
            sum = 0
            for num in nums:
                sum += num
            print(sum)
    elif operator == '*':
        def my_sum(*nums):
            sum1 = 1
            for num in nums:
                sum1 *= num
            print(sum1)

        #将函数返回
    return my_sum    #返回内部函数作为外部函数的返回值

operation('+')(1,2)
operation('*')(2,3,4)

结果：
3
24

二、生成器和迭代器

生成器就是来生成迭代器，可以把迭代器看成一个容器，类似列表。
生成式--产生一个迭代器的表达式（下面等号右边的式子）

#通过将生成式产生的迭代器转换成了一个列表
a = (x for x in range(10))

说明：把等号右边全部保存给 a ，每次调用next（a）取一个值，并且保存已经调用的位置，下次调用next（a）时继续调用后面的值。

生成器和迭代器都是通过 next（）来获取里面的数据。不管通过什么方式取出数据，取出数据的位置不会返回。
print(next(a))

1、把生成式的结果转换成一个列表（[生成式]）：

a = [x for x in range(10)]
print(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

2、把生成式的结果转换成一个字典：

条件：生成式生成的结果是一个元组，并且元组的元素个数必须是 2

dict1 = dict((x,x*2) for x in range(10))
print(dict1)
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}

#用生成式交换字典key和value
dict1 = dict((value,key) for key,value in {'a':1,'b':2}.items())
print(dict1)
{1: 'a', 2: 'b'}

三、生成器

yield 关键字

只要函数中有 yield 关键字，不管执行yield语句与否，这个函数都会变成一个生成器。
a、有 yield 的函数，在调用函数的时候不再是获取返回值，而是产生一个生成器对象，生成器对象中保留的是函数体。
b、当通过 next 获取生成器中的数据的时候，才会去执行函数体，执行到 yield 为止，并且将 yiled 后面的结果作为生成的数据返回，同时记录结束的位置，下次再调用 next 的时候，从上次结束的位置接着往后执行。

练习：写一个生成器，可以产生一个斐波那契数列

# 练习：
def fib():
    yield 1
    yield 1
    x = 1
    y = 1
    while True:
            x,y = x+y,x
            yield x
n = fib()   #必须保存一下，不然直接next会产生多个生成器，每次取第一个值，结果全为 1 
print(next(n),end=' ')
print(next(n),end=' ')
print(next(n),end=' ')
print(next(n),end=' ')
print(next(n),end=' ')
print(next(n),end=' ')
结果：
1 1 2 3 5 8

四、迭代器 -- iter

生成器和生成式产生的对象就是迭代器。
将列表转换成迭代器对象

iter1 = iter([1, 2, 3, 4])
print(iter1)
print(next(iter1))
print(next(iter1))
print(next(iter1))
1
2
3

利用 iter 把其他类型转换成迭代器，取出时候都是用 next 取出，和生成器一样，只是产生方式不同。

五、装饰器

装饰器函数：用一个函数装饰另一个函数,装饰器函数的参数是被装饰的函数，返回一个装饰后的函数,当调用被装饰的函数时，其实执行的是装饰器中返回的函数,给他增加额外的功能，凡是需要这个额外的功能的地方,只需要加上装饰器即可，而不需要书写额外的代码。

给函数添加装饰器的语法，就是在函数前添加@函数

import time
def record(fn):
    def wrapper(*args, **kwargs):
        start = time.time()
        ret_value = fn(*args, **kwargs)
        end = time.time()
        print(f'{end - start}s')
        return ret_value
    return wrapper

@record
def fac(num):
    result = 1
    for n in range(1, num + 1):
        result *= n
    return result

if __name__ == '__main__':
    for num in range(1, 5):
        print(fac(num))

结果：
0.0s
1
0.0s
2
0.0s
6
0.0s
24