选课系统

目录

• 一、设计模式
  • 1.设计模式分类(三类)
  • 2.设计模式——单例模式
    • 2.1.方式一：使用元类干预对象的创建过程
    • 2.2.方式二：定义一个类方法实现单例模式
    • 2.3.方式三：定义一个装饰器实现单例模式
• 二、pickle模块
  • 1.简介
  • 2.代码示例
• 三、选课系统
  • 1.项目要求
  • 2.功能分析
    • 2.1.管理员功能(核心)
    • 2.2.讲师功能
    • 2.3.学生功能
  • 3.系统架构设计

一、设计模式

针对固定的一些问题设计出了固定的解决套路
设计模式总共有23种

1.设计模式分类(三类)

创建型、结构型、行为型

2.设计模式——单例模式

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

class MyClass:
    pass
obj1 = MyClass()
obj2 = MyClass()
obj3 = MyClass()

正常情况下，类名加括号实例化对象，执行几次就会产生几个不同的对象，但是我们不希望类频繁的产生不同的对象，如果产生的地方特别多会浪费一定的内存空间，这时候就需要使用单例

2.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('tom')
obj3 = Single('katty')
print(id(obj1), id(obj2), id(obj3))  # 2931788983320 2931788983320 2931788983320
print(obj1.name)  # jason
print(obj2.name)  # jason
print(obj3.name)  # jason

2.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.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

二、pickle模块

1.简介

pickle模块与json模块相似，都用来做序列化、反序列化

优点：pickle模块支持python所有数据类型

缺点：pickle模块不支持跨语言传输，兼容性不好

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)

# json模块也不行    
import json

with open(r'a.txt', 'w', encoding='utf8') as f:
    f.write(json.dumps(obj))
    
# pickle模块
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()

三、选课系统

1.项目要求

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

2.功能分析

2.1.管理员功能(核心)

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

2.2.讲师功能

1. 注册
2. 登录
3. 选择教授课程
4. 查看教授课程
5. 管理课程分数

2.3.学生功能

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

3.系统架构设计

三层架构：

1. 功能展示层：

   src.py

   admin.py

   teacher.py

   student.py

2. 核心逻辑层：

   admin_interface.py

   teacher_interface.py

   student_interface.py

3. 数据处理层

   db_handler.py

   modles.py