python函数式编程

#函数式编程
#高阶函数
# 匿名函数
# 返回函数
# 装饰器
# 偏函数

#匿名函数：lambda函数，对于简短的函数可以使用lambda进行定义，只是一个表达式，函数体简单
strm = lambda x,y : x+y
s = lambda x: x * 100

# 高阶函数，把函数当成变量使用
def funA(n):
    return n*100

def funB(n, f):
    return f(n)*10

# 系统高阶函数map,将列表或者集合内所有元素按照一定规则进行操作，返回可迭代对象
list1 = [i for i in range(10)]
def funC(n):
    return n*7
mapaa = list(map(funC,list1))
print(mapaa)


from functools import reduce

#reduce 归并、缩减，把一个可迭代对象最后归并为一个结果 reduce([1,2,3]) == f(f(1,2),3)
list2 = [i for i in range(10)]
def myAdd(x, y):
    return x+y

gb = reduce(myAdd, list2)
print(gb)


#filter过滤
#与map相同，都是对列表每个元素进行操作
#不同：map生成一个与原来列表相对应的新列表，filter只有符合条件的才能进入新列表
def isEven(a):
    if a % 2 == 0:
        return a

aa = [1,334,563,2,4,556,677545]
rst = list(filter(isEven, aa ))
print(rst)


#高级函数-sorted
#把一个队列按照给定的方法进行排序，key函数排序 算法
bb = [-33,85885,99,334,2,34,1,-99]
#按绝对值进行排序,reverse默认升序，True降序
ss = sorted(bb, key=abs, reverse=True)
print(ss)

#按字母小写排序
aa = ['ddjfdsk','ddje','Djie','heuk']
bb = sorted(aa, key=str.lower)
print(bb)

#返回函数：函数可以返回具体的值，也可以返回一个函数
#函数被作为返回值返回，被返回的函数在函数内定义
def myF2():
    def myF3():
        print("I am myF3")
        return 'F3'
    return myF3

f3 = myF2()
print(f3())
myF2()

def myF4(*args):

    def myF5():
        rst = 0
        for i in args:
            rst += i
        return rst
    return myF5

f4 = myF4(*(1,2,3,4,5,6,7,8))
print(f4())

#闭包：
#在一个函数内部定义函数，当内部函数使用外部函数的参数或者局部遍历，当内部函数被当成返回值的时候，相关参数或者变量保存在返回函数中，这种结果叫闭包
#上面定义的myF4就是典型的闭包结构

#闭包常见的坑
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())   #结果为9
print(f2())  #结果为9
print(f3())  #结果为9
#造成这个原因是返回函数引用了变量i，而i并非立即执行，只有等三个函数都返回时才进行执行，而此时i = 3，所有每个函数返回都为9
#此问题描述成：返回闭包时，返回的函数不能引用任何循环变量
#解决方案：在创建一个函数，用该函数的参数绑定循环变量的当前值，无论循环变量如何改变，已经绑定的函数参数值不会改变

def count1():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1,4):
        fs.append(f(i))
    return fs

f1,f2,f3 = count1()
print(f1())   #结果为9
print(f2())  #结果为9
print(f3())  #结果为9


#新需求，对hello函数进行扩展，在打印hell之前打印系统时间，而又不改变原有函数功能，此时可以使用装饰器
#装饰器：在不改变函数原有的功能上无限扩展函数功能的一种机制，装饰器本质上是一个返回函数的高阶函数
#语法：@,在每次要扩展打函数名前加上@+函数名，python中语法糖

import time
#对hello函数进行扩展，在打印hell之前打印系统时间
def printTime(f):
    def wrapper(*args,**kwargs):
        print(time.ctime())
        return f(*args,**kwargs)
    return wrapper

@printTime
def hello():
    print("hello world")

hello()

#装饰器好处，一旦定义就可以装饰任意函数
#一旦被其装饰，则把装饰器的功能直接添加到被装饰函数上面

#下面手动执行装饰器
def hello3():
    print('我是手动执行')

hello3 = printTime(hello3)
hello3()


#偏函数：把函数的参数固定，相当于有特定参数的函数体
#functools.partial作用就是把一个函数的某些参数固定，返回一个新的函数
import functools
int16 = functools.partial(int , base=16)
print(int16("12763"))

#!/usr/bin/env python
#-*-coding:utf-8-*-
#author:白杨

