day17

# review
"""
    复习
        迭代 iter
            可迭代对象iterable:包含__iter__()方法
                作用：能够被for

            迭代器对象iterator:包含__next__()方法
                作用：以【一种】方式获取容器【多种数据结构】的下一个元素
        生成器
            可迭代对象 + 迭代器对象
            生成器函数
                def 函数名称():
                    ...
                    yield 数据
                    ...

                for item in 函数名称():
                    itme 存储的是yield后面的数据

            生成器表达式
                结果 = (对item处理 for item in 可迭代对象 if 条件)
                for item in 结果:
                    ...
"""
str01 = "大家好，才是真的好."
list01 = [23,34,4,5]
# for item in str01:
#     print(item)

# 书写for循环的快捷键： iter + 回车  +tab






# demo01
"""
    函数式编程 -- 函数作为参数
        面向对象编程：考虑问题从对象角度出发
        面向过程编程：考虑问题从实现(步骤)角度出发
        面向函数编程：考虑问题从函数角度出发（不是架构设计思想）
                    用在某个类或者某个函数中(局部).
"""


def fun01():
    print("fun01执行喽")


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

# 2. 将函数作为参数传递
def fun02(func):
    print("fun02执行喽")
    func()
    # fun01()

fun02(fun01)


# demo02
"""

"""

list01 = [4, 54, "65", 75, 8, "9", "b"]


# 需求1:找出所有偶数
def find01():
    for item in list01:
        if type(item) == int and item % 2 == 0:
            yield item


# 需求2:找出所有字符串
def find02():
    for item in list01:
        if type(item) == str:
            yield item


# 需求3:找出所有大于10的整数
def find03():
    for item in list01:
        if type(item) == int and item > 10:
            yield item


# "封装" : 拆分变化点
# "变化的"
def condition01(item):
    return type(item) == int and item % 2 == 0


def condition02(item):
    return type(item) == str


def condition03(item):
    return type(item) == int and item > 10

"""
# "继承"：抽象变化点 --> 统一变化 --> 隔离变化
# "不变的"  ----->  万能查找
def find(func_condition):
    for item in list01:
        # if condition01(item):
        if func_condition(item):
            yield item


# “多态”:调用父，执行子。
# 不变的 + 变化的
for item in find(condition03):
    print(item)
"""

from common.iterable_tools import IterableHelper

for item in IterableHelper.find_all(list01,condition01):
    print(item)




# demo03
"""
    lambda：匿名函数

    lambda 参数:方法体

    注意：
     方法体只能有一句话
     方法体不支持赋值语句

     15:25 上课
"""


# 普通方法
def fun01():
    print("fun01执行喽")


fun01()

# 无参数，无返回值
a = lambda: print("匿名方法执行喽")
a()


# 有参数，无返回值
def fun02(a, b, c):
    print("fun02执行喽", a, b, c)


fun02(1, 2, 3)

b = lambda a, b, c: print("匿名方法执行喽", a, b, c)
b(1, 2, 3)


# 有参数，有返回值
def fun03(a, b):
    return a > b


print(fun03(1, 2))

# lambda 方法体只能有一句话
c = lambda a, b: a > b
print(c(1, 2))


def fun04(obj):
    obj[0] = 100


list01 = [1]
fun04(list01)
print(list01)

# lambda 方法体不支持赋值语句
# d = lambda obj:obj[0] = 100

# common 文件夹
#  iterable_tools.py

"""
    可迭代对象常用工具
"""


