Python函数式编程初级学习

时间:2021-08-14 08:31:41

函数式编程即函数可以作为参数传入函数,也可以返回函数。

1.高阶函数
    函数可以作为参数传入函数。
    def add(x,y,f):
        return f(x)+f(y)
    调用add函数add(3,-4,abs) ,结果为7
2.map/reduce
   def f(x):
       return x*x
    map(f,[1,2,3,4,5]) 返回的是一个Iterator,用list()可以把它全部显示出来。map()的作用即把f函数作用于第二个Iterable参数的每一个元素上。
    def add(x,y):
        return x+y
    reduce(add,[1,2,3,4,5])返回的同样也是一个Iterator。
    上一个语句就相当于add(add(add(add(1,2),3),4),5).所以reduce()接收的第一个函数参数就只能是接收两个参数的函数。
map/reduce都是高阶函数
3.filter/sorted
   (1) 以输出素数为filter()的例子
    ①初始数列直接考虑奇数列,除2之外偶数均非素数
        def _odd_iter():
          n=1
while True:#这是一个生成器,所以不用担心没有退出条件的问题
n=n+2
yield n
    ②排除条件
        def _delete(n):
         return lambda x: x % n >0
 ③输出素数
   def primes():
           yield 2  #因为2不在初始奇数列中,所以先输出2
it=_odd_iter()#初始数列
while True:
n=next(it)
yield n
              it = filter(_delete(n),it)  #filter()将it中_delete()作用后为False的                                                                                                     #元素都删除
    ④限定一个输出范围 否则将无限输出下去
        for n in primes():
       if n < 1000:
print(n)
else:
break
(2)sorted()
    L=[('Bob',75),('Adam',92),('Bart',66),('Lisa',88)]
       def by_name(t):
return t[0]
L2=sorted(L,key=by_name) #类似map,key参数接收的函数也是作用于L的每一个元素
                                 #所以这里返回的就是Bob,Adam,Bart,Lisa,然后再对L的元素排序
                                 #key只是排序依据,不改变L
print(L2)
def by_score(t):
return t[1]
L3=sorted(L,key=by_score)
print(L3)
Output:[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]
[('Bart', 66), ('Bob', 75), ('Lisa', 88), ('Adam', 92)]

对于str,sorted()是按ASCII来排序的,所以大写会排在小写之前
L=['Credit','about','Zoey','Bart','effect']
print(sorted(L))
OUTPUT:['Bart', 'Credit', 'Zoey', 'about', 'effect']

print(sorted(L,reverse=True))  #reverse参数为反转
Output:['effect', 'about', 'Zoey', 'Credit', 'Bart']  
4.返回函数
    高阶函数不仅可以接收函数作为参数,还可以返回函数。
   当调用函数不需要立刻得到结果,而是想以后的需要的时候再计算结果,可以返回函数。
    def lazy_sum(*args):
def sum():
ax=0
for n in args:
ax=ax+n
return ax
return sum
f=lazy_sum(1,2,3,4,5)
   当运行之后,lazy_sum返回一个sum函数,赋值给f,lazy_sum()由args的传入的相关参数和变量也都保存在f中,但还未计算,等到调用时f会使用这些参数并计算。这种现象称为“闭包”。
   因为f是当调用时才计算结果
   def count():
fs=[]
for i in range(1,4):
def f():
return i*i
fs.append(f)
return fs #因为fs.append(f)中f是一个函数,所以这里也有返回函数的意思
f1,f2,f3=count()
print(f1())#这里调用时,上面一句3个函数都已经返回了,此时的i已经变成3,所
#以接下来调用f2,f3,它们保存的参数i都为3,所以最后结果都是9 print(f2())
   print(f3())
Output:9
        9
        9
所以返回函数时,返回函数里不要有可能会变化的变量。
5.匿名函数
   其实就是一个简易的函数定义式
   如def f(x):
        return x*x
 写成匿名函数就lambda x : x*x  #冒号左边的x是参数,右边是返回式
6.装饰器(Decorator)
   在运行代码期间动态增加功能,但又不改变函数原来的定义。
  import functools
   def log(func):
@functools.wraps(func) #相当于wrapper.__name__=func.__name__,如果没有这一句,运行now.__name__就会得到wrapper,因为log返回的函数是wrapper
def wrapper(*args,**kw):
print('call %s():'%func.__name__) #打印日志
return func(*args,**kw) #调用函数
return wrapper #所以log(now)即返回wrapper函数,wrapper函数的功能就是先打印日志,再调用输入的函数
@log
def now(): #这两句相当于now=log(now)
print('2016.8.10')
print(now())
Output:
call now():
2016.8.10
7.偏函数
  import functools
int2 =functools.partial(int,base=2) #把某个函数的某个参数设一个默认值,生成一个新的函数
print(int2('100000'))
   print(int2('12345',base=8)) #这个新的函数任然是可以更改这个参数值的,只是它有一个默认的参数值
   Output:
        32 
        5349
其实就相当于
  def int2(x,base=2)
      return int(x,base)