函数式编程

语法

"""
    函数式编程 -- 语法
"""
def fun01():
    print("fun01执行喽")

# 1. 函数可以赋值给变量
a = fun01
# 通过变量调用函数
a()# 活的
fun01()# 死的

# 2. 将函数作为参数传递
# 如果传入基本数据类型(整数/小数/字符串..),称之为传入数据
# 如果传入函数,称之为传入行为/逻辑/算法
def fun02(func):
    print("fun02执行喽")
    func()

fun02(fun01)

 思想

"""
    函数式编程 -- 思想
"""

list01 = [4,5,5,6,767,8,10]

"""
# 1. 找出所有偶数
def find01():
    for item in list01:
        if item % 2 == 0:
            yield item
            
# 2. 找出所有奇数
def find02():
    for item in list01:
        if item % 2:
            yield item

# 3. 找出所有大于10
def find03():
    for item in list01:
        if item  > 10:
            yield item
"""
# "封装":提取变化
def condition01(item):
    return item % 2 == 0

def condition02(item):
    return item % 2

def condition03(item):
    return item  > 10

# "继承":隔离变化
# 根据任何条件,在任何可迭代对象中查找多个元素.
def find(target,func):
    for item in target:
        # if item > 10:
        # if condition03(item):
        if func(item):
            yield item

# "多态":执行变化
for item in find(list01,condition03):
    print(item)

 

 函数作为参数

from common.list_helper import ListHelper

class Skill:
    def __init__(self, id=0,name="", atk=0, duration=0.1):
        self.id = id
        self.name = name
        self.atk = atk
        self.duration = duration

list01 = [
    Skill(101,"葵花宝典",850,10),
    Skill(102,"辟邪剑法",800,5),
    Skill(103,"狮吼功",500,8),
    Skill(104,"降龙十八掌",700,3),
    Skill(105,"电炮飞脚",8,2)
]

def condition01(item):
    return item.atk > 10

def condition02(item):
    return  2 <= item.duration <= 10

def condition03(item):
    return len(item.name) > 3

for item in ListHelper.find_all(list01, condition02):
    print(item.name)

"""
     工具类:定义针对可迭代对象的常用操作
"""

class ListHelper:
    """
        列表助手类
    """
    @staticmethod
    def find_all(iterable, func_condition):
        """
            根据指定条件,在可迭代对象中查找多个元素.
        :param target:
        :param func_condition: 函数类型的查找条件
              func_condition(可迭代对象中的元素) --> bool
        :return:所有满足的条件
        """
        for item in iterable:
            if func_condition(item):
                yield item

 

 匿名函数（lambda）

# 定义有参数lambda
func = lambda item:item % 2 == 0
re = func(5)
print(re)

# 定义无参数lambda
func = lambda :100
re = func()
print(re)

# 定义多个参数lambda
func =lambda a,b,c:a+b+c
re = func(1,2,3)
print(re)

# 定义无返回值lambda
func = lambda a:print("变量是:",a)
func(10)

# lambda 不支持赋值语句
# func = lambda obj:obj.a = 100

# lambda 只支持一条语句
# lambda a,b:if a % 2 == 0: print(a+b)

list01 = [4,5,5,6,767,8,10]

# def condition01(item):
#     return item % 2 == 0
#
# def condition02(item):
#     return item % 2
#
# def condition03(item):
#     return item  > 10

def find(target,func):
    for item in target:
        if func(item):
            yield item

# for item in find(list01,condition03):
#     print(item)

for item in find(list01,lambda item:item  > 10):
    print(item)

 

 ---------------------------------------------------------------------------------------

 

"""
    练习1:
    需求:
    定义函数, 在技能列表中, 计算技能名称大于3个字的技能数量
    定义函数, 在技能列表中, 计算攻击力大于500的技能数量
    定义函数, 在技能列表中, 查找持续时间在5--10之间的技能数量
    目标: 在ListHelper中定义计算满足指定条件的元素数量
    要求:使用lambda调用ListHelper
"""

print(ListHelper.get_count(list01,lambda item:len(item.name) > 3))
print(ListHelper.get_count(list01,lambda item:item.atk > 500))
print(ListHelper.get_count(list01,lambda item:5 <= item.duration<=10))


"""
    练习2:
    需求:
    定义函数, 在技能列表中, 判断是否存在编号是105的技能
    定义函数, 在技能列表中, 判断是否存在"九阳神功"技能
    定义函数, 在技能列表中, 判断是否攻击力大于10的技能
    目标: 在ListHelper中定义判断是否具有满足条件的元素
    要求:使用lambda调用ListHelper
"""

print(ListHelper.is_exists(list01,lambda element:element.id == 105))
print(ListHelper.is_exists(list01,lambda element:element.name == "九阳神功"))
print(ListHelper.is_exists(list01,lambda element:element.atk> 10))

"""
    练习3:
    需求:
    定义函数, 在技能列表中, 计算所有攻击力的和
    定义函数, 在技能列表中, 计算所有持续时间的和 
    目标: 在ListHelper中定义根据条件求和的方法
"""

print(ListHelper.sum(list01,lambda e:e.atk))
print(ListHelper.sum(list01,lambda e:e.duration))