class IterableHelper:
    """
        可迭代对象助手
    """

    # 静态方法：函数(不需要操作实例/类数据) --> 方法
    @staticmethod  # 为了不隐式(自动)传参(self/cls)
    def find_all(iterable_target, func_condition):
        """
            在可迭代对象中，根据指定条件搜索全部元素.
        :param iterable_target:需要搜索的可迭代对象
        :param func_condition:需要判断的条件
        :return:生成器对象,存储满足条件的结果.
        """
        for item in iterable_target:
            if func_condition(item):
                yield item

    @staticmethod
    def find_single(iterable_target, func_condition):
        """
            在可迭代对象中，根据指定条件搜索单个元素.
        :param iterable_target:需要搜索的可迭代对象
        :param func_condition:需要判断的条件
        :return:满足条件的结果.
        """
        for item in iterable_target:
            if func_condition(item):
                return item

    @staticmethod
    def get_count(iterable_target, func_condition):
        """
            在可迭代对象中，查找满足条件的数量.
        :param iterable_target:需要搜索的可迭代对象
        :param func_condition:需要判断的条件
        :return:int类型,满足条件的数量.
        """
        count = 0
        for item in iterable_target:
            if func_condition(item):
                count += 1
        return count

    @staticmethod
    def sum(iterable_target, func_handle):
        """
            在可迭代对象中，根据指定逻辑累加其中的元素.
        :param iterable_target:需要累加的数据(可迭代对象)
        :param func_condition:需要累加的逻辑(方法/函数)
        :return:累加结果
        """
        sum_value = 0
        for item in iterable_target:
            sum_value += func_handle(item)
        return sum_value

    @staticmethod
    def is_exists(iterable_target, func_condition):
        """
            在可迭代对象中，根据指定条件判断是否存在元素.
        :param iterable_target:需要搜索的数据(可迭代对象)
        :param func_condition:需要判断的条件(方法/函数)
        :return:是否存在(bool类型)。
        """
        for item in iterable_target:
            # if item.atk > 50:
            if func_condition(item):
                return True
        return False

    @staticmethod
    def get_max(iterable_target, func_handle):
        """
            在可迭代对象中，根据指定条件查找最大元素
        :param iterable_target:需要搜索的数据(可迭代对象)
        :param func_condition:需要判断的条件(方法/函数)
        :return:最大的元素
        """
        max = iterable_target[0]
        for i in range(1, len(iterable_target)):
            # if max.atk < iterable_target[i].atk:
            if func_handle(max) < func_handle(iterable_target[i]):
                max = iterable_target[i]
        return max

    @staticmethod
    def select(iterable_target, func_handle):
        """
              在可迭代对象中，根据指定逻辑映射元素
          :param iterable_target:需要搜索的数据(可迭代对象)
          :param func_condition:需要处理的逻辑(方法/函数)
          :return:
          """
        # result = []
        # for item in iterable_target:
        #     # result.append( (item.name,item.atk))
        #     result.append(func_handle(item))
        # return result

        for item in iterable_target:
            yield func_handle(item)

    @staticmethod
    def order_by(iterable_target, func_condition):
        for r in range(len(iterable_target) - 1):
            for c in range(r + 1, len(iterable_target)):
                # if iterable_target[r].atk > iterable_target[c].atk:
                if func_condition(iterable_target[r]) > func_condition(iterable_target[c]):
                    iterable_target[r], iterable_target[c] = iterable_target[c], iterable_target[r]

    # 在可迭代对象中，根据指定条件查找最小元素get_min
    @staticmethod
    def get_min(iterable_target, func_condition):
        min_value = iterable_target[0]
        for i in range(1, len(iterable_target)):
            # if min_value.atk > iterable_target[i].atk:
            if func_condition(min_value) > func_condition(iterable_target[i]):
                min_value = iterable_target[i]
        return min_value

    # 根据指定条件对可迭代对象进行降序排列order_by_descending
    @staticmethod
    def order_by_descending(iterable_target, func_condition):
        for r in range(len(iterable_target) - 1):
            for c in range(r + 1, len(iterable_target)):
                if func_condition(iterable_target[r]) < func_condition(iterable_target[c]):
                    iterable_target[r], iterable_target[c] = iterable_target[c], iterable_target[r]

    # 在可迭代对象中，根据指定条件删除元素delete_all
    @staticmethod
    def delete_all(iterable_target,func_condition):
        # [w01,w02,w03]
        for i in range(len(iterable_target)-1,-1,-1):
            # if iterable_target[i].weight < 40:
            if func_condition(iterable_target[i]):
                del iterable_target[i]






