09高级函数

"""
高级函数
闭包，满足三个条件:
1.存在于嵌套函数中，闭包是内层函数；
2.闭包需要使用外层函数的参数或变量；
3.外层函数把内层函数(闭包)的引用返回。
作用:保护内层函数不被轻易地调用和修改。
"""

# 闭包案例1
# def test(number_01):
#     def test_in(number_02):  # 闭包函数，保护当前函数不会轻易修改
#         print(number_01 + number_02)
#         return number_01 + number_02
#     return test_in
#
#
# result = test(1000)  # test_in 返回，result = test_in
# result(2000)   # 相当于 test_in()
# print(test(500))  # <function test.<locals>.test_in at 0x0000020472269AE8>
# result = test(500)
# ss = result(400)
# print("ss的值为", ss)

# 闭包案例2
# def outer(start=0):  # start=0是有默认值的参数
#     count = [start]  # count是一个列表，列表中只有一个元素 start，下标为0
#     def inner():
#         count[0] += 1   # count中的下标为0的元素值+1
#         return count[0]
#     return inner
#
#
# aaa = outer(5)
# print(aaa())  # 结果为6
#
#
# 闭包案例3，y=a*x+b
# def test(a, b):
#     def test_in(x):
#         return a*x+b
#     return test_in
#
#
# result1 = test(5, 6)
# print(result1(10))
# result2 = test(7, 8)
# print(result2(100))
# 程序运行结果:
# 56
# 708

"""
装饰器，就是闭包函数。
作用:给已经写好的函数增加一些装饰，比如:验证权限，记录函数执行时间等。
函数，"封闭开放"，只能调用，尽量不要修改。
装饰器
概念:是一个闭包，把一个函数当做参数，返回一个替代版的函数
本质上就是一个返回函数的函数
"""

# def wrapper(func):
#     print("正在给函数做装饰...")
#
#     def wrapper_in():
#         print("正在验证函数的权限...")
#         func()
#
#     return wrapper_in
#
#
# @wrapper  # 等于test = wrapper(test)
# def test():
#     print("test is running")


# aaa = wrapper(test)
# aaa()
# test = wrapper(test)
# test()

# import time
#
# aaa = time.time()
# print(aaa)
#
#
# print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

"""
2019-10-14作业:利用装饰器获取并记录函数的执行时间
查第6,7章笔记独立完成
"""
# import time  # 引入time模块

# # 闭包函数，装饰器：通用装饰器，不定长参数
# def test(func):  # 外层函数2,func = a
#     print("开始装饰函数")
#    print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))   # 获取时间
#     ticks_1 = time.time()  # 获取时间戳
#
#     def test_in(*args, **kwargs):  # 内层函数，闭包函数,不定长参数
#         print("开始验证权限")
#         # print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))  # 获取时间
#         end = func(*args, **kwargs)  # 使用了外层函数的参数,调用 a()，不定长参数
#         ticks_2 = time.time()  # 获取时间戳
#         print("函数的运行时间需要%f秒" % (ticks_2 - ticks_1))
#         return end
#
#     return test_in  # 外层函数把内层函数的名称(引用)进行了返回。有括号表示调用，不调用不带括号
#
#
# @test  # a = test(a)
# def a(x, y):  # 函数可以作为参数进行传递
#     time.sleep(1)  # 休眠1秒钟
#     print("a is running")
#     print(x + y)
#     z = x + y
#     return z
#
#
# result = a(10, 20)  # 相当于调用test_in()
# print(result)


"""
通用装饰器，作用：装饰  有无参数，有无返回值  的函数。
"""

# def wrapper_1(name):
#     def wrapper(func):
#         print("正在装饰 %s" % name)
#
#         def inner(*args, **kwargs):
#             print("正在验证权限 %s" % name)
#             print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))  # 获取时间
#             return func(*args, **kwargs)
#
#         return inner
#
#     return wrapper
#
#
# @wrapper_1("test_1")  # 带参数的装饰器
# def test_1(a, b):
#     return a, b
#
#
# # @wrapper_1("test_2")  # 带参数的装饰器
# # def test_2(m, n, r=5):
# #     return m, n, r
#
#
# result_1 = test_1(10, 20)
# print(result_1)
# # result_2 = test_2(100, 200, 300)
# # print(result_2())
"""
任务要求:在不修改a函数的基础上，加上"正在装饰和正在验证权限"
装饰器。闭包函数，接收一个函数作为实参，再调用实参来完成原函数的调用。
语法格式:定义a函数的上方，写上@test  装饰器函数名   等于a = test(a)
"""

