Python高级-函数式编程2

The core values of Chinese socialism

filter函数

• 过滤函数：对一组数据进行过滤，符合条件的数据会生成一个新的列表并返回
• 跟map相比较
  • 相同：都对列表中的每一个元素进行逐一操作
  • 不同：
    • map会生成一个跟原来数据相对应的新队列
    • filter不一定，只要符合条件的才会进入新的数据集合
  • filter函数写法：
    • 利用给定函数进行判断
    • 返回值一定是布尔值
    • 调用格式：filter(f, data)，f是过滤函数，data是数据

# filter案例
# 对于一个列表进行过滤，偶数组成一个新列表

# 需要订义过滤函数
# 过滤函数要求有输入，返回布尔值
def isEven(a):
    return a%2==0

l = [2, 435445, 44233, 5642, 678, 345, 9807]

rst = filter(isEven, l)
# 返回的filter内容是一个可迭代对象
print(type(rst))
print(rst)
print([i for i in rst])

<class 'filter'>
<filter object at 0x108458b00>
[2, 5642, 678]

高阶函数-排序

• 把一个序列按照给定算法进行排序
• key：在排序前对每一个元素进行key函数运算， 可以理解成按照key函数定义的逻辑进行排序

# 排序案例

a = [223, 435, 633, 54565, 7436,3434, 8495]
al = sorted(a, reverse=True)
print(al)

[54565, 8495, 7436, 3434, 633, 435, 223]

# 排序案例2

a = [-213213, 43532, 543, 77, 3543, -4352]
# 按照绝对值进行排序
# abs求绝对值
al = sorted(a, key=abs)
print(al)

[77, 543, 3543, -4352, 43532, -213213]

返回函数

• 函数可以返回具体的值
• 也可以返回一个函数作为结果

# 定义一个普通的函数
def myFun(n):
    print("In myFun")
    return None
a = myFun(8)
print(a)

In myFun
<class 'NoneType'>
None

# 函数作为返回值返回，被返回的函数在函数体内调用
def myFun2():
    def myFun3():
        print("In myFun3")
        return 3
    return myFun3

# 调用myFun2, 返回一个函数myFun3, 赋值给f3
f3 = myFun2()
print(type(f3))
print(f3)

print(f3())

<class 'function'>
<function myFun2.<locals>.myFun3 at 0x1084dc2f0>
In myFun3
3

# 复杂一点的返回函数的例子
# args: 参数列表
# 1. myFun4定义函数，返回内部定义的函数myFun5
# 2. myFun5使用了外部变量，这个变量是myFun4的参数

def myFun4(*args):
    def myFun5():
        rst = 0
        for n in args:
            rst += n
        return rst
    return myFun5

f5 = myFun4(3, 2, 34, 56, 98, 77)
# f5的调用方式
print(f5())

270

闭包

• 当一个函数在内部定义函数，并且内部的函数应用外部函数的参数或者局部变量，当内部函数被当做返回值的时候，相关参数和变量保存在返回的函数中，这种结果叫闭包
• myFun4是一个标准的闭包结构

def count():
    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= count()
print(f1())
print(f2())
print(f3())

1
4
9

装饰器（Decrator）

• 在不改变函数代码的基础上无限制扩展函数功能的一种机制，本质上讲，装饰器是一个返回函数的高阶函数
• 装饰器的使用：使用@语法，即在每次要扩展的函数定义前使用@+函数名

def hello():
    print("Hello world!")
    
hello()

Hello world!

f = hello
print(type(f))
f()

<class 'function'>
Hello world!

# f和hello是一个函数
print(id(f))
print(id(hello))

4453553696
4453553696

# 现在有新的需求
# 对hello功能进行扩展，每次打印hello之前打印当前系统时间
# 而实现这个功能又不能改动现有代码
# ==>使用装饰器

import time
# 高阶函数，以函数作为参数
def printTime(f):
    def wrapper(*args, **kwargs):
        print("Time:", time.ctime())
        return f(*args, **kwargs)
    return wrapper

# 上面定义了装饰器，使用的时候需要用到@，此符号是Python的语法糖
@printTime
def hello():
    print("Hello world!!")
    
hello()

Time: Sat Jul 27 09:45:20 2019
Hello world!!

# 装饰器好处，一点定义，则可以装饰任意函数
# 一旦被其装饰，则把装饰器功能直接添加到定义函数的功能上
# 不使用@语法糖，手动执行
def hello2():
    print("我是手动执行的")

f = printTime(hello2)
f()

Time: Sat Jul 27 09:56:23 2019
我是手动执行的

偏函数

• 参数固定的函数，相当于一个有特定参数的函数体
• functools.partial的作用是，把一个函数某些函数固定，返回一个新函数

# 把字符串转换成十进制数字
a = int("1234567")
print(type(a))
print(a)

# 求八进制字符串12345，表示成十进制数字是多少
b = int("12345", base = 8)
print(type(b))
print(b)

<class 'int'>
1234567
<class 'int'>
5349

# 新建一个函数，此函数默认输入的字符串是16进制
# 把此字符串返回十进制数字
def int16(x, base=16):
    return int(x, base)

x = input("输入：")
a = int16(x)
print(a)

输入：12345
74565

# 实现上面int16功能
import functools

int8 = functools.partial(int, base=8)

a = int8("123456")
print(a)

42798