# exercise01
"""
    练习1:
        1. 创建技能类(编号、名称、攻击力、持续时间、攻击间隔)
        2. 创建技能列表(不少于4种技能)
        3. 根据函数式编程思想完成以下功能：
            -- 功能1：定义查找编号是102的技能对象
            -- 功能2：定义查找名称是"辟邪剑法"的技能对象
                    (如果重名，只查找第一个)
            -- 功能3：定义查找持续时间大于10秒的单个技能对象
                    (如果有多个，只查找第一个)
        步骤：
            (1)先定义3个函数实现3个功能.
            (2)“封装”:拆分变化点、提取稳定的代码.
            (3)"继承":在稳定的代码中抽象变化(提取成参数)
            (4)"多态":将稳定的代码与变化的代码相结合.

    练习2：将find_single函数，移置IterableHelper类中
    练习3：
         根据函数式编程思想完成以下功能：
            -- 功能1：定义函数，查找编号大于101的技能数量
            -- 功能2：定义函数，查找攻击力在30-80之间的技能数量
        步骤：
            (1)先定义2个函数实现2个功能.
            (2)“封装”:拆分变化点、提取稳定的代码.
            (3)"继承":在稳定的代码中抽象变化(提取成参数)
            (4)"多态":将稳定的代码与变化的代码相结合.
            (5)将稳定的代码，移置IterableHelper类中命名为get_count
    练习4：
         根据函数式编程思想完成以下功能：
            -- 功能1：定义函数，计算所有技能的攻击力总合
            -- 功能2：定义函数，计算所有技能的持续时间总合
        步骤：
            (1)先定义2个函数实现2个功能.
            (2)“封装”:拆分变化点、提取稳定的代码.
            (3)"继承":在稳定的代码中抽象变化(提取成参数)
            (4)"多态":将稳定的代码与变化的代码相结合.
            (5)将稳定的代码，移置IterableHelper类中命名为sum
            (6)使用lambda调用IterableHelper类中的sum
    练习5：
         根据函数式编程思想完成以下功能：
            -- 功能1：定义函数，判断技能列表中是否存在功能力大于50的技能
            -- 功能2：定义函数，判断技能列表中是否存在持续时间为0的技能
        步骤：
            (5)将稳定的代码，移置IterableHelper类中命名为is_exists
            (6)使用lambda调用IterableHelper类中的is_exists
    练习6：
         根据函数式编程思想完成以下功能：
            -- 功能1：定义函数，获取技能列表中攻击力最强的技能
            -- 功能2：定义函数，获取技能列表中攻间隔最长的技能
        步骤：
            (5)将稳定的代码，移置IterableHelper类中命名为get_max
            (6)使用lambda调用IterableHelper类中的get_max
    练习7：
         根据函数式编程思想完成以下功能：
            -- 功能1：定义函数，获取技能列表中技能名称与攻击力
            -- 功能2：定义函数，获取技能列表中攻击力与攻击间隔与持续时间
        步骤：
            (5)将稳定的代码，移置IterableHelper类中命名为select
            (6)使用lambda调用IterableHelper类中的select
        思考：
            如何获取第一个/最后一个/后三个
    练习8：
        根据函数式编程思想完成以下功能：
            -- 功能1：定义函数，根据攻击力对技能列表进行升序排列
            -- 功能2：定义函数，根据持续时间对技能列表进行升序排列
        步骤：
            (5)将稳定的代码，移置IterableHelper类中命名为order_by
            (6)使用lambda调用IterableHelper类中的order_by
"""
from common.iterable_tools import IterableHelper