"""
作业：在A4纸上写装饰器，并画出装饰函数的整个过程，2019-10-15
"""
"""
通用装饰器，不定长参数 return func()
"""

#
# def wrapper(name):   # 带参数的装饰器，name
#     def wrapper_1(func):  # 装饰器
#         print("政委已同意 %s" % name)
#
#         def inner(*args, **kwargs):
#             print("团长李云龙已集合好队伍 %s" % name)
#             return func(*args, **kwargs)
#         return inner
#     return wrapper_1
#
#
# # 独立团，出兵，打鬼子
# @wrapper("独立团")  # --->fight = wrapper(fight)
# def fight_1(a=100):  # a代表枪支
#     print("独立团可以出兵打鬼子了，携带枪支%d支" % a)
#     return "歼灭鬼子参观团"
#
#
# @wrapper("新二团")
# def fight_2(a=100):   # a代表枪支
#     print("新二团可以出兵打鬼子了，携带枪支%d支" % a)
#     return "歼灭鬼子"
#
#
# print(fight_1(200))
# print(fight_2(300))
"""
如果一个函数有多个装饰器，自下而上进行装饰
"""
# def w1(func1):
#     print("w1正在装饰")  # 1.
#     def w1_inner():
#         print("w1正在验证权限")  # 5.
#         return func1()  # 6.test()
#     return w1_inner
#
# def w2(fun2):
#     print("w2正在装饰")  # 2.
#     def w2_inner():
#         print("w2正在验证权限")  # 3.
#         return fun2()  # 4. w1_inner
#     return w2_inner
#
# @w2  # (2).test = w2(test), test=w2(w1_inner),func2=w1_inner,test=w2_inner
# @w1  # (1).test = w1(test)，test=w1_inner,func1=test
# def test():
#     print("test is running.")  # 7.
#
# # 在原函数调用之前，装饰器已经进行了装饰
# test()  # 3.test=w2_inner
#
# @w2  # (2).fight = w2(fight),fight=w1_inner,-->fight = w2(w1_inner)-->
#            # (func2 = w1_inner),fight=w2_inner
# @w1  # (1).fight = w1(fight),(func1=fight),fight = w1_inner
# def fight():
#     print("We are family,we have fighting.")
#
# fight()  # fight=w2_inner
"""
与自定义函数(def,lambda).序列相关的三个函数：
1.map(function,iterabele1,iterable2,...iterableN)根据提供的函数对指定的序列做映射
2.filter(function or None,iterable)对指定的序列进行过滤操作，
第1个参数可以是函数的名称或者None，如果function传入None，则返回所有本身可以判断为True的元素。
第2个参数表示的是序列、支持迭代的容器或迭代器。返回值为迭代器对象。
其中，第一个参数如果是function，它只能接收一个参数，而且该函数的返回值为布尔值(True 或 False)。
3.reduce(function,sequence[,initial])->value
function(是一个带有两个参数的函数);第2个参数可以是序列、元组、字符串; 
initial 表示固定的初始值.优先调用.
reduce 会依次从sequence中取出每个元素，
和上一次调用function的结果作为参数再次调用function。
对参数序列中的元素进行累积。
from functools import reduce  从函数工具模块中导入reudce函数，
                              调用其中的某一个函数时:函数名()
import functools  导入函数工具模块，调用其中的某一个函数时:模块名.函数名()
"""
# func = lambda x:x+2
# result = map(func, [1,2,3,4,5])
# print(result)   # <map object at 0x000002AD14A89400>
# print(list(result))  # [3, 4, 5, 6, 7]
# result_2 = filter(func,[1,2,3,4,5])
# print(list(result_2))
#
# def test(a,b):
#     return a+b
#
# result_1 = map(test, [1,2,3,4,5], [10,20,30,40,50,60,70])
# print(list(result_1))   # [11, 22, 33, 44, 55]
#
# func = lambda x:x%2
# result = filter(func,[1,2,3,4,5])
# print(result)   # <filter object at 0x0000027250B69438
# print(list(result))  # [1, 3, 5]
#
# result_1 = filter(None,[1,0,"","a",2,0.0])  # 过滤，留下True
# print(list(result_1))   # [1, 'a', 2]
# from functools import reduce
# import functools
#
# def func(a, b):
#     return a+b
#
# result = functools.reduce(func, [1,2,3,4,5,6,7])
# print(result)
#
# result_1 = functools.reduce(func, {10, 6}, 5)   # "zzz"是初始值，优先调用
# print(result_1)
#
# result_2 = functools.reduce(func,"abcdefg", "zzz")
# print(result_2)

