Python中的函数式编程（成长的路就是孤独的）

函数式编程简介

上图说明不同语言的抽象层次不同，，汇编语言更接近于计算机的语言，越低级的语言越接近计算机，抽象程度越低，执行效率越高。函数式编程是一种抽象程度很高的编程范式，其可以归结到面向过程的程序设计，但其思想更接近于数学计算。Python允许使用变量，所以Python不是纯函数式编程语言。
函数式编程的一个特点：允许把函数本身作为参数传入另一个函数，也允许返回一个函数。

高阶函数

那么一个函数可以接收另一个函数作为参数的函数就称为高阶函数：

def add(x, y, f):
    return f(x) + f(y)


print(add(-2, 7, abs))

>>9

map()、reduce()、filter() 和 sorted() 是Python内置的两个高阶函数。

map&reduce

map()接收一个函数和一个list，通过吧函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。比如如果我们希望将 list 中的每个元素都做平方，即可如下操作：

def f(x):
    return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

print(list(r))

>>[1, 4, 9, 16, 25, 36, 49, 64, 81]

map() 不仅仅可以处理只包含数值的 list，它可以处理包含任意类型的 list，只要传入的函数 f 可以处理这种数据类型。
reduce() 函数接收的参数也是一个函数 f，一个list，但 reduce() 传入的函数 f 必须接收两个参数，reduce() 对 list 的每个元素反复调用函数 f ，并返回最终结果值。例如求一个序列的和：

from functools import reduce # 安装reduce
def add(a, b):
    return a + b

r3 = reduce(add, [1, 3, 5, 7, 9])
print(r3)
r4 = reduce(add,[1, 3, 5, 7, 9], 10)
print(r4)

>>25
>>35

其中，reduce() 函数可输入第三个作为初始值。
split() 将一个字符串按照要求分割出字符串数组；pow(x, y) 求 x 的 y 次幂。

filter

filter() 函数同样是接收一个函数 f 和一个 list ，f 的作用是对每个元素进行判断，返回 True 或 False ，filter() 根据判断自动过滤掉不符合条件的元素，例如我们需要保留序列 L = [1,2,3,4,5,6] 中的奇数，则：

L = [1, 2, 3, 4, 5, 6]

def odd(x):
    return x % 2 == 1

R = filter(odd, L)
print(list(R))

>>[1, 3, 5]

s,strip(rm)的作用是删除 s 字符串中开头、结尾处的 rm 序列的字符；a[::-1]的意思是将字符串a的内容进行反转；matn.sqr()即是求解某数的算术平均根。

sorted

sorted() 函数的作用是对 list 进行排序：

L = [1, 6, 8, -2, 4, 10, 0]
R = sorted(L)
print(R)

>>[-2, 0, 1, 4, 6, 8, 10]

也可以对字符串进行排序，默认是按照字符串的ASCII码大小来排序的：

L1 = ['hello', 'giveME colorCC', 'WS']
R1 = sorted(L1)
print(R1)

>>['WS', 'giveME colorCC', 'hello']

当然，sored() 也可以自定义排序，我们定义其排序方式安装绝对值大小排序：

L2 = [1, 6, 8, -2, 4, 10, 0]
R2 = sorted(L2, key = abs)
print(R2)

>>[0, 1, -2, 4, 6, 8, 10]

返回函数

高阶函数除了可以接受函数作为参数外，还可以把返回函数作为结果。以下为求和函数，但是我们可以选择是返回函数还是返回求和结果：

def lazy_sum(args):
#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])
#f = lazy_sum(1, 2, 3, 4)
print(f) #返回函数
print(f()) #返回计算结果

>><function lazy_sum.<locals>.sum at 0x0000022F2C7E8BF8>
>>10

注意区别返回函数和返回值：

def my_abs():
    return abs   # 返回函数
def my_abs2(x):
    return abs(x)   # 返回函数调用的结果，返回值是一个数值

内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包。闭包的特点是返回的函数还引用了外层函数的局部变量，所以，返回闭包时，返回函数不要引用任何循环变量，或者后续会发生变化的变量。

匿名函数

高阶函数可以接收函数做参数，有时候传入匿名函数可能比显示地定义函数更方便。匿名函数 lambda x: x * x就代表：

def f(x):
    return x * x

其中【lambda】就代表匿名函数，冒号前面的x代表函数参数。匿名函数不需要定义函数名，不用写return，只能有一个表达式，返回值就是表达式的结果。例用匿名函数改写下面的代码：

def is_odd(n):
    return n % 2 ==1
L = list(filter(is_odd,range(1,20)))
print(L)
L1 = list(filter(lambda n : n % 2 == 1,range(1,20)))
print(L1)

>>[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

装饰器

emmmm，学了好久，这个最好。
*args是非关键字参数，用于元组，**kw是关键字参数，用于字典例：

def f(x, *args, **kw):
    print(x)
    print(args)
    print(kw)

f(1, 2, 3, 4, y=1, a=2, b=3, c=4) 
# 将1传给了x，将2,3,4以元组方式传给了args，y=1,a=2,b=3,c=4以字典的方式给了kw

>>1
>>(2, 3, 4)
>>{'y': 1, 'a': 2, 'b': 3, 'c': 4}

偏函数

【functools.partial】代表偏函数，其作用就是把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。利用偏函数创建一个新的函数int2：

import functools
int2 = functools.partial(int, base=2)
print(int2('1000000'))

>>64

函数式编程、面向过程编程、面向对象编程，真的是看得我云里雾里的。。。。关于区分请看bieleyang的解释，看完可能会出现一缕阳光，哈哈。好了，这次就到这里了，下次来说说面向对象编程。(我在坚持，你还在吗？)