5.python-函数式编程

函数式编程

(1) 定义：用一系列函数解决问题。
-- 函数可以赋值给变量，赋值后变量绑定函数。
-- 允许将函数作为参数传入另一个函数。
(2) 高阶函数：将函数作为参数或返回值的函数。

函数作为参数(函数式编程理论支柱)

将核心逻辑传入方法体，使该方法的适用性更广，体现了面向对象的开闭原则。

函数式编程思想

适用性：多个函数,主体结构相同,但是核心算法不同
步骤：
1. 分:将不同的算法单独定义在函数中
2. 隔:使用参数隔离通用函数与变化函数
价值：
创造通用函数

# 定义函数,在列表中查找第一个大于10的数
def func01():
    for item in list01:
        if item > 10:
            return item


# 定义函数,在列表中查找第一个小于100的数
def func02():
    for item in list01:
        if item < 100:
            return item


list01 = [3, 32, 52, 5, 22, 52, 525, 8, 5, 46, 36, 262]
print(func01())  # 32 # 直接调用函数
print(func02())  # 3


# 函数func01和func02只有判断句子不同,其余相同,可将函数更改为
def func03(condition):  # 函数主体不变,将不同的部分抽取成函数作为参数传入
    for item in list01:
        if condition(item):  # 间接调用函数
            return item


def condition01(item):
    return item > 10


def condition02(item):
    return item < 100


print(func03(condition01))  # 将条件函数condition01作为参数传入,不带有小括号,有小括号传入的是函数的返回值
print(func03(condition02))  # 将条件函数condition02作为参数传入

lambda 表达式

(1) 定义：是一种匿名方法
(2) 作用：
-- 作为参数传递时语法简洁，优雅，代码可读性强。
-- 随时创建和销毁，减少程序耦合度

# 语法 lambda 形参:方法体
# 形参没有可以不填
# 方法体只能有一条语句,且不支持赋值语句


# 1. 有参数有返回值
# def func01(p1,p2):
#     return p1 > p2
#
# print(func01(10, 20))

func01 = lambda p1, p2: p1 > p2
print(func01(10, 20))

# 2. 无参数有返回值
# def func02():
#     return 100
#
# print(func02())

func02 = lambda: 100
print(func02())

# 3. 有参数无返回值
# def func03(p1):
#     print("参数是%s" % p1)
#
# func03(10)

func03 = lambda p1: print("参数是%s" % p1)

func03(10)

# 4. 无参数无返回值
# def func04():
#     print("hello world")
#
# func04()

func04 = lambda: print("hello world")
func04()


# 5. lambda不支持赋值语句
def func05(p1):
    p1[0] = 100


list01 = [10]
func05(list01)
print(list01)  # [100]


# lambda p1:p1[0] = 100

# 6.lambda函数体内只能有一条语句
def func06():
    for number in range(5):
        print(number)


func06()


# lambda :for number in range(5):
#     print(number)


# lambda常用于函数式编程,作为参数传入,间接调用
def first(condition):
    for item in list01:
        if condition(item):
            return item


list01 = [42, 45, 16, 21, 7, 27, 7, 7, 27, 60, 2627, 8, 2, 724, 5, 266, 27, 2, 180, 7]

# 获取列表第一个大于100的数
print(first(lambda x: x > 100))  # 2627
# 获取列表第一个小于10的数
print(first(lambda x: x < 10))  # 7


def find_all(condition):
    list_number = []
    for item in list01:
        if condition(item):
            list_number.append(item)
    return list_number


# 获取列表中所有被3整除的数且为偶数
print(find_all(lambda x: x % 3 == 0 and x % 2 == 0))  # [42, 60, 180]
# 获取列表中所有奇数或被5整除的数
print(find_all(lambda x: x % 2 == 1 or x % 5 == 0))  # [45, 21, 7, 27, 7, 7, 27, 60, 2627, 5, 27, 180, 7]

内置高阶函数

class Employee:
    def __init__(self, eid, did, name, money):
        self.eid = eid  # 员工编号
        self.did = did  # 部门编号
        self.name = name  # 姓名
        self.money = money  # 工资


# 员工列表
list_employees = [
    Employee(1001, 9002, "师父", 60000),
    Employee(1002, 9001, "孙悟空", 50000),
    Employee(1003, 9002, "猪八戒", 20000),
    Employee(1004, 9001, "沙僧", 30000),
    Employee(1005, 9001, "小白龙", 15000)
]

# map（函数，可迭代对象）：
# 使用可迭代对象中的每个元素调用函数，将返回值作为新可迭代对象元素；返回值为新可迭代对象。
# 获取所有的姓名
print(list(map(lambda x: x.name, list_employees)))  # ['师父', '孙悟空', '猪八戒', '沙僧', '小白龙']
# 获取所有的工号和工资
print(list(map(lambda x: (x.eid, x.did),
               list_employees)))  # [(1001, 9002), (1002, 9001), (1003, 9002), (1004, 9001), (1005, 9001)]

# filter(函数，可迭代对象)：
# 根据条件筛选可迭代对象中的元素，返回值为新可迭代对象。
# 查找工资小于40000的
iterable01 = filter(lambda x: x.money < 40000, list_employees)
for item in iterable01:
    print(item.__dict__)
# 查找部门编号为9001且工资大于20000的
iterable02 = filter(lambda x: x.did == 9001 and x.money > 20000, list_employees)
for item in iterable02:
    print(item.__dict__)

# sorted(可迭代对象，key = 函数,reverse = bool值)：False升序 True降序
# 排序，返回值为排序结果。
# 按工资升序
iterable03 = sorted(list_employees, key=lambda x: x.money, reverse=False)
for item in iterable03:
    print(item.__dict__)
# 按工号降序
iterable04 = sorted(list_employees, key=lambda x: x.eid, reverse=True)
for item in iterable04:
    print(item.__dict__)

# sort(key = 函数,reverse = bool值)：False升序 True降序
# 排序,对列表排序
list_employees.sort(key=lambda x: x.money, reverse=True)


# max(可迭代对象，key = 函数)：根据函数获取可迭代对象的最大值。
# min(可迭代对象，key = 函数)：根据函数获取可迭代对象的最小值。
# 工资最大值
employees01 = max(list_employees, key=lambda x: x.money)
print(employees01.__dict__)  # {'eid': 1001, 'did': 9002, 'name': '师父', 'money': 60000}
# 部门最小值
employees02 = min(list_employees, key=lambda x: x.did)
print(employees02.__dict__)  # {'eid': 1002, 'did': 9001, 'name': '孙悟空', 'money': 50000}