day18

# review
"""
    复习
    函数式编程：以函数为中心
    功能1():
        相同
        不同1
    功能2():
        相同
        不同2
    功能3():
        相同
        不同3

    变化点1():
         不同1

    变化点2():
         不同2

    变化点3():
         不同3

    通用(参数):
        相同
        # 不同3()
        参数()

    通用(变化点1)

    通用(lambda 参数:方法体)


"""

# demo01

"""
    python内置高阶函数
"""
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),
]

# 需求：找出编号大于102的所有技能
for item in IterableHelper.find_all(list01,lambda item:item.id > 102):
    print(item)

# 1.过滤器
for item in filter(lambda item:item.id > 102,list01):
    print(item)

# 需求：找出技能列表中所有技能编号和技能名称
for item in IterableHelper.select(list01,lambda item:(item.id,item.name)):
    print(item)

#2. 映射
for item in map(lambda item:(item.id,item.name),list01):
    print(item)

# 需求：找出技能列表中获取攻击力最大的技能
print(IterableHelper.get_max(list01,lambda item:item.atk))

# 3. 取最大值max  取最小 min
print(max(list01,key = lambda item:item.atk))


# 需求：对技能列表根据持续时间进行升序排列
# IterableHelper.order_by(list01,lambda item:item.duration)
# for item in list01:
#     print(item)

# IterableHelper.order_by_descending(list01,lambda item:item.duration)
# for item in list01:
#     print(item)

# 4. 排序
#      -- 返回排序后的结果，不改变原有数据。
#      -- 默认升序排列
#      -- 通过reverse=True 进行降序排列
# for item in sorted(list01,key =lambda item:item.duration):
#     print(item)
for item in sorted(list01,key =lambda item:item.duration,reverse=True):
    print(item)


# demo02

"""
  笛卡尔积 全排列
  练习:exercise02
"""
import itertools

# 排列出所有扑克牌 13 * 4  --> 列表(52)
# 扑克牌的数字
list_number = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
# 扑克牌的花色
list_suit = ["红桃", "黑桃", "方片", "梅花"]

# list_poker = []
# for number in list_number:
#     for suit in list_suit:
#         list_poker.append((number, suit))
#
# print(len(list_poker), list_poker)

# for item in itertools.product(list_number,list_suit):
#     print(item)

result = tuple(itertools.product(list_number, list_suit))
print(len(result), result)

# 排列出3个色子可以组成的所有数字6 * 6 × 6   --》 6**n
# 色子（1 -- 6）  6
# list_result = []
# for x in range(1, 7):
#     for y in range(1, 7):
#         for z in range(1, 7):
#             list_result.append((x, y, z))
# print(len(list_result), list_result)

result = tuple(itertools.product(range(1, 7), repeat=3))
print(len(result), result)

# for item in itertools.product(range(1, 7),repeat=10):
#     print(item)




# demo03

"""
    排列
        从n个元素中取出m个元素,并按照顺序进行排列.
        公式：n!  /  (n-m)!
"""
import itertools

# 7 个人 中取3个
# 7 * 6 * 5 * 4 * 3 * 2 * 1
# 4 * 3 * 2 * 1
tuple_person = ("男1号","男2号","男3号","女1号","女2号","女3号","女4号")
print(7 * 6 * 5)
result = tuple(itertools.permutations(tuple_person,3))
print(len(result),result)


# demo04

"""
    组合
        从n个元素中取出m个元素
        不考虑顺序的排列
    练习：exercise04.py
"""

import itertools

# 7 个人 中取3个
tuple_person = ("男1号", "男2号", "男3号", "女1号", "女2号", "女3号", "女4号")
result = list(itertools.combinations(tuple_person, 3))
print(len(result), result)


# demo05

"""
    外部嵌套作用域
"""


def fun01():
    a = 10
    def fun02():
        b = 20
        # print(a)  # 访问外部嵌套作用域中的变量
        # a = 30# 创建了局部变量a
        nonlocal a  # 声明外部嵌套作用域变量
        a = 30  # 再进行修改

    fun02()
    print(a)

fun01()

# demo06

"""
    闭包
        内外函数的执行环境，称之为闭包
        特点：外部函数执行过后，没有立即释放栈帧(等着内部函数使用).
"""


def fun01():
    a = 10
    print("fun01执行喽")
    # 要素1：有内嵌函数
    def fun02():
        # 要素2：访问外部变量
        print("fun02执行喽", a)
    # 要素3:返回内部函数
    return fun02

result = fun01()
result()# 执行fun02

# demo07

"""
    装饰器
    练习：exercise06
"""

def print_func_name(func):
    def wrapper(*args, **kwargs):
        print(func.__name__)
        return func(*args, **kwargs)

    return wrapper

# 增加新功能：打印函数名称
# def print_func_name(func):
#     print(func.__name__)

# print_func_name(print)

@print_func_name
def say_hello():
    print("hello")


@print_func_name
def say_goodbye():
    print("goodbye")


say_hello()
say_goodbye()

# demo08
"""
    装饰器 -- 推导过程
    在不改变旧功能(进入后台，删除订单)基础上，为其增加新功能(验证权限)
    练习:exercise07
"""

def verif_permissions(func):
    # 2. * args 为了解决位置实参个数无限问题
    def wrapper(*args,**kwargs):# * 将实参合为一个元组
        # 新功能
        print("验证权限")
        # 旧功能
        # 3. 内部函数的返回值就是旧功能的返回值
        return func(*args,**kwargs)# * 将实参拆分，与形参对应

    return wrapper

# 旧功能
@verif_permissions# enter_background = verif_permissions(enter_background)
def enter_background(login_id,pwd):
    print(login_id,"进入后台")

