"""
    针对列表的自定义工具
"""


class ListHelper:

    @staticmethod
    def find_all(target, func_condition):
        """
            查找列表中满足条件的所有元素
        :param target: 列表
        :param func_condition: 条件
            函数／方法类型
            －－　参数：列表中的元素
            －－　返回值：是否满足条件bool值
        :return:
        """
        for item in target:
            if func_condition(item):
                yield item

    @staticmethod
    def first(target, func_condition):
        """
            查找列表中满足条件的第一个元素
        :param target:
        :param func_condition:
        :return:
        """
        for item in target:
            if func_condition(item):
                return item

    @staticmethod
    def last(target, func_condition):
        """
        查找列表中瞒住条件的最后一个元素
        :param target:
        :param func_condition:
        :return:
        """
        for item in target[::-1]:
            if func_condition(item):
                return item

    @staticmethod
    def select(target, func_condition):
        """
            筛选列表中指定条件的数据
        :param target:
        :param func_condition:
        :return:
        """
        for item in target:
            # yield xxx(item)
            yield func_condition(item)

    @staticmethod
    def sum(target, func_condition):
        """
            计算列表中指定条件的所有元素和
        :param target:
        :param func_condition:
        :return:
        """
        sum_value = 0
        for item in target:
            # sum_value += xxx(item)
            sum_value += func_condition(item)
        return sum_value

    @staticmethod
    def total_condition(target, func_codition):
        """
        获取瞒住条件的对象的总数
        :param target:
        :param func_codition:
        :return:
        """
        total = 0
        for item in target:
            if func_codition(item):
                total += 1
        return total

    @staticmethod
    def judge_exits(target, func_condition):
        """
        判断列表中是否包含某一个元素
        :param target:
        :param func_condition:
        :return:
        """
        for item in target:
            if func_condition(item):
                return True
        return False

    @staticmethod
    def del_condition(target, func_condition):
        """
        删除列表中的某个元素
        :param target:
        :param func_condition:
        :return: int类型，被删除的元素个数
        """
        del_count = 0
        for item in target[::-1]:
            if func_condition(item):
                target.remove(item)
                del_count += 1
        return del_count

    @staticmethod
    def get_max(target, func_condition):
        """
        获取列表中最大值
        :param target:
        :param func_condition:
        :return:
        """
        max_value = target[0]
        for i in range(1, len(target)):
            # if max_valud.hp > target[i].hp
            if func_condition(max_value) < func_condition(target[i]):
                max_value = target[i]
        return max_value

    @staticmethod
    def get_min(target, func_condition):
        min_value = target[0]
        for i in range(1, len(target)):
            if func_condition(min_value) > func_condition(target[i]):
                min_value = target[i]
        return min_value

    @staticmethod
    def ascending_order(target, func_condition):
        """
        根据指定条件做升序排序列表
        :param target:
        :param func_condition:
        :return:
        """
        for i in range(len(target) - 1):
            for n in range(len(target) - i - 1):
                # if target[n].hp > target[n+1].hp:
                if func_condition(target[n]) > func_condition(target[n + 1]):
                    target[n], target[n + 1] = target[n + 1], target[n]

    @staticmethod
    def sort(target, func_condition):
        """
        万能排序
        :param target: 需要排序的数据
        :param func_condition: 排序的逻辑，类型为函数，参数是列表中两个元素，返回值是比较的结果，方法提示比较的结果
        :return:
        """
        for i in range(len(target) - 1):
            for n in range(len(target) - i - 1):
                if func_condition(target[n], target[n + 1]):
                    target[n], target[n + 1] = target[n + 1], target[n]


li = [1, 5, 6, 8, 2, 1, 2, 6, 5, 2]

ListHelper.sort(li, lambda e1, e2: e1 < e2)

print(li)