第31天三层架构，异常

import os
import sys
from core import main

BASE_DIR = os.path.normpath(os.path.join(
    __file__,
    os.pardir,
    os.pardir
))

sys.path.append(BASE_DIR)

if __name__ == '__main__':
    main.run()

from interface import common_interface
from core import admin, student, teacher


def init():
    """初始化函数"""
    pass


def run():
    """系统入口函数"""
    init()
    sys_welcome_info = 'COURSE SELECTION SYSTEM'
    sys_func = """1.管理员操作界面\n2.学员操作界面\n3.讲师操作界面"""
    sys_func_dict = {
        '1': admin.admin_view,
        '2': student.student_view,
        '3': teacher.teacher_view
    }
    common_interface.sys_func_inter(sys_welcome_info, sys_func, sys_func_dict)

from functools import wraps
import re
from interface import common_interface, admin_interface


def login_auth(func):
    @wraps(func)
    def inner(*args, **kwargs):
        if not common_interface.admin_status:
            login()
            if common_interface.admin_status:
                return func(*args, **kwargs)
            else:
                print('管理员未登录成功')
        else:
            return func(*args, **kwargs)

    return inner


def register():
    """注册"""
    temp = '请'
    while True:
        name = input(temp + '输入管理员的名字(Q退出)>>').strip()
        if name.upper() == 'Q':
            return
        pwd1 = input('请输入管理员的密码>>').strip()
        pwd2 = input('请确认您的密码>>').strip()
        if name and pwd1 and pwd2:
            if pwd1 == pwd2:
                msg, state = admin_interface.register(name, pwd1)
                if state:
                    return common_interface.logger('admin', msg)
                else:
                    print(msg)
            else:
                print('两次密码不一致')
        else:
            print('输入不能为空')
        temp = '请重新'


def login():
    """登录"""
    temp = '请'
    while True:
        name = input(temp + '输入用户名(Q退出)>>').strip()
        if name.upper() == 'Q':
            return
        pwd = input('请输入密码>>').strip()
        if name and pwd:
            msg, state = admin_interface.login(name, pwd)
            if state:
                common_interface.admin_status = state
                return common_interface.logger('admin', msg)
            else:
                print(msg)
        else:
            print('用户名和密码不能为空')
        temp = '请重新'
def admin_view():
    """管理员系统接口"""
    sys_welcome_info = 'ADMIN OPERATE SYSTEM'
    sys_func = """1.注册\n2.登录\n3.创建校区\n4.创建课程\n5.创建班级\n6.创建讲师"""
    sys_func_dict = {
        '1': register,
        '2': login,
        '3': create_campus,
        '4': create_course,
        '5': create_grade,
        '6': create_teacher
    }
    common_interface.sys_func_inter(sys_welcome_info, sys_func, sys_func_dict)

from db import models


def register(name, pwd):
    """注册

    name: 管理员名字 pwd:管理员密码，如果注册成功返回(msg，True),如果失败(msg, False)
    """
    admin_obj = models.Admin.get_obj_from_name(name)
    if admin_obj:
        return 'admin is exists', False
    else:
        models.Admin(name, pwd)
        return 'create %s successful' % name, True


def login(name, pwd):
    """登录

    name: 管理员名字 pwd:管理员密码，如果注册成功返回(msg，对象),如果失败(msg, False)
    """
    admin_obj = models.Admin.get_obj_from_name(name)
    if admin_obj:
        if admin_obj.pwd == pwd:
            return 'admin %s login successfully' % name, admin_obj
        else:
            return 'password is wrong !', False
    else:
        return 'admin is not exists', False

from db import DBhandler