# result = filter(None,{"a","b","c"})
# print(list(result))

"""
复习：
1.闭包:函数嵌套的内层函数、
  内层函数使用外层函数的变量或参数
  外层函数要把内层函数的引用返回
2.装饰器：作用，在不改变原函数的基础上，添加一些装饰
"""
import time  # 导入time时间模块

# 通用装饰器
# def w_1(func):   # func=test
#     print("w1开始进行装饰...")  # 1
#     def inner(*args, **kwargs):
#         ticks_1 = time.time()
#         print("w1开始验证权限")  # 2
#         print(time.strftime("%Y-%m-%d %H:M:%S", time.localtime()))
#         end = func(*args, **kwargs)   # func()-->test()
#         ticks_2 = time.time()
#         print("ticks_2 - tick_1")
#         return end
#
#     return inner  #
#
# def w_2(func):
#     print("w2开始进行装饰...")
#     def inner(*args, **kwargs):
#         print("w2开始验证权限")
#         return func(*args, **kwargs)
#     return inner
#
#
# @w_2
# @w_1   # -->test=w_1(test) func=test   -->test=inner   等待
# def test(a, b):
#     time.sleep(1)
#     print("test is running")
#     print(a, b)  # 100 200
#     c = a + b
#     return c
#
# sum = test(100, 200)  # -->inner(100, 200) -->sum=300
# print(sum)  # 300

"""
其他的一些常用函数：
1.数学模块中的sqrt(x),求x的平方根，首先引入数学模块 import math  -->math.sqrt()
2.abs(x)  求x的绝对值
3.round(x,n)  对浮点数x进行四舍五入取值，n为可选项，代表浮点数量终的小数位数。
4.max()  求最大值
5.min()  求最小值
6.sum()  求和
类型转换相关函数:
1.int()  转换为整形
2.bool()  转换为布尔类型
3.float()  转换为浮点型
4.str()  转换为字符串
5.list()  转换为列表类型
6.tuple()  转换为元组
7.dict()  转换为字典
8.set()  转换为可变集合类型
  frozenset()  转换为不可变集合类型
标准输入输出函数：
1.print()  输出函数
2.input()  输入函数

求序列长度的函数
1.len()  计算某一序列的长度

常用的函数:
1.eval("字符串")  将字符串做的表达式进行运算功能强大，要慎用。
2.exec() : 执行Python语句,比eval功能更强大，慎用
"""
# import math
# print(math.sqrt(4))  # 2.0
# print(math.sqrt(16))  # 4.0
#
# print(abs(-10))  # 10
# print(abs(5.67))  # 5.67
#
# print(round(1.34567, 4))  # 1.3457
# print(round(2.67))  # 3
# print(round(2.67, 0))  # 3.0
# print(round(0.5))  # 0
# print(round(-0.4))  # 0
# print(round(345, 2))  # 345

# str_1 = input("请输入一个加减乘除的四则运算")
# print(eval(str_1))

# exec('print("I love python.")')
#
# str_1 = '{"name":"zs","age":20}'
# dict_2 = eval(str_1)  # 使用eval还原字符串原来的样子
# print(dict_2)
# print(type(eval(str_1)))
#
# str_2 = '[1,2,3,4,"abc"]'
# list_1 = eval(str_2)  # 使用eval还原字符串原来的样子
# print(list_1)
# print(type(list_1))