函数式编程

函数式编程(python)

一：高阶函数

1：变量可以指向函数

abs(-10) -->10
x = abs(-10) --> x = 10
y = abs  --> <built-in function abs>   #变量本身可以指向函数
z = abs  z(-10) --> 10

2：函数名也是变量

abs = 10  abs(-10) --> 报错
注：由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其它模块也生效，要用import builtins; builtins.abs = 10。

3：传入函数

如果一个函数能够接受另一个函数作为参数，那个这个函数就称为高阶函数
eg:
    def add(x,y,f):
        return f(x)+f(y)
    x = -5
    y = -2
    f = abs  # 注意：不能写为 f = abs()
    print(add(x,y,f))  --> 7
上述：add函数能够接受abs函数作为参数，因此将add函数称为高阶函数

4：map/reduce

4.1:iterable & iterator

iterable 用来判断是否可以迭代
iterator 用来判断是否是迭代器
凡是可以for循环的 都是Iterable
凡是可以next()的，都是Iterator
集合数据类型：list、tuple、dict、set 都是Iterable 不是 Iterator，但可以通过iter()获得一个Iterator对象
for循环的本质就是通过next()来获取下一个对象
    list1 = [1,3,2,4]
    for it in list1:
        pass
    上述for循环等价于以下代码
    it = iter(list1)
    while True:
        try:
            x = next(it)
        except StopIteration:
            break

4.2：map函数

map(f(s),Iterable)函数接受两个参数、第一个参数为一个函数，一个是Iterable 
map将传入的函数依次作用的序列的每个元素，并将结果作为新的Iterator返回
eg:
def f(x):
    return x*x
list1 = [1,2,3,4,5]
r = map(f,list1)  # r 是一个Iterator
print(list(r)) --> [1,4,9,16,25]
list(map(str,[1,2,3])) -->['1','2','3']

4.3:reduce函数

python3默认不会加载reduce函数，需要进行导入：from functools import reduce
reduce(f(x),Iterable) 要执行的函数必须接收两个参数，这两个参数进行运算，并将运算的结果再次和第三个元素进行运算，依次类推！

4.4： filter函数

filter 会让列表中的每一元素都执行一次函数，并将执行函数返回为真或不为None的结果
eg:
def test(s):
if s % 2 ==0:
    return s
list3 = [4,23,6,7,8]
n = filter(test,list3)
print(list(n)) -->[4, 6, 8]

4.5:sorted排序函数

1：默认从小到大排序
    eg1:
    list4 = [3,5,-2,8,6,-4]
    print(sorted(list4)) --> [-4,-2,3,5,8,6]
    list5 = ['zhangsan','Lisi','wangwu']
    print(sorted(list5)) -->['Lisi', 'wangwu', 'zhangsan']  # 对字符串排序遵从ASCii码顺序
2：可用key函数来实现自定义排序
    list4 = [3,5,-2,8,6,-4]
    print(sorted(list4,key=abs)) --> [-2,3,-4,5,8,6]
    list5 = ['zhangsan','Lisi','wangwu']
    print(sorted(list5,key=str.lower)) -->['Lisi', 'wangwu', 'zhangsan']反向排序
3:可用reverse=True 进行反向排序
    list4 = [3,5,-2,8,6,-4]ur
    print(sorted(list4,key=abs,reverse=True --> [8, 6, 5, -4, 3, -2]
    list5 = ['zhangsan','Lisi','wangwu']
    print(sorted(list5,key=str.lower)) -->['zhangsan', 'wangwu', 'Lisi']

二：返回函数

2.1 函数作为返回值

1:通常的求和函数
    def wg_add(*args):
        sum = 0
        for i in args:
            sum = sum +i
        return sum
    print(wg_add(1,3,5,6)) --> 15
2:若不需要立即求和，要在后面的代码中根据需要计算可进行如下改写
    def wg_add1(*args):
        def sum1():
            sum = 0
            for i in args:
                sum = sum+i
            return sum
        return  sum1  # return sum1()
    f = wg_add1(1,2,3)
    # 当我们调用 wg_add1函数时，返回的并不是求和结果，而是求和函数,当我们调用f时，才正真返回求和结果
    print(f) --><function wg_add1.<locals>.sum1 at 0x0000000002B1B840>
    print(f())  -->6

2.2：闭包

闭包是指：
1：当一个内函数使用了外函数的临时变量
2：外函数的返回值是内函数的引用

eg1:

    def outer(y):
        x = 10
        def inner():
            # x = 2      # 当直接修改x的值是实际上是重新定义了一个x对象、并未实质修改其外函数的临时变量的值
            nonlocal x  # 若此处需要修改临时变量x 的值，需要在此处申明nonlocal关键字
            x=2
            return x+y # 内函数使用了外函数的临时变量
        return inner(),x  # 外函数的返回值是内函数的引用
    print(outer(20))  --> (22, 2)
eg2:
    def wg_coun():
        wg1 = []
        for i in range(1,4):
            def wg_f():
                return i*i
            wg1.append(wg_f)
        return wg1
    w1,w2,w3 = wg_coun() # 并非立即执行
        # 每次循环都创建了一个函数，将创建的3个函数都返回
        #当调用w1()是才会执行，此时，应用的变量i变为了3，所以最终结果为9
    print(w1(),w2(),w3())  -->9,9,9 

三：匿名函数

函数语法： lambda arg1,arg2:expression

print(list(map(lambda x:x*3,[1,2,3,4]))) --> [3, 6, 9, 12]

3.1 无参匿名函数

t = lambda :True
print(t())  --> True

3.2 带参匿名函数

t = lambda x,y:x+y
print(t(1,3)) --> 4

3.3 匿名函数调用

t = lambda x,y:x+y
# 用t(arg1,arg2)进行匿名函数调用
print(t(1,3)) --> 4

3.4 嵌套使用

# lambda嵌套到普通函数中,lambda函数本身做为return的值
def wg2(n):
return lambda x:x+n
print(wg2(3)(4)) --> 7

四：装饰器

python 装饰器是用来拓展原来函数功能的一种函数，这种函数的特殊之处是它的返回值也是一种函数、使用python装饰器的好处是在不用更改原函数代码的前提下给函数增加新功能

1：一般而言，我们要拓展原函数，最直接的方式就是侵入到原函数代码里面进行修改

转载于:https://www.cnblogs.com/banjieyu/p/9408283.html