class BaseClass:
    """这是一个基类，用来存放一些公共的方法和属性"""

    @classmethod
    def tell_info(cls):
        """查看当前类中的所有对象，

        将结果封装到一个列表中返回回去，如果没有对象，则返回空列表
        """
        return DBhandler.tell_info(cls)

    @classmethod
    def get_obj_from_name(cls, name):
        """根据名字查看是否有这个对象，如果存在则返回对象本身，不存在则返回None"""
        return DBhandler.get_obj_from_name(cls, name)

    @classmethod
    def save(cls, obj):
        """将传入的对象存储到文件中"""
        DBhandler.save(cls, obj)

class Admin(BaseClass):
    """管理员类

    会创建一个不同的文件分别来存储我们的管理员信息
    """

    def __init__(self, name, pwd):
        self.name = name
        self.pwd = pwd
        self.save(self)

import os
import pickle
from conf import settings


def save(cls, obj):
    """将对象存储到文件中

    cls:类对象，为了拼接路径用的，obj: 实际要存储的对象
    """
    obj_dir = os.path.join(settings.DB_DIR, cls.__name__)
    if not os.path.exists(obj_dir):
        os.mkdir(obj_dir)
    file_path = os.path.join(obj_dir, obj.name)
    with open(file_path, 'wb') as f:
        pickle.dump(obj, f)


def get_obj_from_name(cls, name):
    """根据名字获得对象

    cls:类本身，name: 传入的名称，此方法依然不适用于课程或者班级
    """
    file_path = os.path.join(settings.DB_DIR, cls.__name__, name)
    if os.path.exists(file_path):
        with open(file_path, 'rb') as f:
            return pickle.load(f)


def tell_info(cls):
    """查看当前类创建的所有对象

    cls: 类对象，此方法是根据在db目录下是否存在相应的文件来查看是否有对象的，因此对于课程或者班级
    这种并没有存储到文件中的类来讲是查看不到的，如果查看不到的会返回一个空的列表,所以不要用用课程或
    班级类来调用此方法
    """
    temp = []
    obj_dir = os.path.join(settings.DB_DIR, cls.__name__)
    if os.path.exists(obj_dir):
        for file_name in os.listdir(obj_dir):
            file_path = os.path.join(obj_dir, file_name)
            with open(file_path, 'rb') as f:
                temp.append(pickle.load(f))
    return temp

import logging.config
from conf import log_config

admin_status = None
student_status = None
teacher_status = None


def sys_func_inter(sys_welcome_info, sys_func, sys_func_dict):
    """系统的功能接口函数

    sys_welcome_info: 系统功能分割信息
    sys_func: 系统的功能信息
    sys_func_dict: 系统的功能字典
    """
    temp = '请'
    while True:
        print(sys_welcome_info.center(50, '*'))
        print(sys_func)
        print(sys_welcome_info.center(50, '*'))
        choice = input(temp + '输入你要选择的功能(Q退出)>>').strip()
        if choice.upper() == 'Q':
            return
        if choice not in sys_func_dict:
            print("输入有误")
            temp = '请重新'
            continue
        sys_func_dict[choice]()


def my_logger(name='admin'):
    """通过读取配置文件获得一个自己的日志生成器

    name:可以是三个值,student代表的是学生对象的日志生成器，teacher代表的是讲师对象的日志生成器，admin代表的是管理员的日志生成器
    默认的是管理员的生成器
    """
    logging.config.dictConfig(config=log_config.LOGGING_DIC)
    return logging.getLogger(name)


def logger(name, msg):
    """更高层次的一层封装"""
    log = my_logger(name)
    log.debug(msg)

ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError

try:
    a   # 当运行到这一行的时候会发生异常然后被捕捉然后执行except语句
    l = [1, 2, 3]
    print(l[4])
except (IndexError, NameError):
    print('程序发生了未知错误')

# 运行结果：
# 程序发生了未知错误

try:
    f = open('xxx', 'wt', encoding='utf-8')
    # 当此时出现异常之后，没有被捕捉到，所以程序终止，但是当前f打开的系统资源还没
    # 有被回收掉，所以我们可以通过finally去回收当前系统中还没有被回收的资源
    f.read()   
    f.close()
except NameError:
    pass
finally:
    f.close()