【python基础】第38回 选课系统

目录

• 1. 让字典具备句点符操作数据的功能
• 2. 设计模块
  • 2.1 如何理解设计模式
  • 2.2 设计模式总共有23种
  • 2.3 设计模式的分类（三类）
  • 2.4 设计模式之单例模式
    • 2.4.1 类加括号用多次只允许产生一个对象
    • 2.4.2 引出
    • 2.4.3 方式1-使用元类干预对象的创建过程
    • 2.4.4 方式2-定义一个类方法实现单例模式
    • 2.2.5 方式3-定义一个装饰器实现单例模式
• 3. pickle 模块
  • 3.1 理解
  • 3.2 代码实例
• 4. 选课系统项目分析
  • 4.1 选课系统
  • 4.2 功能分析
    • 4.2.1 管理员功能（最核心）
    • 4.2.2 讲师功能
    • 4.2.3 学生功能
  • 4.3 系统架构设计-三层架构
    • 4.3.1 功能展示层
    • 4.3.2 核心逻辑层
    • 4.3.3 数据处理层
    • 4.3.4 画图讲解
  • 4.4 描述出选课系统管理员注册功能完成逻辑
    • 4.4.1 获取用户输入
    • 4.4.2 注册接口
    • 4.4.3 models.py

1. 让字典具备句点符操作数据的功能

1.自定义字典并且让字典具备
d.key = value  修改键值对
d.key = value  添加键值对

# 让字典具备句点符操作数据的功能（对象的名称空间与对象的值不是一个概念）
class MyDict(dict):
    def __getattr__(self, item):
        return self.get(item)

    def __setattr__(self, key, value):
        self[key] = value

a = MyDict(name= 'jason',ped = 123)
print(a.name)
a.xxx = '得得得'  # 添加
a.name = 'jasonnn'  # 修改
print(a)

2. 设计模块

2.1 如何理解设计模式

在IT行业有很多前辈针对固定的一些问题设计出了固定的解决套路

2.2 设计模式总共有23种

2.3 设计模式的分类（三类）

创建型
结构型
行为型

2.4 设计模式之单例模式

2.4.1 类加括号用多次只允许产生一个对象

正常情况下，类名只要加括号实例化产生对象，执行几次就会产生几个不同的对象

class MyClass:
    pass

obj1 = MyClass()
obj2 = MyClass()
obj3 = MyClass()
print(id(obj1),id(obj2),id(obj3))  # 2613284719200 2613285182336 2613284536816

2.4.2 引出

有时候我们不希望类频繁的产生不同的对象

1. 类中有很多很好用的方法，程序很多地方都需要使用（通过对象调用）
2. 如果产生的地方特别多，那么会浪费一定的内存空间，所有需要使用单例

2.4.3 方式1-使用元类干预对象的创建过程

class MyClass(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 Singin(metaclass=MyClass):
    def __init__(self,name):
        self.name = name

obj1 = Singin('jason')
obj2 = Singin('zason')
obj3 = Singin('xason')
print(id(obj1),id(obj2),id(obj3))

print(obj1.name)  # jason
print(obj2.name)  # jason
print(obj3.name)  # jason

2.4.4 方式2-定义一个类方法实现单例模式

# 定义一个类方法实现单例模式
import settings

class MyClass:
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance =cls(settings.HOST,settings.PORT)
            return cls.__instance

obj1 = MyClass('1.1',222)
obj2 = MyClass('1.2',333)
print(obj1 is obj2)
obj3=MyClass.singleton()
obj4=MyClass.singleton()
print(obj3 is obj4)

2.2.5 方式3-定义一个装饰器实现单例模式

import settings

def singleton(cls): #cls=Mysql
    _instance=cls(settings.HOST,settings.PORT)

    def wrapper(*args,**kwargs):
        if args or kwargs:
            obj=cls(*args,**kwargs)
            return obj
        return _instance
    return wrapper


@singleton # Mysql=singleton(Mysql)
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql()
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3) #True

obj4=Mysql('1.1.1.3',3307)
obj5=Mysql('1.1.1.4',3308)
print(obj3 is obj4) #False

3. pickle 模块

3.1 理解

1. pickle模块与json模块很像，都是用来做序列化，反序列化的
2. 并且pickle模块支持python所有数据类型
3. 但是pickle不支持跨语言传输，只能python自己跟自己玩，兼容性不好
4. 为了比较方便的编写选课系统，我们需要将对象保存到文件，所以需要用该模块，后续我们不用 因为有更加高级的方法>>>:ORM(对象关系映射)

3.2 代码实例

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模块也不行
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)
data.choice_course()

4. 选课系统项目分析

4.1 选课系统

选课系统
  角色:学校、学员、课程、讲师
  要求:
    1. 创建北京、上海 2 所学校
    2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
    3. 课程包含，周期，价格，通过学校创建课程 
    4. 通过学校创建班级， 班级关联课程、讲师5. 创建学员时，选择学校，关联班级
    5. 创建讲师角色时要关联学校， 
    6. 提供三个角色接口  
    	6.1 学员视图， 可以注册， 交学费， 选择班级，  
    	6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩   
    	6.3 管理视图，创建讲师， 创建班级，创建课程
    7. 上面的操作产生的数据都通过pickle序列化保存到文件里

4.2 功能分析

4.2.1 管理员功能（最核心）

1. 注册
2. 登录
3. 创建讲师
4. 创建学校
5. 创建课程

4.2.2 讲师功能

1.登录
2.查看教授课程
3.选择教授课程
4.查看课程学生
5.评判学生分数

4.2.3 学生功能

1.注册
2.登录
3.选择学校
4.选择课程
5.查看分数

4.3 系统架构设计-三层架构

4.3.1 功能展示层

src.py
admin_view_py
teacher_view.py
student_view.py

4.3.2 核心逻辑层

admin_interface.py
teacher_interface.py
student_interface.py

4.3.3 数据处理层

db_hanlder.py
model.py

4.3.4 画图讲解

4.4 描述出选课系统管理员注册功能完成逻辑

4.4.1 获取用户输入

1. 获取用户名，密码，确认密码
2. 判断两次密码是否一致
3. 调用注册接口

4.4.2 注册接口

1. 将用户名和密码放到models中判断用户对象是否存在
2. 返回信息

4.4.3 models.py

1. 获取用户名和密码
2. 创建对象在db_handler中判断用户是否存在
3. 若不存在则将对象传入db_hanlder中保存对象数据，并返回该对象
4. 若存在则返回空