python学习笔记

上周内容回顾

• 反射的实战案例

反射:通过字符串操作对象的属性或者方法
简单的理解为人可以更加简单的与面向对象相关代码做交互

• 魔法方法

__init__          对象赋值独有的数据
__str__           对象执行打印操作(必须返回字符串类型)
__getattr__       对象获取不存在的属性名
__setattr__       对象操作属性
__del__           对象删除操作
__getattribute__  对象获取属性名
__call__          对象加括号调用
__enter__         对象执行with语法开始(返回啥as后面的变量接收啥)
__exit__          对象执行with语法结束
__new__           产生空对象

• 元类

1.产生类的类
	默认的元类是type
	class MyMetaClass(type):
        pass
2.修改类的元类
	class MyClass(metaclass=MyMetaClass):
        pass
3.高度定制化类或者对象的行为
	__init__   类
	__call__   对象
4.元类里面的双下call执行流程
	1.产生空对象
 	2.将空对象交给类里面的__init__实例化
	3.返回对象
ps:用不到元类的时候就不要想底层这么复杂的逻辑了!!!

今日内容概要

• 设计模式
• pickle模块
• 选课系统项目分析
• 选课系统目录搭建
• 选课系统功能编写

今日内容详细

设计模式

1.如何理解设计模式
	在IT行业有很多前辈针对固定的一些问题设计出了固定的解决套路
2.设计模式总共有23种
	我们目前不需要掌握这么多种 后续再慢慢看(现在能力不足)
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)


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

class Mysql:
    __instance=None
    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=Mysql('1.1.1.2',3306)
obj2=Mysql('1.1.1.3',3307)
print(obj1 is obj2) #False

obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True


方式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模块

"""
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模块也不行

import pickle

with open(r'a.txt', 'wb') as f:
    f.write(pickle.dumps(obj))
    pickle.dump(obj, f)

with open(r'a.txt', 'rb') as f:
    data = pickle.load(f)
print(data)
print(data.name)
data.choice_course()

选课系统项目分析

选课系统
  角色:学校、学员、课程、讲师
  要求:
    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.查看分数

选课系统目录搭建

三层架构
    功能展示层
    core
        src.py
        admin_view.py
        teacher_view.py
        student_view.py
    核心逻辑层
    interface
        admin_interface.py
        teacher_interface.py
        student_interface.py
    数据处理层
    db
        db_hanlder.py
        models.py

    conf
        settings.py
    lib
        common.py
    start.py
    readme
    requirements.txt

选课系统管理员注册功能完整逻辑

启动文件把当前项目根目录添加到sys.path
写一个启动脚本
在第一层src.py文件写一个run方法
    1,2,3,分别对应管理员视图文件，讲师视图文件，学生视图文件
进到第一层管理员视图文件搭建管理员功能框架
    在注册功能先获取用户数据
    校验两次密码是否一致
    调第二层管理员注册功能接口
在第二层管理员注册功能文件建立注册功能函数
    先校验用户名是否已存在(调用models.py文件读取用户数据)
    完成用户注册(调用models.py文件保存用户数据)
调第三层models.py文件
    建立一个创建管理员对象的类
    类加括号实例化产生管理员对象
    封装seve_obj方法专门调db_hanlder.py文件数据保存功能
    封装给类的check_obj方法专门调db_hanlder.py文件数据读取功能
再到第三层db_hanlder.py文件建立数据保存功能
    由于db目录下将来需要存各个角色的文件数据，为了便于管理，我们再创一级目录，类名叫什么文件夹的名字就叫什么
    先在配置文件拼接db文件夹路径(可能很多地方都要用，所以放在配置文件)
    建立保存数据的功能
    然后在db_hanlder.py拼接存放管理员数据的文件路径
    拼接对象文件路径，pickle模块写入
    建立查询数据的功能
    拼接存放管理员数据的文件路径
    拼接对象文件路径，pickle模块读取