"""
    练习4:
    需求:
    定义函数, 在技能列表中, 获取所有技能的名称与攻击力.
    定义函数, 在技能列表中, 获取所有技能的编号与名称与持续时间.
    目标: 在ListHelper中定义根据条件筛选信息的函数
"""

for item in ListHelper.select(list01,lambda info:(info.id,info.atk)):
    print(item)

for item in ListHelper.select(list01,lambda info:(info.id,info.name,info.duration)):
    print(item)

"""
    练习5:
    需求:
    定义函数, 在技能列表中, 获取攻击力最大的技能.
    定义函数, 在技能列表中, 获取持续时间最大的技能.
    目标: 在ListHelper中定义根据指定条件获取最大元素的功能
"""

max = ListHelper.get_max(list01,lambda item:item.atk)
print(max.name)
max = ListHelper.get_max(list01,lambda item:item.duration)
print(max.name)

 

"""
     工具类:定义针对可迭代对象的常用操作
     微软 LINQ  语言集成查询框架
     集成操作框架
"""

class ListHelper:
    """
        列表助手类
    """

    @staticmethod
    def get_count(iterable, func_condition):
        """
             在可迭代对象中获取满足条件的元素数量.
         :param iterable:需要检索的可迭代对象
         :param func_condition: 函数类型的查找条件
               func_condition(可迭代对象中的元素) --> bool
         :return:满足条件的数量
         """
        count = 0
        for item in iterable:
            if func_condition(item):
                count += 1
        return count

    @staticmethod
    def is_exists(iterable, func_condition):
        """
             在可迭代对象中判断是否具有满足条件的元素.
         :param iterable:需要检索的可迭代对象
         :param func_condition: 函数类型的查找条件
               func_condition(可迭代对象中的元素) --> bool
         :return:是否存在 True表示存在,False表示不存在
         """
        for item in iterable:
            if func_condition(item):
                return True
        return False

    @staticmethod
    def sum(iterable, func_condition):
        """
             在可迭代对象中根据指定条件进行求和计算
         :param iterable:需要求和的可迭代对象
         :param func_condition: 函数类型的求和条件
               func_condition(可迭代对象中的元素) --> 任意类型
         :return:求和的结果
         """
        sum_value = 0
        for item in iterable:
            sum_value += func_condition(item)
        return sum_value

    @staticmethod
    def select(iterable, func_condition):
        """
             在可迭代对象中根据指定条件对每个元素进行筛选
         :param iterable:需要筛选的可迭代对象
         :param func_condition: 函数类型的筛选条件
               func_condition(可迭代对象中的元素) --> 任意类型
         :return:生成器对象类型的筛选结果
         """
        for item in iterable:
            yield func_condition(item)

    @staticmethod
    def get_max(iterable, func_condition):
        """
             在可迭代对象中根据指定条件获取最大元素
         :param iterable:需要搜索的可迭代对象
         :param func_condition: 函数类型的搜索条件
               func_condition(可迭代对象中的元素) --> 任意类型
         :return:最大元素
         """
        max_item = iterable[0]
        for i in range(1, len(iterable)):
            # if max_item.atk <  iterable[i].atk:
            # if max_item.duration <  iterable[i].duration:
            if func_condition(max_item) < func_condition(iterable[i]):
                max_item = iterable[i]
        return max_item

    @staticmethod
    def order_by(iterable, func_condition):
        """
             根据指定条件对可迭代对象进行升序排列
         :param iterable:需要排序的可迭代对象
         :param func_condition: 函数类型的排序依据
               func_condition(可迭代对象中的元素) --> 任意类型
         """
        for r in range(len(iterable) - 1):
            for c in range(r + 1, len(iterable)):
                # if iterable[r].atk > iterable[c].atk:
                if func_condition(iterable[r]) > func_condition(iterable[c]):
                    iterable[r], iterable[c] = iterable[c], iterable[r]

    # 获取最小
    # 降序
    # 删除

 

内置高阶函数

class Wife:
    def __init__(self, name, age, weight, height):
        self.name = name
        self.age = age
        self.weight = weight
        self.height = height

list01 = [
    Wife("翠花", 36, 60, 1.5),
    Wife("如花", 39, 75, 1.3),
    Wife("赵敏", 25, 46, 1.7),
    Wife("灭绝", 42, 50, 1.8)
]

# 1. 过滤:根据条件筛选可迭代对象中的元素，返回值为新可迭代对象。
for item in filter(lambda item:item.age < 40,list01):
    print(item.name)

# 2. 映射:使用可迭代对象中的每个元素调用函数，将返回值作为新可迭代对象元素；
for item in map(lambda item:(item.name,item.age),list01):
    print(item)

# 3. 升序排列
for item in sorted(list01,key = lambda item:item.height):
    print(item.height)

# 4. 降序排列
for item in sorted(list01,key = lambda item:item.height,reverse=True):
    print(item.height)

# 5. 获取最大值
re = max(list01, key=lambda item: item.weight)
print(re.name)

# 6. 获取最小值
re = min(list01, key=lambda item: item.weight)
print(re.name)