@verif_permissions
def delete_order():
    print("删除订单")
    return True

# # 拦截  =  新 + 旧
# enter_background = verif_permissions(enter_background)
#
# delete_order = verif_permissions(delete_order)

# 1.调用的是内部函数
enter_background("abc",pwd = "123")
print(delete_order())





# exercise01
"""
    练习:
        使用内置高阶函数实现：
        1. ([1,1],[2,2,2],[3,3,3])
           获取元组中长度最大的列表
        2. 在老婆列表列表，获取所有名称与身高
        3. 在老婆列表中，获取所有体重大于50的老婆
        4. 对老婆列表，根据身高进行降序排列
        5. 获取所有身高大于1.6的老婆名称和身高.
"""


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

    def __str__(self):
        return self.name

    def __repr__(self):
        return "Wife(" + self.name + ")"


list01 = [
    Wife("翠花", 60, 1.5),
    Wife("赵敏", 45, 1.7),
    Wife("铁扇公主", 55, 1.65),
    Wife("如花", 40, 1.6),
]

# 1.
tuple01 = ([1, 1], [2, 2, 2], [3, 3, 3])
print(max(tuple01, key=lambda item: len(item)))
# 2.
# 惰性操作 -->  立即操作
result = tuple(map(lambda item: (item.name, item.height), list01))
print(result[-2:])
# 3.
result = tuple(filter(lambda item: item.weight > 50, list01))
print(result)
# 4.
result = sorted(list01, key=lambda item: item.height, reverse=True)
print(len(result), result)
# 5.
for item in map(lambda item: (item.name, item.height), filter(lambda item: item.height > 1.6, list01)):
    print(item)

# 获取满足条件的所有人
# result = filter(lambda item:item.height > 1.6,list01)
# # 获取人的某些信息
# for item in map(lambda item:(item.name,item.height),result):
#     print(item)

# exercise02
# 练习1:在3男，4女中，选出2个人的所有可能性.
# ("男1号","男2号","男3号")
# ("女1号","女2号","女3号","女4号")
import itertools

tuple_man = ("男1号", "男2号", "男3号")
tuple_woman = ("女1号", "女2号", "女3号", "女4号")
result = tuple(itertools.product(tuple_man,tuple_woman))
print(len(result),result)

# exercise03

import itertools

# 练习1： 计算在4张牌中排列4中的可能性
from common.iterable_tools import IterableHelper

tuple_poker = ("红桃3", "黑桃2", "梅花5", "大王")

list_result = list(itertools.permutations(tuple_poker, 4))
print(len(list_result), list_result)

# 练习2:"012345",可以组成多少个不重复的5位偶数
# list_result = list()
# print(len(list_result), list_result)
for item in filter(lambda item: item[0] != "0" and int(item[-1]) % 2 == 0, itertools.permutations("012345", 5)):
    # ('1', '0', '2', '3', '4') -->"10234" --> 10234
    print(int("".join(item)))

# exercise04

import itertools

# 练习1： 计算在4张牌中组合2张中的可能性
tuple_poker = ("红桃3", "黑桃2", "梅花5", "大王")
# for item in itertools.combinations(tuple_poker,2):
#     print(item)

# 练习2：
# 药品调剂
# 分为3种药品，共取出100例粒，要求：没种必须都要有.
# 计算所有调剂方式
# 提示：思考共取出5粒如何实现
contents = 100
for item in itertools.combinations(range(1, contents), 2):
    # item 是 (1, 2) 板子的位置
    #     (2,4)
    for i in range(item[0]):
        print("A药品", end=" ")

    for i in range(item[1] - item[0]):
        print("B药品", end=" ")

    for i in range(contents - item[1]):
        print("C药品", end=" ")

    print()

# exercise05

"""
    闭包应用
         逻辑连续
         装饰器
"""


# 压岁钱
def give_gife_money(money):
    def child_buy(target, price):
        nonlocal money
        if money >= price:
            money -= price
            print("孩子买了%s,花了%.1f钱" % (target, price))

        else:
            print("钱不够了，呜呜呜～")

    return child_buy



action = give_gife_money(10000)
action("变形金刚", 200)
action("天安门模型", 500)
action("手机", 12000)


# exercise06

"""
    在不改变旧功能(进入后台，删除订单)基础上，为其增加新功能(验证权限)
"""
def verif_permissions(func):
    def wrapper(*args, **kwargs):
        print("验证权限")
        return func(*args, **kwargs)
    return wrapper

@verif_permissions
def enter_background():
    print("进入后台")

@verif_permissions
def delete_order():
    print("删除订单")

enter_background()
delete_order()
# exercise07

"""
    在不改变旧功能(fun01，fun02)基础上，为其增加新功能(打印方法执行时间)
    公式：执行时间 = 开始后 - 开始前
"""
import time


def print_execute_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        # 旧功能
        result = func(*args, **kwargs)
        stop_time = time.time()
        # 新功能
        print(stop_time - start_time)
        return result

    return wrapper

@print_execute_time
def fun01():
    for i in range(10):
        pass

@print_execute_time# fun02 = print_execute_time(fun02)
def fun02():
    for i in range(1000000):
        pass


fun01()
fun02()



exercise.txt

# review
作业
1. 三合一
2. 当天练习独立完成
3. 每个灯泡都有"亮","灭"两种模式，
    请打印出30个灯泡所有可能的模式
4. 年会节目有：
    "舞蹈1","舞蹈2","舞蹈3","相声1","相声2","歌曲1","歌曲2","歌曲3","歌曲4"
   请打印出节目所有排列的方案
   要求：相同节目不能挨着.

5. 阅读：
    程序员的数学
    重构
    HeadFirst 设计模式