#函数式编程
#高阶函数
# 匿名函数
# 返回函数
# 装饰器
# 偏函数

#匿名函数：lambda函数，对于简短的函数可以使用lambda进行定义，只是一个表达式，函数体简单
strm = lambda x,y : x+y
s = lambda x: x * 100

# 高阶函数，把函数当成变量使用
def funA(n):
   return n*100

def funB(n, f):
   return f(n)*10

# 系统高阶函数map,将列表或者集合内所有元素按照一定规则进行操作，返回可迭代对象
list1 = [i for i in range(10)]
def funC(n):
   return n*7
mapaa = list(map(funC,list1))
print(mapaa)


from functools import reduce

#reduce 归并、缩减，把一个可迭代对象最后归并为一个结果 reduce([1,2,3]) == f(f(1,2),3)
list2 = [i for i in range(10)]
def myAdd(x, y):
   return x+y

gb = reduce(myAdd, list2)
print(gb)


#filter过滤
#与map相同，都是对列表每个元素进行操作
#不同：map生成一个与原来列表相对应的新列表，filter只有符合条件的才能进入新列表
def isEven(a):
   if a % 2 == 0:
      return a

aa = [1,334,563,2,4,556,677545]
rst = list(filter(isEven, aa ))
print(rst)


#高级函数-sorted
#把一个队列按照给定的方法进行排序，key函数排序 算法
bb = [-33,85885,99,334,2,34,1,-99]
#按绝对值进行排序,reverse默认升序，True降序
ss = sorted(bb, key=abs, reverse=True)
print(ss)

#按字母小写排序
aa = ['ddjfdsk','ddje','Djie','heuk']
bb = sorted(aa, key=str.lower)
print(bb)

#返回函数：函数可以返回具体的值，也可以返回一个函数
#函数被作为返回值返回，被返回的函数在函数内定义
def myF2():
   def myF3():
      print("I am myF3")
      return 'F3'
return myF3

f3 = myF2()
print(f3())
myF2()

def myF4(*args):

   def myF5():
      rst = 0
for i in args:
         rst += i
      return rst
   return myF5

f4 = myF4(*(1,2,3,4,5,6,7,8))
print(f4())

#闭包：
#在一个函数内部定义函数，当内部函数使用外部函数的参数或者局部遍历，当内部函数被当成返回值的时候，相关参数或者变量保存在返回函数中，这种结果叫闭包
#上面定义的myF4就是典型的闭包结构

#闭包常见的坑
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())   #结果为9
print(f2())  #结果为9
print(f3())  #结果为9
#造成这个原因是返回函数引用了变量i，而i并非立即执行，只有等三个函数都返回时才进行执行，而此时i = 3，所有每个函数返回都为9
#此问题描述成：返回闭包时，返回的函数不能引用任何循环变量
#解决方案：在创建一个函数，用该函数的参数绑定循环变量的当前值，无论循环变量如何改变，已经绑定的函数参数值不会改变

def count1():
   def f(j):
      def g():
         return j*j
      return g
   fs = []
   for i in range(1,4):
      fs.append(f(i))
   return fs

f1,f2,f3 = count1()
print(f1())   #结果为9
print(f2())  #结果为9
print(f3())  #结果为9


#新需求，对hello函数进行扩展，在打印hell之前打印系统时间，而又不改变原有函数功能，此时可以使用装饰器
#装饰器：在不改变函数原有的功能上无限扩展函数功能的一种机制，装饰器本质上是一个返回函数的高阶函数
#语法：@,在每次要扩展打函数名前加上@+函数名，python中语法糖

import time
#对hello函数进行扩展，在打印hell之前打印系统时间
def printTime(f):
   def wrapper(*args,**kwargs):
      print(time.ctime())
      return f(*args,**kwargs)
   return wrapper

@printTime
def hello():
   print("hello world")

hello()

#装饰器好处，一旦定义就可以装饰任意函数
#一旦被其装饰，则把装饰器的功能直接添加到被装饰函数上面

#下面手动执行装饰器
def hello3():
   print('我是手动执行')

hello3 = printTime(hello3)
hello3()


#偏函数：把函数的参数固定，相当于有特定参数的函数体
#functools.partial作用就是把一个函数的某些参数固定，返回一个新的函数
import functools
int16 = functools.partial(int , base=16)
print(int16("12763"))