设计模式
1.如何理解设计模式
在IT行业有很多前辈针对固定的一些问题设计出了固定的解决套路
2.设计模式(23种)
工厂模式（Factory Pattern）
抽象工厂模式（Abstract Factory Pattern）
单例模式（Singleton Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）
工厂模式（Factory Pattern）
抽象工厂模式（Abstract Factory Pattern）
单例模式（Singleton Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）
责任链模式（Chain of Responsibility Pattern）
命令模式（Command Pattern）
解释器模式（Interpreter Pattern）
迭代器模式（Iterator Pattern）
中介者模式（Mediator Pattern）
备忘录模式（Memento Pattern）
观察者模式（Observer Pattern）
状态模式（State Pattern）
空对象模式（Null Object Pattern）
策略模式（Strategy Pattern）
模板模式（Template Pattern）
访问者模式（Visitor Pattern）
MVC 模式（MVC Pattern）
业务代表模式（Business Delegate Pattern）
组合实体模式（Composite Entity Pattern）
数据访问对象模式（Data Access Object Pattern）
前端控制器模式（Front Controller Pattern）
拦截过滤器模式（Intercepting Filter Pattern）
服务定位器模式（Service Locator Pattern）
传输对象模式（Transfer Object Pattern）
参考博客：https://www.cnblogs.com/chenssy/p/3357683.html
3.设计模式的分类
创建型、结构型、行为型
4.设计模式之单例模式
类加括号调用多次只允许产生一个对象
class MyClass:
pass
obj1 = MyClass()
obj2 = MyClass()
obj3 = MyClass()
print(id(obj1), id(obj2), id(obj3)) # 2263190030944 2263190494080 2263189844464
'''
正常情况下 类名只要加括号实例化产生对象 执行几次就会产生几个不同的对象
'''
'''
有时候我们不希望类频繁的产生不同的对象
类中有很多很好用的方法 程序很多地方都需要使用(通过对象调用)
如果产生的地方特别多 那么会浪费一定的内存空间 所以需要使用单例
'''
方式1:使用元类干预对象的创建过程
class MyMeTaClass(type):
# 记录类是否已经创建了对象
instance = None
def __call__(self, *args, **kwargs):
if self.instance:
return self.instance
# 获取空对象
obj = super().__call__(*args, **kwargs)
# 保存对象
self.instance = obj
# 返回空对象
return obj
class Single(metaclass=MyMeTaClass):
def __init__(self, name):
self.name = name
obj1 = Single('jason')
obj2 = Single('kevin')
obj3 = Single('tony')
print(id(obj1), id(obj2), id(obj3))
print(obj1.name)
print(obj2.name)
print(obj3.name)
pickle模块
了解pickle模块：
pickle模块与json模块很像 都是用来做序列化 反序列化的
并且pickle模块支持python所有数据类型
缺点：
pickle不支持跨语言传输 只能python自己跟自己玩 兼容性不好
为了比较方便的编写选课系统 我们需要将对象保存到文件 所以需要用该模块
后续我们不用 因为有更加高级的方法:ORM(对象关系映射)
class MyClass:
def __init__(self, name):
self.name = name
def choice_course(self):
print('%s正在选课' % self.name)
obj = MyClass('jason')
# 需求:将对象保存到文件 并且将来取出之后还可以通过句点符随意调用
with open(r'a.txt','w',encoding='utf8') as f:
f.write(obj)
# 常规的文件操作不行,文件虽然创建了，但是里面并没有写入数据
import json
with open(r'a.txt','w',encoding='utf8') as f:
f.write(json.dumps(obj))
# json模块也不行，对象不再json序列化的范围之内
import pickle
with open(r'a.txt', 'wb') as f:
f.write(pickle.dumps(obj))
pickle.dumps(obj, f)
# 文件内容是二进制形式的，只是用来保存的，不能用肉眼去看懂的，需要用的时候用代码去看
with open(r'a.txt', 'rb') as f:
data = pickle.load(f)
print(data) # 是一个对象
print(data.name) # jason 可以通过点的方式取到数据
data.choice_course() # jason正在选课
选课系统分析
选课系统
角色:学校、学员、课程、讲师
要求:
1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 通过学校创建班级， 班级关联课程、讲师5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校，
6. 提供三个角色接口
6.1 学员视图， 可以注册， 交学费， 选择班级，
6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程
7. 上面的操作产生的数据都通过pickle序列化保存到文件里
功能分析
管理员功能(最核心)
1.注册
2.登录
3.创建讲师
4.创建学校
5.创建课程
讲师功能
1.注册
2.登录
3.选择教授课程
4.查看教授课程
5.管理课程分数
学生功能
1.注册
2.登录
3.选择学校
4.选择课程
5.查看分数
系统架构设计
三层架构
功能展示层
src.py
admin_view.py
teacher_view.py
student_view.py
核心逻辑层
admin_interface.py
teacher_interface.py
student_interface.py
数据处理层
db_hanlder.py
model.py
选课系统管理员注册功能完整逻辑
第一层代码：
1.获取用户的用户名和密码
2.校验俩次密码是否一致
3.执行登录核心逻辑，获取接口层里面的接口
通过下面第二层的操作，接收到俩次参数，打印返回结果
第二层代码：
1.定义函数设置俩个形参，来接收用户名和密码
2.校验用户名是否已经存在
2.1管理员的校验，那么就通过操作管理员的类来进行校验
类里面的方法是绑定给对象的，但此时我们是需要去检验，手里面没有数据，是用类进行调用的，使用classmethod去修饰一下，将类当作第一个参数传入进去
去数据库里查看是否存在这个人
2.2获取路径，判断路径是否存在
3.完成用户注册
3.1这里我们不能操作db_hanlder(它只能由类调用),这里需要通过类来调用
3.2model.py
创建一个类，加括号进行实例化对象
from db import db_hanlder
class Admin(object):
def __init__(self, name, pwd):
self.name = name
self.pwd = pwd
self.save_obj() # 保存实例化后的对象
def save_obj(self):
db_hanlder.save_obj(self) # 这一步到了db.hanlder.py
3.3db.hanlder.py
由于db目录下将来需要存各个角色的文件数据，为了便于管理，动态创建多个不同角色的文件夹
类名叫什么文件夹的名字就叫什么
创建管理员文件夹路劲（obj.__class__.__name__）,判断文件路径是否存在
以上是准备工作
拼接对象文件路径
pickle模块写入（使用二进制模式写入）
向前推，推到注册接口层：
models.Admin(username, password)
return True, f'{username}注册成功'
