#====================高阶函数=================
'''
1、python中所有变量都可以理解为指针
2、函数名是函数的指针,也可以理解为一个变量,也可以将函数名赋值给另个变量
3、高阶函数:既然变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数
'''
print(abs)
f = abs
print(f)
abs=1000#变量重新赋值
print(f(-100))
print(abs)
#高阶函数
def add(x, y, f):
return f(x,y)
print(add(-10,50,max))
abs=f
#====================map()和reduce()函数=================
'''
1、map函数:map()函数接收两个参数,一个是函数,一个是Iterable,
map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回。
2、reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
这个函数必须接收两个参数
'''
#map函数
def f(x):
return x * x
L=[1, 2, 3, 4, 5, 6, 7, 8, 9]
R=map(f,L)
print(R)
print(list(R))
#reduce函数
from functools import reduce
def fn(x, y):
return x * 10 + y
x=reduce(fn,L)
print(x)
#====================filter()函数=================
'''
1、filter()函数用于过滤序列。
和map()类似,filter()也接收一个函数和一个序列。和map()不同的是,
filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。
'''
#求解素数问题:埃氏筛法
def Primary():
x=2 #1不是素数,所有初始序列从2开始
while(True):
yield x
x+=1
def Choose(n):#用于多个参数的情况
def fun(x): #内部函数可以使用外部函数数据
return x%n
return fun
def Primes():
it = Primary() # 初始序列迭代器
while True:
n = next(it) # 返回序列的第一个数
yield n
it = filter(Choose(n), it) # 原迭代器经过筛选返回新迭代器
P=Primes() #素数生成器
for n in P:
if n < 100:
print(n,end="\t")
else:
break
print("")
#====================sorted函数=================
'''
sorted()函数也是一个高阶函数,它还可以接收一个key函数来实现自定义的排序
key指定的函数将作用于序列的每一个元素上,并根据key函数返回的结果进行排序。
要进行反向排序,可以传入第三个参数reverse=True:
'''
L=[36, 5, -12, 9, -21]
x=sorted(L)
print(x)
print(L)#原序列没有改变
x=sorted(L,key=abs)
print(x)
S=['bob', 'about', 'Zoo', 'Credit']
print(sorted(S))
print(sorted(S,key=str.lower))
print(sorted(S,key=str.lower,reverse=True))
#====================函数作为返回值=================
''''
内部函数sum可以引用外部函数lazy_sum的参数和局部变量,
当lazy_sum返回函数sum时,相关参数和变量都保存在返回的函数中,
这被称为闭包(Closure),同时可以保证多层调用相互独立
'''
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
f = lazy_sum(1, 3, 5, 7, 9)#返回一个函数
print(f)
print(f(),f())
f1 = lazy_sum(10, 30, 50, 70, 90)
print(f1())
print(f==f1)
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
print(f1(), f2(), f3() )
'''
由这个例子可以看出,返回的函数和被掉的原函数一起被闭包,
但是当调用一次count()是返回了三个函数,所有这三个函数共享一个外层函数
因为返回函数没有马上调用,所有当count()执行到return是i已经为3了
返回闭包时牢记一点:返回函数不要引用任何循环变量,或者后续会发生变化的变量。
如果一定要引用循环变量怎么办?方法是再创建一个函数,用该函数的参数绑定循环变量当前的值,
无论该循环变量后续如何更改,已绑定到函数参数的值不变:
'''
def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1, 4):
fs.append(f(i)) # f(i)立刻被执行,因此i的当前值被传入f()
return fs
#这个时候函数g的外层函数为f,所有闭包的是f和g
f1, f2, f3 = count()
print(f1(), f2(), f3() )
#====================匿名函数=================
'''
关键字lambda表示匿名函数,冒号前面的x表示函数参数。
匿名函数有个限制,就是只能有一个表达式,不用写return,返回值就是该表达式的结果。
'''
#做参数
L=list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(L)
#赋值调用
f=lambda x: x * x
print(f(5))
#==============装饰器=====================
def now():
print('2015-3-25')
#装饰器(decorator)函数:参数和返回值都是一个函数
def log(func):
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
#添加装饰器
@log
def now():
print('2015-3-25')
now()
'''
实际上是将当前函数now传入装饰器函数进行一番装饰在将返回函数给当前函数now
相当于:now=log(now)
'''
#如果decorator本身需要传入参数,那就需要编写一个返回decorator的高阶函数
def log(text):
def decorator(func):
def wrapper(*args, **kw):
print('%s %s():' % (text, func.__name__))
return func(*args, **kw)
return wrapper
return decorator
#这个地方相当于将log('execute')返回函数decorator放在@后
#即@decorator
@log('execute')
def now():
print('2015-3-25')
#产看函数的名字,已经变了
print(now.__name__)
#一般需要保证名字不变,可以使用wrapper.__name__ = func.__name__
#但一般使用functools.wraps来干这个事
#即在定义wrapper()的前面加上@functools.wraps(func)即可。
import functools
def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
def log(text):
def decorator(func):
@functools.wraps(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')
print(now.__name__)
#==============偏函数=====================
'''
functools.partial就是帮助我们创建一个偏函数的.
functools.partial的作用就是,把一个函数的某些参数给固定住(也就是设置默认值),返回一个新的函数
'''
print(int("1000000",base=2))
int2 = functools.partial(int, base=2)
print(int2('1000000'))
#创建偏函数时,实际上是为函数添加一些*args和**kw参数
#上面的int2就相当于
kw = { 'base': 2 }
print(int('10010', **kw))
max2 = functools.partial(max, 10)
#实际上会把10作为*args的一部分自动加到左边,也就是
print(max2(5, 6, 7))
args = (10, 5, 6, 7)
print(max(*args))
Python基础:高阶函数
最新推荐文章于 2024-06-30 16:27:45 发布