day19

# review

# code01  
"""
    第一门课：python基础
    数据基本运算
        1. pycharm快捷键（标志着对开发工具的熟练程度,提高开发效率）
            -- 百度搜索

        2. 对象池：每次创建对象时，都会在池中查找是否具有相同对象，
                  如果有则直接返回其地址，如果没有再创建.
                  提高内存的利用率(减少重复出现的对象)
           小整数对象池:-5 ~ 256 之间的数字永远存在内存中.

        3. python内存管理机制(自动化)：
            引用计数:
                a = 对象()
                b = a
                del b,a  # 对象被销毁

                list01 = []
                list02 = []
                list01.append(list02)
                list02.append(list01)
                缺点：不能解决循环引用问题,容易造成内存浪费.
            标记清除：扫描内存，查看是否存在无法访问的内存空间。
                缺点：扫描内存耗时长.
            分代回收：将内存划分为多个区域("年轻代"、"中年代"、"老年代")
                    当上一代满了，进行标记清除，将有用的数据移动到下一代(升代)。
            内存优化：
                尽量少产生垃圾、对象池、手动回收(慎重)、
                （字符串拼接)
        4.容器
            每种容器特点：存储？ 可变？ 不可变？
            内存图
            各种容器互相转换
            注意：往往是根据数据，灵活的选择各种容器嵌套.
        5.函数
            设计：小而精，不要大而全.
            参数：
                实参
                    位置：函数名(1,2,3)
                        序列实参：函数名(*列表)
                    关键字：函数名(a = 1,c = 3, b=2)
                        字典实参：函数名(**字典)
                形参
                    默认形参：def 函数名(a =0,b=0.0,c="")  --可以不传递
                    位置：def 函数名(a,b,c)   -- 必须传递
                        星号元组形参：def 函数名(*args)-- 位置实参数量无限
                    命名关键字形参： def 函数名(*args,a) -- a 必须使用关键字实参
                                  def 函数名(a,*,b) -- b 必须使用关键字实参
                        双星号字典形参：def 函数名(**kwargs)-- 关键字实参数量无限
"""

a = 500
b = 500
print(a is b)  # true

a = "悟空"
b = "悟空"
print(a is b)  # true

a = (1, 2)
b = (1, 2)
print(a is b)  # false

def fun01(*args,a):
    pass

fun01(12,3,123,4,4,53,456,a = 1)


# code02

"""
    第二门课：面向对象
        （略）....

        理解架构设计思想：三大特征、六大原则
"""
# code03
"""
    11:30
    第三门课：python核心
        程序结构：
            为什么要有模块和包？ --- 代码结构清晰
            各种导入方式
            main.py的价值 --- 主模块不会生成pyc文件
        异常处理：
            异常现象：不再向下执行，而是不断返回给调用者，直到程序最外层或者try.
            处理目的：异常现象 --> 正常现象.
            处理手段：
                try:
                    可能出错的代码
                except 错误类型1 as 变量名：
                    处理逻辑,通过变量名可以访问错误对象
                except 错误类型2 as 变量名：
                    处理逻辑,通过变量名可以访问错误对象
                else:
                    不出错的逻辑

                try:
                    可能出错的代码
                finally:
                    一定执行的逻辑
                注意：没有处理异常
        迭代 iter
            可迭代对象 iterable：__iter__() -- 可以被for
            迭代器 iterator:__next__() -- 可以返回数据
            架构图

        生成器
            本质：迭代器 + 可迭代对象()
            生成器函数：
                def 函数名():
                    ...
                    yield 数据
                    ...

                通常使用for获取数据
                也可以通过__next__获取数据，通过send发送数据
                通过tuple(生成器),将惰性操作变为立即操作
            价值：循环一次，计算一次，返回一次,
                  节省内存

        函数式编程
            函数作为参数
                参数：数值、列表、自定义对象 --> 传递数据
                参数：函数--> 传递逻辑/算法/行为
                IterableHelper类 --> "万能"

            函数作为返回值
                闭包 --> 装饰器（拦截）

"""
# 快捷键：iter + 回车 + Tab
for char in "abcd":
    print(char)


def fun01():
    for i in range(10):
        value = yield i
        print(value)  # "偶数"  None

generate = fun01()
for item in generate:  # generate.__next__()
    print(item)
    if item % 2 == 0:
        # 在迭代过程中给生成器发送信息
        generate.send("偶数")


exercise.txt
# 3. 每个灯泡都有"亮","灭"两种模式，
#     请打印出30个灯泡所有可能的模式
import itertools

# for item in itertools.product(["亮", "灭"], repeat=30):
#     print(item)

# 4. 年会节目有：
#     "舞蹈1","舞蹈2","舞蹈3","相声1","相声2","歌曲1","歌曲2","歌曲3","歌曲4"
#    请打印出节目所有排列的方案
#    要求：相同节目不能挨着.

list01 = ["舞蹈1", "舞蹈2", "舞蹈3", "相声1", "相声2", "歌曲1", "歌曲2", "歌曲3", "歌曲4"]
for item in itertools.permutations(list01, len(list01)):
    # ('歌曲4', '歌曲3', '歌曲2', '歌曲1', '舞蹈3', '舞蹈1', '相声2', '相声1', '舞蹈2')
    for i in range(len(item) - 1):
        if item[i][:2] == item[i + 1][:2]:
            break
    else:
        print(item)