【Python 高级】Python全栈体系（十）

Python 高级

第六章 总复习

一、Python 核心总复习

• 循环引用
  
• 标记清除
  
• 分代回收
  

"""
    Python核心总复习
        1. Python 执行过程
            源代码  -“编译”->  字节码(.pyc)  -解释->  机器码
            |      第一次        |
            main.py  -- 入口代码应当简洁
        2. 自动化内存管理机制
            引用计数： 每个对象记录被变量绑定(引用)的数量,当为0时被销毁。
                缺点：对循环引用无效
            标记清除：当内存不足时,对整块内存空间进行扫描,清空垃圾数据(整理有用的数据).
                缺点：全盘扫描内存,计算量大。
            分代回收：将内存划分为多个区域(代),当内存不足时，进行升代操作.
                    将有用的数据,转移到下一代,垃圾数据清空.
                    由于分代,所以避免了全盘扫描.
            内存优化：尽少产生垃圾、对象池(减少重复对象的存在,减少对象创建与销毁的过程)
                    可以设置分代回收参数
        3. 容器
            字符串str:存储字符编码,不可变序列
            列表list:存储变量,可变序列
            元组tuple:存储变量,不可变序列
            字典dict:存储键值对,可变散列
            集合set:存储键,可变散列
            序列与散列：
                序列:连续的内存空间，有顺序(索引.切片)
                散列:不连续的内存空间，顺序(通过key)
            可变与不可变：
                可变：预留空间
                不可变：按需分配
    4. 可变与不可变对象的传参：
            不可变数据,在函数内的修改,不影响函数外
            可变数据,在函数内的修改,可以影响函数外
        结论：传入可变对象,修改可变对象,可以不通过返回值传递结果
    5. 函数参数
        实参：如何给形参传递数据
            位置实参：根据顺序对应
                序列实参： 函数名(*序列)       【拆】
            关键字实参：根据名称对应 函数名(形参名 = 数据)
                字典实参： 函数名(**字典)      【拆】
        形参：规定传参方式
            默认参数：实参可以不传递
                def 函数名(形参名 = 默认值)
            位置形参：实参必须传递
                星号元组形参：实参数量无限  def 函数名(*args)   【合】
            命名关键字形参：实参必须是关键字实参
                def 函数名(*args,a,b)
                def 函数名(*,a,b)
                双星号字典形参：关键字实参数量无限  def 函数名(*kwargs)【合】
"""
a = "悟空"  # 引用计数增加1
b = a      # 引用计数增加1
c = b      # 引用计数增加1
del a      # 引用计数减少1
b = "八戒" # 引用计数减少1
c = None  # 引用计数减少1
# 悟空因为引用计数为零,所以被销毁.

list01 = []
list02 = []
list01.append(list02)
list02.append(list01)

# 对不可变对象的频繁修改，要改为对可变对象的修改。
list_result = []
for i in range(100):
    list_result.append(str(i))

data01 = 100.7890
data02 = 100.7890
print(id(data01),id(data02))


def func01(p1,p2):
    # 不可变数据,在函数内的修改,不影响函数外
    p1 = 2
    # 可变数据,在函数内的修改,可以影响函数外
    p2[0] = 2

a = 1
list01 = [1]
func01(a,list01)
print(a)
print(list01)

二、面向对象总复习

"""
    面向对象总复习
    1. 面向过程与面向对象：
        考虑问题从步骤(实现细节)角度出发
        考虑问题从对象(谁)角度出发
    2. 类和对象
        实例成员:变量、方法.  每个对象不同的数据与行为.
        类成员:变量、方法.  大家(共享)的数据与行为.
        静态方法：函数.   工具
    3. 三大特征：
        封装：分而治之（变化点单独定义）
        继承：抽象 -->统一 --> 隔离(变化点)
        多态：执行变化,定义变化（重写）
        核心理念：先用,再做.
    6. 六大原则：
        开闭原则：允许增加新功能,不能修改客户端代码.
        单一职责：每个类有且只有一个改变的原因
        依赖倒置：调用父,不调用子.
        组合复用：仅仅复用代码，优先考虑组合关系,不使用继承关系。
        里氏替换：父出现的地方，可以使用子替换.
                 建议使用扩展重写
        迪米特：低耦合
"""

三、Python 高级总复习

"""
    Python高级总复习
    1. 导入三种方式：
        import 路径.模块 as 别名
        from 路径.模块 import 成员
        from 路径.模块 import *
    2. 导包成功的条件：sys.path + 导入路径 = 真实路径
    3. 异常处理
        语法：
            try:
                可能触发异常的语句
            except 错误类型1 [as 变量1]：
                处理语句1
            except 错误类型2 [as 变量2]：
                处理语句2
            except Exception  [as 变量3]：
                不是以上错误类型的处理语句
            else:
                未发生异常的语句
            finally:
                无论是否发生异常的语句
        现象：当异常发生时，程序不会再向下执行，而转到函数的调用语句。
        目的：将异常流程(向上)转换为正常流程(向下)
        目标：逻辑错误,非语法错误.
        人为抛出异常：快速传递信息
            raise 异常对象
        自定义异常类：封装错误信息
    4. 迭代
        可迭代对象：__iter__,可以参与for循环
        迭代器：__next__,可以通过next取值
    5. 生成器
        特点：惰性/延迟（循环一次/计算一次/返回一次）
        生成器函数:yield
                如果结果是多个使用yield返回
                         单个   return
        生成器表达式：(推导式语法)
    6. 函数式编程
        函数作为参数:将核心逻辑传入函数,从而得到通用的函数.
            重点：IterableHelper 集成操作框架
        函数作为返回值:逻辑连续
            闭包、装饰器 
"""