class Skill:
    def __init__(self, id, name, atk, duration, atk_interval):
        self.id = id
        self.name = name
        self.atk = atk
        self.duration = duration
        self.atk_interval = atk_interval

    # 对象 -->  str
    def __str__(self):
        return "%d -- %s -- %.1f -- %.1f --%.1f" % (self.id, self.name, self.atk, self.duration, self.atk_interval)

    # 重写对象比较逻辑
    # def __eq__(self, other):
    #     如果编号相同，就认为相同
    #     return self.id == other.id


list01 = [
    Skill(101, "葵花宝典", 50, 0, 0),
    Skill(102, "降龙十八掌", 80, 12, 1),
    Skill(103, "黯然销魂掌", 90, 15, 0.5),
    Skill(104, "辟邪剑法1", 70, 0, 0),
    Skill(104, "辟邪剑法2", 70, 0, 0),
]

print(list01[3] == list01[4])  # false

# 练习1
# (1)先定义3个函数实现3个功能.
def find_single01():
    for item in list01:
        if item.id == 102:
            return item


def find_single02():
    for item in list01:
        if item.name == "辟邪剑法":
            return item


def find_single03():
    for item in list01:
        if item.duration > 10:
            return item


# (2)“封装”:拆分变化点、提取稳定的代码.
def condition01(item):
    return item.id == 102


def condition02(item):
    return item.name == "辟邪剑法"


def condition03(item):
    return item.duration > 10

"""
# (3)"继承":在稳定的代码中抽象变化(提取成参数)
def find_single(func_condition):
    for item in list01:
        # if item.duration > 10:
        # if condition03(item):
        if func_condition(item):
            return item


# (4)"多态":将稳定的代码与变化的代码相结合.
print(find_single(condition02))
print(find_single(condition01))
"""

# 练习2
print(IterableHelper.find_single(list01,condition01))

# 练习3
def get_count01():
    count = 0
    for item in list01:
        if item.id > 101:
            count +=1
    return count

def get_count02():
    count = 0
    for item in list01:
        if 30 <= item.atk <= 80:
            count +=1
    return count

def condition01(item):
    return item.id > 101

def condition02(item):
    return 30 <= item.atk <= 80

"""
def get_count(func_condition):
    count = 0
    for item in list01:
        # if condition02(item):
        if func_condition(item):
            count +=1
    return count
"""

print(IterableHelper.get_count(list01,condition01))

print(IterableHelper.get_count(list01,lambda item:item.id > 101))

# 练习4：
"""
# -- 功能1：定义函数，计算所有技能的攻击力总合
def sum01():
    sum_value = 0
    for item in list01:
        sum_value += item.atk
    return sum_value
# -- 功能2：定义函数，计算所有技能的持续时间总合
def sum02():
    sum_value = 0
    for item in list01:
        sum_value += item.duration
    return sum_value

def handle01(item):
    return item.atk

def handle02(item):
    return  item.duration

def sum(func_handle):
    sum_value = 0
    for item in list01:
        # 先用
        sum_value += func_handle(item)
    return sum_value
"""
print(IterableHelper.sum(list01,lambda element: element.atk))


# 练习5:
print(IterableHelper.is_exists(list01,lambda item:item.atk > 50))

# 练习6：
print(IterableHelper.get_max(list01,lambda item:item.atk))

# 练习7：
result = IterableHelper.select(list01,lambda item:(item.name,item.atk))
# 生成器不支持 索引/切片查找  result[0]
# for item in result[-3:]:
#     print(item)

# 解决方案：
# 迭代生成器
# 将惰性操作（节省内存） --> 立即操作（灵活获取结果）
result = tuple(result)
print(result[-1])

# 作业：
IterableHelper.delete_all(list01,lambda item:item.duration ==0)
for item in list01:
    print(item)




exercise.txt

day17作业
1. 三合一
2. 当天练习独立完成
3. 在IterableHelper类中，增加如下功能：
    在可迭代对象中，根据指定条件查找最小元素get_min
    根据指定条件对可迭代对象进行降序排列order_by_descending
    在可迭代对象中，根据指定条件删除元素delete_all
4. 阅读：
    重构
    HeadFirst 设计模式