python 高阶函数 装饰器 语法糖
#############################高阶函数map########################## # #map()函数接收两个参数，一个是函数，一个是Iterable # #map将传入的函数依次作用到序列的每个元素， # # 并把结果作为新的Iterator返回。 # # 结果r是一个Iterator，Iterator是惰性序列， # # 因此通过list()函数让它把整个序列都计算出来并返回一个list def func(x): return x*x r = map(func,[1,2,3,4,5,6]) li = list(r) print(li,r) #[1, 4, 9, 16, 25, 36] <map object at 0x00000222A4118710> print(list(map(str, [1, 2, "3", "abc", 5, 6, 7, 8, 9]))) #list这里是使map出来的Iterator变成列表并返回一个列表,需要用变量接的,注意不能直接print(list) #['1', '2', '3', 'abc', '5', '6', '7', '8', '9']把列表中的数字转化成字符串
#将两个列表中对应位置的元素相加组成新的列表 l1 = [1,3,5,7,9] l2 = [2,4,6,8,10] ret1 = map(lambda x,y:x+y,l1,l2) print(list(ret1))
##################################高阶函数reduce######################## # reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数， # reduce把结果继续和序列的下一个元素做累积计算，其效果就是 # reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4) from functools import reduce def add(x, y): return x*10 + y ret = reduce(add, [1,3,5,7,9]) print(ret) #13579 变为整数 from functools import reduce DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} #常量使用大写字母 def str2int(s): def fn(x, y): return x * 10 + y def char2num(s): #挺有意思,char to(2) num,字符串转数字 return DIGITS[s] #字典中键对应的值 return reduce(fn, map(char2num, s)) #map把字符串转化成整型的Iterator,fn又把Iterator转化成一个整数 print(str2int("123456")) #123456 # lambda只是一个表达式，函数体比def简单很多。 # lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去 # lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。 # f = lambda x,y,z:x+y+z #冒号前边的是形参,后边的是返回值的表达式 # print(f(1,2,3)) # #6 # #如上面的例子使用lambda写的话 from functools import reduce DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} def char2num(s): return DIGITS[s] def str2int(s): return reduce(lambda x, y: x * 10 + y, map(char2num, s))
#####################filter()函数用于过滤序列################ # 和map()类似，filter()也接收一个函数和一个序列。 # 和map()不同的是，filter()把传入的函数依次作用于每个元素， # 然后根据返回值是True还是False决定保留还是丢弃该元素 def is_odd(n): return n % 2 == 1 print(list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))) #[1, 5, 9, 15]
####计算素数 #先构造一个从3开始的奇数序列 def _odd_iter(): n = 1 while True: n = n + 2 yield n #注意这是一个生成器，并且是一个无限序列。 #然后定义一个筛选函数： def _not_divisible(n): return lambda x: x % n > 0 # 最后，定义一个生成器，不断返回下一个素数： def primes(): yield 2 it = _odd_iter() # 初始序列 it = [3,5,7,9,11,13,15,17,……] while True: n = next(it) # 返回序列的第一个数 此时n=3 yield n it = filter(_not_divisible(n), it) # 构造新序列 _not_divisible(3) it中的每项作为x,筛选出x%3>0,这样就把3的倍数除去了,我在这个参数传递上花了很长时间才弄懂 # 这个生成器先返回第一个素数2，然后，利用filter()不断产生筛选后的新的序列。 # 由于primes()也是一个无限序列，所以调用时需要设置一个退出循环的条件： # 打印1000以内的素数: for n in primes(): if n < 1000: print(n) else: break
#####*******************sorted()排序***************#### #之前我们已经学过在列表中有sort方法 li = [1,5,3,8] li.sort() #[1, 3, 5, 8] 升序排列 li.sort(reverse=True) #[8, 5, 3, 1]降序排列 li.reverse() #[8, 3, 5, 1] 反向排序 ##sorted()函数是python内置的,也是用来排序的 sorted([36,5,-12,9,-21]) #[-21, -12, 5, 9, 36]升序 sorted([36,5,-12,9,-21],key=abs) #sorted()是高阶函数,可以接收一个key函数,这里的key=abs表示的是取绝对值,列表中的元素被abs函数作用后,再把原来的元素做升序排列 #[5, 9, -12, -21, 36] sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) #str.lower函数使得列表中的字符串变为小写后(注意lower后面不要加括号),然后以首字母进行升序排列,同sort进行降序排列只要在后面加一个reverse=True就可以了 #['about', 'bob', 'Credit', 'Zoo'] ret = sorted(['bob', 'about', 'Zoo', 'Credit'],key=str.lower,reverse=True ) #['Zoo', 'Credit', 'bob', 'about']
dic = {"a":3,"b":2,"c":1}
print(min(dic,key=lambda x:dic[x])) #对字典进行迭代时,迭代的元素是键,而不应当认为是键值对.如 for i in dic 这里的i代表的就是键.同样的字典作为可迭代对象作用于函数中,函数作用的也是字典的键
#c
print(sorted(dic,key=lambda x:dic[x]))
#['c', 'b', 'a']
#以列表中元组的最后一个元素进行排序 students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] print(sorted(students,key=lambda x:x[2])) # #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] #以列表中字典的值进行排序 students = [{'john': 15}, {'jane':12,}, {'dave':10,}] print(sorted(students,key=lambda x:x.copy().popitem()[1])) #因为字典中只有一个键值对,我们想通过字典而其键不同找到不同的值,可以考虑popitem(),popitem()随机删除字典中的一个键值对,并以元组的形式返回删除的键值对的键和值,因为字典中只有一个键值对所以通过popitem()再结合元组索引就可以找到字典的值,而我们要求字典不能改变所以通过copy()再复制一份 # [{'dave': 10}, {'jane': 12}, {'john': 15}]
students = [{'john': 15}, {'jane':12,}, {'dave':10,}]
print(sorted(students,key=lambda x:list(students[students.index[x]].values())[0])) #使用values也可以
#[{'john': 15}, {'jane': 12}, {'dave': 10}]
###*******************偏函数******************* import functools int2 = functools.partial(int,base=2) print(int2("101111")) # ==>int("101111",base=2),把字符串"101111"当做2进制,转化成10进制 #47 #创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数 int2 = functools.partial(int, base=2) ==> kw = { 'base': 2 } # ==> int('10010', **kw) max2 = functools.partial(max, 10) #10作为*args的一部分自动加到左边,也就是 max2(5, 6, 7) ==> args = (10, 5, 6, 7) # ==> max(*args)
语法糖对于计算机的运行并没有任何的好处,但是对于程序员的好处是很大的,方便我们写代码,所以称为糖
#******************************装饰器************************* # 装饰器本质上就是一个python函数，他可以让其他函数在不需要做任何代码变动的前提下，增加额外的功能，装饰器的返回值也是一个函数对象。 # 装饰器的应用场景：比如插入日志，性能测试，事务处理，缓存等等场景 import time def func1(): print('in func1') def timer(func): def inner(): start = time.time() func() #这里的func取得是形参,形参给的是func1,所以这里执行的是func1() print(time.time() - start) return inner func1 = timer(func1) #func1作为参数传递到timer函数中,timer函数返回一个inner的返回值赋值给func1,func1()也即inner() func1() #timer这个函数是用来计算别的函数(形参为函数名)的运行时间
#********装饰器语法糖****** import time def timer(func): def inner(): start = time.time() func() print(time.time() - start) return inner @timer #==> func1 = timer(func1) 除了这条语句,其他的语句都一样,而@timer 就相当于 timer(func1)语句, #这个@timer语句相当于把timer函数和与它相邻的下一个函数以func1 = timer(func1)这样的形式关联起来 def func1(): print('in func1') time.sleep(1) #延时1s def func2(): print('in func2') time.sleep(2) #延时2s func1() func2() # in func1 # 1.0009326934814453 输出结果是1s多,很明显func1函数扩展了计时功能 # in func2
import time def timer(func): def inner(): start = time.time() func() print(time.time() - start) return inner @timer #==> func1 = timer(func1) 除了这条语句,其他的语句都一样,而@timer 就相当于 timer(func1)语句, #这个@timer语句相当于把timer函数和与它相邻的下一个函数以func1 = timer(func1)这样的形式关联起来 def func2(): print('in func2') time.sleep(2) #延时2s def func1(): print('in func1') time.sleep(1) #延时1s func1() func2() # in func1 # in func2 # 2.0009799003601074 #这次因为func2和timer相邻,所以fun2扩展了计时功能
#*********装饰带参数函数*********** import time def timer(func): def inner(a): #这个a是形参,funcl(1)中的实参首先传给他 start = time.time() func(a) #func(a)中的func本身就是以函数为变量的形参,运行时func值实际为funcl,而a作为形参同时作为变量a的值与上面一致是1 print(time.time() - start) return inner @timer def func1(a): #这个a也是形参,与上面两个保持一致 print(a) #这个a不是必须的,此处只是使用它打印 func1(1) #inner
from functools import wraps def deco(func): @wraps(func) #加在最内层函数正上方,这个是必要的,不然会出错 def wrapper(*args,**kwargs): return func(*args,**kwargs) return wrapper @deco def index(): '''哈哈哈哈''' print('from index') print(index.__doc__) #查看函数注释的方法 print(index.__name__) #查看函数名的方法
import time def func1(): '''注释1''' print('in func1') def timer(func): def inner(): '''注释2''' start = time.time() func() print(time.time() - start) return inner func1 = timer(func1) print(func1.__name__) print(func1.__doc__) # in func1 # 0.0 # inner 不使用@wraps(func)这个东西时,会认为func1的名字的注释是inner的名字和注释 # 注释2
#******************装饰器的固定格式************ def timer(func): def inner(*args,**kwargs): '''执行函数之前要做的''' re = func(*args,**kwargs) '''执行函数之后要做的''' return re return inner from functools import wraps def deco(func): @wraps(func) #加在最内层函数正上方 def wrapper(*args,**kwargs): return func(*args,**kwargs) return wrapper *****************带参数的装饰器,带上标志可以灵活的决定是否使用装饰器************** def outer(flag): def timer(func): def inner(*args,**kwargs): if flag: print('''执行函数之前要做的''') re = func(*args,**kwargs) if flag: print('''执行函数之后要做的''') return re return inner return timer @outer(False) def func(): print(111) func() #******************多个装饰器装饰一个函数*************** def wrapper1(func): def inner(): print('wrapper1 ,before func') func() print('wrapper1 ,after func') return inner def wrapper2(func): def inner(): print('wrapper2 ,before func') func() print('wrapper2 ,after func') return inner @wrapper2 @wrapper1 def f(): print('in f') f()
##多个装饰器装饰一个函数详解
def wrapper1(fn): def inner(*args,**kwargs): print("我是wrapper1前面的") ret = fn(*args,**kwargs) print("我是wrapper1后面的") return ret return inner def wrapper2(fn): def inner(*args,**kwargs): print("我是wrapper2前面的") ret = fn(*args,**kwargs) print("我是wrapper2后面的") return ret return inner @wrapper1 # @wrapper1 可以看做是 wrapper2 = wrapper1(wrapper2) @wrapper2 # @wrapper2 可以看做是 func = wrapper2(func) 但却不能直接用这两个语句替换,应该使用func = wrapper1(wrapper2(func)) def func(): print("我是func") func() ''' 我是wrapper1前面的 我是wrapper2前面的 我是func 我是wrapper2后面的 我是wrapper1后面的 ''' def wrapper1(fn): def inner(*args,**kwargs): print("我是wrapper1前面的") ret = fn(*args,**kwargs) print("我是wrapper1后面的") return ret return inner def wrapper2(fn): def inner(*args,**kwargs): print("我是wrapper2前面的") ret = fn(*args,**kwargs) print("我是wrapper2后面的") return ret return inner def func(): print("我是func") func = wrapper1(wrapper2(func)) #即多个装饰器的实际语句是 func = wrapper1(wrapper2(wrapper3(...(wrapper100(func))))) func() ''' 我是wrapper1前面的 我是wrapper2前面的 我是func 我是wrapper2后面的 我是wrapper1后面的 '''
#*****最全的固定格式 from functools import wraps def wrapper_out(flag): def wrapper(fn): @wraps(fn) def inner(*args,**kwargs): if flag: #flag为真执行装饰器 '''函数执行前语句''' ret = fn(*args,**kwargs) '''函数执行后语句''' return ret else: #flag为假不执行装饰器 ret = fn(*args, **kwargs) return ret return inner return wrapper @wrapper_out(True) def func(*args,**kwargs): print("我是func")
func()
print(func.__name__,func.__doc__)
# 我是func
# func None