第七章 阶段项目 - 2048（*）

1.  将2048核心算法定义到核心类中GameCoreController,
    作为实例成员

2.  产生新数字
    -- 随机位置(计算出所有空位置,随机选择一个)
    -- 2(90%) 或者 4(10%)

3. 判断游戏是否结束
    -- 如果有空位置,游戏不能结束
    -- 如果横向可以移动,游戏不能结束
    --    纵向
    -- 以上条件不满足,游戏结束.

4. 创建控制台游戏视图GameConsoleView
    游戏开始时,产生2个新数字,绘制界面.
    游戏逻辑,获取玩家输入wsad移动地图,产生新数字,判断游戏是否结束.

"""
	bll.py
    游戏核心逻辑控制器
"""
import random

from model import LocationModel


class GameCoreController:
    def __init__(self):
        self.__list_merge = None
        self.__map = [
            [0, 0, 0, 0],
            [0, 0, 0, 0],
            [0, 0, 0, 0],
            [0, 0, 0, 0],
        ]
        self.__list_empty_location = []

    @property
    def map(self):
        return self.__map

    def __zero_to_end(self):
        """
            零元素移动到末尾
        """
        for i in range(len(self.__list_merge) - 1, -1, -1):
            if self.__list_merge[i] == 0:
                del self.__list_merge[i]
                self.__list_merge.append(0)

    def __merge(self):
        """
            合并数据
        """
        self.__zero_to_end()
        for i in range(len(self.__list_merge) - 1):
            if self.__list_merge[i] == self.__list_merge[i + 1]:
                self.__list_merge[i] += self.__list_merge[i + 1]
                del self.__list_merge[i + 1]
                self.__list_merge.append(0)

    def move_left(self):
        """
            向左移动
        """
        for line in self.map:
            self.__list_merge = line
            self.__merge()

    def move_right(self):
        """
            向右移动
        """
        for line in self.map:
            self.__list_merge = line[::-1]
            self.__merge()
            line[::-1] = self.__list_merge

    def __square_matrix_tranpose(self):
        for c in range(len(self.map) - 1):
            for r in range(c + 1, len(self.map)):
                self.map[r][c], self.map[c][r] = self.map[c][r], self.map[r][c]

    def move_up(self):
        """
            向上移动
        """
        self.__square_matrix_tranpose()
        self.move_left()
        self.__square_matrix_tranpose()

    def move_down(self):
        """
            向下移动
        """
        self.__square_matrix_tranpose()
        self.move_right()
        self.__square_matrix_tranpose()

    def generate_new_number(self):
        self.__calculate_empty_location()
        if len(self.__list_empty_location) == 0: return
        loc = random.choice(self.__list_empty_location)
        # self.map[loc[0]][loc[1]] = self.__select_random_number()
        self.map[loc.r][loc.c] = self.__select_random_number()

    def __select_random_number(self):
        return 4 if random.randint(1, 10) == 1 else 2

    def __calculate_empty_location(self):
        self.__list_empty_location.clear()
        for r in range(len(self.map)):
            for c in range(len(self.map[r])):
                if self.map[r][c] == 0:
                    # self.__list_empty_location.append((r, c))
                    self.__list_empty_location.append(LocationModel(r, c))

    def is_game_over(self):
        if len(self.__list_empty_location) > 0:
            return False

        for r in range(len(self.map)):
            for c in range(len(self.map[r]) - 1):
                if self.map[r][c] == self.map[r][c + 1] or self.map[c][r] == self.map[c + 1][r]:
                    return False

        return True
        # for r in range(len(self.map)):
        #     for c in range(len(self.map[r])-1):
        #         if self.map[r][c] == self.map[r][c+1]:
        #             return False
        #
        # for c in range(len(self.map)):
        #     for r in range(len(self.map)-1):
        #         if self.map[r][c] == self.map[r+1][c]:
        #             return False


if __name__ == '__main__':
    controller = GameCoreController()
    controller.generate_new_number()
    controller.generate_new_number()
    controller.move_down()
    print(controller.map)

"""
	model.py
"""
class LocationModel:
    """
        位置模型
    """
    def __init__(self,r,c):
        self.r = r
        self.c = c

"""
	usl.py
    游戏界面逻辑模块
"""
import os

from bll import GameCoreController


class GameConsoleView:
    """
        控制台界面类
    """
    def __init__(self):
        self.__controller = GameCoreController()

    def __start(self):
        self.__controller.generate_new_number()
        self.__controller.generate_new_number()
        self.__draw_map()

    def __update(self):
        while True:
            self.__move_map_for_input()
            self.__controller.generate_new_number()
            self.__draw_map()
            if self.__controller.is_game_over():
                print("游戏结束")

    def __move_map_for_input(self):
        dir = input("请输入方向:")
        if dir == "w":
            self.__controller.move_up()
        elif dir == "s":
            self.__controller.move_down()
        elif dir == "a":
            self.__controller.move_left()
        elif dir == "d":
            self.__controller.move_right()

    def main(self):
        self.__start()
        self.__update()

    def __draw_map(self):
        os.system("clear")
        for line in self.__controller.map:
            for item in line:
                print(item,end ="\t")
            print()

"""
	main.py
    游戏入口
"""
from usl import GameConsoleView

if __name__ == '__main__':
    view = GameConsoleView()
    view.main()