一：項目題目：開發一套選課系統
二：項目需求：
角色:學校、學員、課程、講師
要求:
1. 建立北京、上海 2 所學校
2. 建立linux , python , go 3個課程 ， linux\py 在北京開， go 在上海開
3. 課程包含，周期，價格，通過學校建立課程
4. 通過學校建立班級， 班級關聯課程、講師
5. 建立學員時，選擇學校，關聯班級
5. 建立講師角色時要關聯學校，
6. 提供兩個角色接口
6.1 學員視圖， 可以注冊， 交學費， 選擇班級，
6.2 講師視圖， 講師可管理自己的班級， 上課時選擇班級， 檢視班級學員清單 ， 修改所管理的學員的成績
6.3 管理視圖，建立講師， 建立班級，建立課程
7. 上面的操作産生的資料都通過pickle序列化儲存到檔案裡
三：注意事項
1.（簡單）實作70%+功能，充分使用類
2.（一般）類的設計比較清晰、合理
3.（完整）整體代碼邏輯很清晰、角色劃厘清楚、不同角色的主要功能都實作了
四：項目思路
1，先分析題目，，也就是找關鍵詞，從上面可以看出有三個視圖，分别是管理者視圖，講師視圖，學員視圖
對角色進行分類：學校，老師，學生，課堂，班級，管理者
三個視圖，也就是三個管理接口，分别是學員視圖，講師視圖，管理視圖
五個角色，也就是定義五個類，分别是學校，學員，課程，講師，班級
2，分析管理者建立什麼東西，老師建立什麼東西，學生建立什麼東西
一個講師可以教多個班
一個學員可以學多個班級的課
一個課程可以有多個班級
一個班級對應一個課程
一個班級對應一個講師
學生視圖：要選擇學校，選擇班級，其中班級顯示其名稱，課程，價錢，添加到對應的班級裡面
講師視圖：可以檢視所教授的課程的班級，班級學生的資訊
管理者視圖：可以建立講師，建立班級，建立課程，查詢講師，班級，課程的功能
3，具體進行分析
具體分析學生視圖，學生視圖進去可以注冊學生（包括選擇所在學校，選擇所在班級，選擇所學課程），
檢視學生的成績，檢視學生的到課情況
具體分析講師視圖，講師視圖進去可以注冊講師（包括選擇所在學校，選擇所教班級，選擇所教課程），
建立學生的成績，建立學生的到課情況（管理班級）
具體分析管理視圖，管理視圖進去可以建立學生，建立講師，建立課程，建立學校，建立班級，建立課程等等
對于管理系統，我附加了登陸認證，我認為管理不是随便就可以進去的，管理者賬号admin，密碼root,
認證成功後才可以進行一系列操作
4，寫出大緻的僞代碼，并實作其功能，如下：
僞代碼：
學校視圖：
選擇學校
1，建立班級
2，建立講師
3，建立課程
4，查詢講師
5，查詢班級
6，查詢課程
講師視圖
1，檢視班級
2，檢視班級學員清單
學員視圖
1，注冊
2，報名繳費
3，選擇班級
5，填充代碼
五：項目流程圖
六：README檔案
作者:zhanzhengrecheng
程式介紹:
實作選課系統 常用功能
功能全部用python的基礎知識實作,用到了os\sys\pickle\函數\子產品\類知識
概述
本次作業檔案夾一共包含了以下6個檔案：
流程圖： Select Course思路流程圖
程式結構圖：整個Select Course的程式檔案結構
程式結構檔案：整個Select Course的程式檔案結構
程式檔案: Select Course
程式說明檔案：README.md
程式要求
建立北京、上海 2 所學校
建立linux , python , go 3個課程 ， linux\py 在北京開， go 在上海開
課程包含，周期，價格，通過學校建立課程
通過學校建立班級， 班級關聯課程、講師
建立學員時，選擇學校，關聯班級
建立講師角色時要關聯學校，
提供兩個角色接口
學員視圖， 可以注冊， 交學費， 選擇班級，
講師視圖， 講師可管理自己的班級， 上課時選擇班級， 檢視班級學員清單 ， 修改所管理的學員的成績
管理視圖，建立講師， 建立班級，建立課程
上面的操作産生的資料都通過pickle序列化儲存到檔案裡
本程式思路是寫了一個Select Course的程式
先分析題目，，也就是找關鍵詞，從上面可以看出有三個視圖，分别是管理者視圖，講師視圖，學員視圖
對角色進行分類：學校，老師，學生，課堂，班級，管理者
分析管理者建立什麼東西，老師建立什麼東西，學生建立什麼東西
具體分析學生視圖，學生視圖進去可以注冊學生（包括選擇所在學校，選擇所在班級，選擇所學課程），
檢視學生的成績，檢視學生的到課情況
具體分析講師視圖，講師視圖進去可以注冊講師（包括選擇所在學校，選擇所教班級，選擇所教課程），
建立學生的成績，建立學生的到課情況（管理班級）
具體分析管理視圖，管理視圖進去可以建立學生，建立講師，建立課程，建立學校，建立班級，建立課程等等
對于管理系統，我附加了登陸認證，我認為管理不是随便就可以進去的，管理者賬号admin，密碼root,
認證成功後才可以進行一系列操作
寫出僞代碼，然後填充
程式結構
備注（程式結構）
目前還不會在windows中用樹的結構，是以做出程式結構的txt版本，放在檔案外面
對幾個執行個體檔案的說明
── admin # 管理者賬戶資料，隻存了一個管理者，賬号是admin，密碼是root
── c++ # 這是存課程類中其中一個課程的詳細資訊
── class #這是存班級的檔案，比如建立了python全棧1班，。。。
── class_grade # 這是存班級中學生成績的檔案，比如王二：87
── class_record # 這是存班級中學生到課次數的檔案，比如王二：8次
── Course # 這是存所有課程的檔案，比如目前開的課程有'python', 'linux', 'java',c++,.。。
── java #這是存課程類中其中一個課程的詳細資訊
── linux # 這是存課程類中其中一個課程的詳細資訊
── python # 這是存課程類中其中一個課程的詳細資訊
── school # 這是存所有學校的檔案，比如目前隻有北京分校，上海分校，。。。
不足及其改進的方面
1，未能熟練的使用類方法，好多類中函數為了友善類與對象都可以調用，寫成了普通函數，
2，希望對類有更熟悉的認識之後，重構代碼，用class寫，不出現很多@staticmethod
3，想法比較簡單，希望能學習更好的用類寫出來的選課系統，自己再研究研究
七：程式結構圖
八：程式代碼
8.1 bin
bin下run.py
# _*_ coding: utf-8 _*_
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
from core import main
if __name__ =='__main__':
main.begin()
8.2 conf
conf下settings.py
# _*_ coding: utf-8 _*_
import sys
import os
import logging
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
DATABASE = {
'engine':'file_storage', #檔案存儲，這裡可擴充成資料庫形式
'name':'accounts', #db下的檔案名稱
'path':'%s/db'%BASE_DIR
}
LOGIN_LEVEL = logging.INFO #初始化日志記錄級别為INFO，INFO以下的可以直接列印
#日志類型
LOGIN_TYPE = {
'system':'system.log',
}
8.3 core
core下的accounts.py
# _*_ coding: utf-8 _*_
#讀取資料和儲存資料
import os
import sys
import pickle,json
import logging
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR) #添加環境變量
from core import auth
from core import db_handler
from conf import settings
class MyPickle:
def __init__(self):
pass
def load_account(account):
db_path = db_handler.db_handler(settings.DATABASE)
account_file = '%s/%s' % (db_path, account)
if os.path.isfile(account_file): # 如果使用者名存在
with open(account_file, 'rb') as f:
account_data = pickle.load( f)
return account_data
else:
print("\033[31;1mAccount [%s] does not exist!\033[0m" % account)
exit()
def save_account(account_dic):
db_path = db_handler.db_handler(settings.DATABASE)
filename = '%s/%s' % (db_path, account_dic['account'])
with open(filename,'wb') as f:
acc_data = pickle.dump(account_dic, f)
def save_course(account_dic):
db_path = db_handler.db_handler(settings.DATABASE)
filename = '%s/%s' % (db_path, account_dic['course_name'])
with open(filename,'wb') as f:
acc_data = pickle.dump(account_dic, f)
def load_course(course_name):
db_path = db_handler.db_handler(settings.DATABASE)
account_file = '%s/%s' % (db_path, course_name)
if os.path.isfile(account_file):#如果使用者名存在
with open(account_file, 'rb') as f:
account_data = pickle.load( f)
print("\033[34;1m--------這是您查找的課程資訊----------\033[0m")
print('\033[32;1m%s\033[0m'%account_data)
return account_data
else:
print("\033[31;1mCourse [%s] does not exist!\033[0m" % course_name)
exit()
def save_class(name,class_name):
db_path = db_handler.db_handler(settings.DATABASE)
filename = '%s/%s' % (db_path, name)
with open(filename, 'a+',encoding='utf-8') as f:
f.write(class_name)
f.write(',')
def load_class(name):
db_path = db_handler.db_handler(settings.DATABASE)
account_file = '%s/%s' % (db_path, name)
if os.path.isfile(account_file): # 如果使用者名存在
with open(account_file, 'r',encoding='utf-8') as f:
account_data = f.read()
print("----------\033[34;1m目前存在的班級\033[0m----------")
print("\033[31;1m%s\033[0m" % account_data)
print("-----------------------------------")
return account_data
else:
print("\033[31;1mClass [%s] does not exist!\033[0m" % name)
exit()
def save_classrecord(name,classrecord_dict):
db_path = db_handler.db_handler(settings.DATABASE)
filename = '%s/%s' % (db_path, name)
with open(filename, 'a+',encoding='utf-8') as f:
f.write(classrecord_dict)
f.write(',')
def load_classrecord(name):
db_path = db_handler.db_handler(settings.DATABASE)
account_file = '%s/%s' % (db_path, name)
if os.path.isfile(account_file): # 如果使用者名存在
with open(account_file, 'r',encoding='utf-8') as f:
account_data = f.read()
print("-----------------課堂記錄-------------------")
print("\033[31;1m%s\033[0m" % account_data)
print("-------------------------------------------")
return account_data
else:
print("\033[31;1mClass record does not exist!\033[0m" )
exit()
def save_classgrade(name,classgrade_dict):
db_path = db_handler.db_handler(settings.DATABASE)
filename = '%s/%s' % (db_path, name)
with open(filename, 'a+',encoding='utf-8') as f:
f.write(classgrade_dict)
f.write(',')
def load_classgrade(name):
db_path = db_handler.db_handler(settings.DATABASE)
account_file = '%s/%s' % (db_path, name)
if os.path.isfile(account_file): # 如果使用者名存在
with open(account_file, 'r',encoding='utf-8') as f:
account_data = f.read()
print("-----------------學生成績-------------------")
print("\033[31;1m%s\033[0m" % account_data)
print("-------------------------------------------")
return account_data
else:
print("\033[31;1mClass grade does not exist!\033[0m")
exit()
def save_school(name, school_name):
db_path = db_handler.db_handler(settings.DATABASE)
filename = '%s/%s' % (db_path, name)
with open(filename, 'a+',encoding='utf-8') as f:
f.write(school_name)
f.write(',')
def load_school(name):
db_path = db_handler.db_handler(settings.DATABASE)
account_file = '%s/%s' % (db_path, name)
if os.path.isfile(account_file): # 如果使用者名存在
with open(account_file, 'r',encoding='utf-8') as f:
account_data = f.read()
print("----------\033[34;1m目前存在的學校\033[0m----------")
print("\033[31;1m%s\033[0m" % account_data)
print("-----------------------------------")
return account_data
else:
print("\033[31;1mSchool does not exist!\033[0m")
exit()
def save_coursedata(name, course_name):
db_path = db_handler.db_handler(settings.DATABASE)
filename = '%s/%s' % (db_path, name)
with open(filename,'a+',encoding='utf-8') as f:
f.write(course_name)
f.write(',')
def load_coursedata(name):
db_path = db_handler.db_handler(settings.DATABASE)
account_file = '%s/%s' % (db_path, name)
if os.path.isfile(account_file): # 如果使用者名存在
with open(account_file, 'r',encoding='utf-8') as f:
account_data = f.read()
print("----------\033[34;1m這是已經有的課程\033[0m----------")
print("\033[31;1m%s\033[0m" % account_data)
print("----------------------------------------------------")
return account_data
else:
print("\033[31;1mCourse does not exist!\033[0m")
exit()
core下auth.py
# _*_ coding: utf-8 _*_
import os
import json
from core import accounts
#使用者認證
def access_login(user_data,log_obj):
'''
登陸函數，當登陸失敗超過三次，則退出
登陸成功之後，檢視這個人的身份，來确定進入那個視圖
:return: 如果使用者賬号密碼正确，則傳回使用者資料的字典
'''
retry_count = 0
while user_data['is_authenticated'] is not True and retry_count <3:
account = input('\033[34;1mplease input Administrator Acount:\033[0m').strip()
password = input('\033[34;1mplease input Administrator Password:\033[0m').strip()
#使用者賬号密碼正确，則傳回使用者資料的字典
auth = access_auth(account,password,log_obj)
if auth:
user_data['is_authenticated'] = True #使用者認證為True
user_data['account_id'] = account #使用者賬号ID為賬号名
return auth
retry_count +=1
else:
print("Account [%s] try logging too many times..." % account)
log_obj.error("Account [%s] try logging too many times..." % account)
exit()
def access_auth(account,password,log_obj):
'''
下面access_login調用access_auth方法，用于登陸
:param account: 使用者名
:param password: 密碼
:param log_obj:
:return:
'''
account_data = accounts.MyPickle.load_account(account)
if account_data.get('vip_password') is not None:
if account_data['vip_password'] == password:
log_obj.info("Account [%s] logging success" % account)
return account_data
else:
log_obj.error(" Password does not correct!")
print("\033[31;1m Password not correct!\033[0m")
else:
log_obj.error("Account or Password does not correct!")
print("\033[31;1mAccount or Passwordoes not correct!\033[0m")
core下db_handler.py
# _*_ coding: utf-8 _*_
'''處理與資料之間的互動，如果file_db_storage，傳回路徑'''
import pickle
import os
from conf import settings
def db_handler(conn_parms):
if conn_parms['engine'] == 'file_storage':
return file_db_handle(conn_parms)
def file_db_handle(conn_parms):
'''
對檔案路勁做文法分析
:param conn_parms:
:return:
'''
db_path = '%s/%s'%(conn_parms['path'],conn_parms['name'])
return db_path
core下logger.py
# _*_ coding: utf-8 _*_
'''操作所有的日志工作'''
import logging
from conf import settings
def logger(log_type):
#建立日志
logger = logging.getLogger(log_type)
logger.setLevel(settings.LOGIN_LEVEL)
#建立螢幕對象和設定等級debug
# ch = logging.StreamHandler()
# ch.setLevel(settings.LOGIN_LEVEL)
#建立檔案對象，給檔案對象設定等級
log_file = "%s/log/%s"%(settings.BASE_DIR,settings.LOGIN_TYPE[log_type])
fh = logging.FileHandler(log_file)
fh.setLevel(settings.LOGIN_LEVEL)
# 設定輸出對象格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
#把格式添加到配置中
# ch.setFormatter(formatter)
fh.setFormatter(formatter)
#把日志列印到指定的handler
# logger.addHandler(ch)
logger.addHandler(fh)
return logger
core下main.py
# _*_ coding: utf-8 _*_
from core import Manager
from core import Student
from core import Teacher
from conf import settings
from core import logger
from core import auth
import sys
#初始化賬戶資料
user_data = {
'account_id':None,
'is_authenticated':False,
'account_data':None
}
#系統日志記錄到檔案中
access_logger = logger.logger('system')
def interactive(msg,menu_dic):
exit_flag = False
while not exit_flag:
print(msg)
user_choice = input("please choice >>>>").strip()
if user_choice in menu_dic:
menu_dic[user_choice]()
else:
print("\033[31;1myou choice doesn't exist\033[0m")
def Student_view():
msg = '''\033[32;1m-------welcome to student manage view------
1 注冊新學生使用者
2 檢視上課記錄
3 檢視作業成績
4 退出
\033[0m'''
menu_dic = {
"1": Student.Student.resistered,
"2":Student.Student.find_classrecord,
"3":Student.Student.find_grade,
"4":logout,
}
interactive(msg,menu_dic)
def Teacher_view():
msg = '''\033[32;1m-------welcome to teacher manage view------
1 建立新講師
2 建立學生上課情況
3 建立學生考試成績
4 logout
\033[0m'''
menu_dic = {
"1":Teacher.Teacher.resistered,
"2":Teacher.Teacher.create_classrecord,
"3":Teacher.Teacher.create_grade,
"4":logout,
}
interactive(msg, menu_dic)
def Manager_view():
msg = '''\033[32;1m-------welcome to admin manage view------
1 建立講師
2 建立學生
3 建立學校
4 建立課程
5 檢視課程
6 檢視學校
7 建立班級
8 檢視班級
9 退出
\033[0m'''
menu_dic = {
"1":Manager.Manager.create_teacher,
"2":Manager.Manager.create_student,
"3":Manager.Manager.create_school,
"4": Manager.Manager.create_course,
"5": Manager.Manager.show_course,
"6":Manager.Manager.show_school,
"7": Manager.Manager.create_class,
"8": Manager.Manager.show_class,
"9": logout,
}
# login_judge()
interactive(msg, menu_dic)
#退出，寫簡單函數即可
def logout():
'''
退出登陸
:return:
'''
print("\033[32;1m-------Looking forward to your next visit-------\033[0m")
exit()
def begin():
'''
開始入口
:return:
'''
msg = '''\033[32;1m-------welcome to course selectionn system------
1 Student_system
2 Teacher_system
3 Manager_system
4 logout
\033[0m'''
menu_dic = {
"1":Student_view,
"2":Teacher_view,
"3":Manager_view,
"4":logout,
}
interactive(msg, menu_dic)
def login_judge():
# 調用認證子產品，傳回使用者檔案json.load後的字典，傳入access_logger日志對象
access_data = auth.access_login(user_data,access_logger)
if user_data['is_authenticated']: #如果使用者認證成功
user_data["account_data"] = access_data
core下Manager.py
# _*_ coding: utf-8 _*_
from core import Teacher
from core import Student
from core import accounts
from lib import Course
from lib import Classes
from lib import School
class Manager:
def __init__(self):
pass
@staticmethod
def create_student():
Student.Student.resistered()
@staticmethod
def create_teacher():
Teacher.Teacher.resistered()
@staticmethod
def create_course():
Course.Course.create_course()
@staticmethod
def show_course():
Course.Course.show_course()
@staticmethod
def create_class():
Classes.Classes.create_class()
@staticmethod
def show_class():
Classes.Classes.show_class()
@staticmethod
def create_school():
School.School.create_school()
@staticmethod
def show_school():
School.School.show_school()
core下Student.py
# _*_ coding: utf-8 _*_
'''
學員視圖，學員建立姓名，年齡，所報的班級，所報的學校等等
'''
from core import main
from core import accounts
from core import Manager
from lib import Course
class Student:
def __init__(self):
pass
#學生注冊
@staticmethod
def resistered():
student_dict = {}
print('\033[32;1m-------welcome to student registered system------\033[0m')
student_name = input("student_name >>>")
student_password = input("student_password >>>")
Manager.Manager.show_school()
student_school = input("student_school >>>")
Manager.Manager.show_class()
student_class = input("student_class >>>")
accounts.MyPickle.load_coursedata('course')
student_course = input("student_course >>>")
student_score = None
student_identity = 'student'
student_dict['account'] = student_name
student_dict['password'] = student_password
student_dict['school'] = student_school
student_dict['class'] = student_class
student_dict['course'] = student_course
student_dict['score'] = student_score
student_dict['identity'] = student_identity
print("\033[32;1m--------這是您登記的資訊，請檢視----------\033[0m")
print('\033[31;1m%s\033[0m'%student_dict)
accounts.MyPickle.save_account(student_dict)
#檢視上課記錄
@staticmethod
def find_classrecord():
'''上課記錄是老師給的'''
print('\033[32;1m-------welcome to Student system(find classrecord)------\033[0m')
name = 'class_record'
accounts.MyPickle.load_classrecord(name)
#檢視作業成績
@staticmethod
def find_grade():
'''成績是老師給的'''
print('\033[32;1m-------welcome to Student system(find classgrade)------\033[0m')
name = 'class_grade'
accounts.MyPickle.load_classgrade(name)
core下Teacher.py
# _*_ coding: utf-8 _*_
from core import accounts
from core import Manager
class Teacher:
def __init__(self):
pass
#講師注冊
@staticmethod
def resistered():
teacher_dict = {}
print('\033[32;1m-------welcome to teacher registered system------\033[0m')
teacher_name = input("teacher_name >>>")
teacher_password = input("teacher_password >>>")
Manager.Manager.show_school()
teacher_school = input("teacher_school >>>")
Manager.Manager.show_class()
teacher_class = input("teacher_class >>>")
teacher_identity = 'teacher'
teacher_dict['account'] = teacher_name
teacher_dict['password'] = teacher_password
teacher_dict['school'] = teacher_school
teacher_dict['class'] = teacher_class
teacher_dict['identity'] = teacher_identity
print("\033[32;1m--------這是您登記的資訊，請檢視----------\033[0m")
print('\033[31;1m%s\033[0m' % teacher_dict)
accounts.MyPickle.save_account(teacher_dict)
#建立上課記錄,想法是每一個人對應一個記錄，比如王某：8次
@staticmethod
def create_classrecord():
classrecord_dict = {}
print('\033[32;1m-------welcome to teacher system(create class_record)------\033[0m')
student_name = input("student_name >>>")
class_record = input("class_record >>>")
classrecord_dict[student_name] = class_record
name = 'class_record'
classrecord_dict = str(classrecord_dict)
accounts.MyPickle.save_classrecord(name,classrecord_dict)
#建立作業成績，想法是每一個人對應一個記錄，比如王某：98
@staticmethod
def create_grade():
classgrade_dict = {}
print('\033[32;1m-------welcome to teacher system(create class_grade)------\033[0m')
student_name = input("student_name >>>")
class_grade = input("class_grade >>>")
classgrade_dict[student_name] = class_grade
name = 'class_grade'
classgrade_dict = str(classgrade_dict)
accounts.MyPickle.save_classgrade(name,classgrade_dict)
8.4 db
db下accounts
(這是檔案，在這裡就不一一展示了)
8.5lib
lib下Classes
# _*_ coding: utf-8 _*_
from lib import Course
from core import accounts
from core import Manager
class Classes:
def __init__(self):
pass
@staticmethod
def create_class():
name = 'class'
print('\033[32;1m-------welcome to manage system(create class)------\033[0m')
class_data = accounts.MyPickle.load_class(name)
class_name = input("class_name >>>")
accounts.MyPickle.save_class(name,class_name)
@staticmethod
def show_class():
print('\033[32;1m-------welcome to Manager system(find class)------\033[0m')
name = 'class'
accounts.MyPickle.load_class(name)
lib下Course
# _*_ coding: utf-8 _*_
#建立一個課程類,包括課程名稱，課程周期，課程價格
from core import accounts
from core import Manager
class Course:
def __init__(self):
pass
@staticmethod
def create_course():
name = 'course'
print('\033[32;1m-------welcome to Manager system(create course)------\033[0m')
course_data = accounts.MyPickle.load_coursedata(name)
course_dict = {}
accounts.MyPickle.load_school('school')
course_school = input("The school of course：>>>")
course_name = input("course name：>>>")
course_period = input("course period：>>>")
course_prices = input("course prices：>>>")
course_dict["course_school"] = course_school
course_dict["course_name"] = course_name
course_dict["course_period"] = course_period
course_dict["course_prices"] = course_prices
print("\033[32;1m--------這是您建立課程的資訊，請檢視----------\033[0m")
print('\033[31;1m%s\033[0m' % course_dict)
accounts.MyPickle.save_course(course_dict)
accounts.MyPickle.save_coursedata(name, course_name)
@staticmethod
def show_course():
'''
輸入課程資訊
:return:
'''
print('\033[32;1m-------welcome to Manager system(find course)------\033[0m')
name = 'course'
accounts.MyPickle.load_coursedata(name)
course_name = input("請輸入要查找的課程名：>>>")
accounts.MyPickle.load_course(course_name)
lib下School
# _*_ coding: utf-8 _*_
from lib import Course
from core import accounts
class School:
def __init__(self):
pass
@staticmethod
def create_school():
name = 'school'
school_data = accounts.MyPickle.load_school(name)
print('\033[32;1m-------welcome to manage system(create school)------\033[0m')
school_name = input("school_name >>>")
accounts.MyPickle.save_school(name,school_name)
@staticmethod
def show_school():
print('\033[32;1m-------welcome to Manager system(find school)------\033[0m')
name = 'school'
accounts.MyPickle.load_school(name)
8.6log
system.log
2018-04-19 09:15:24,489 - system - ERROR - Account or Password does not correct!
2018-04-19 09:15:36,036 - system - ERROR - Account or Password does not correct!
2018-04-19 09:15:43,911 - system - ERROR - Account or Password does not correct!
2018-04-19 09:15:43,911 - system - ERROR - Account [admin] try logging too many times...
2018-04-19 09:20:48,536 - system - ERROR - Account or Password does not correct!
2018-04-19 09:23:00,911 - system - INFO - Account [admin] logging success
2018-04-19 09:29:27,238 - system - INFO - Account [admin] logging success
2018-04-19 09:40:13,110 - system - INFO - Account [admin] logging success
2018-04-19 10:02:58,567 - system - INFO - Account [admin] logging success
2018-04-19 10:03:16,395 - system - INFO - Account [admin] logging success
2018-04-20 13:57:36,289 - system - ERROR - Account or Password does not correct!
2018-04-20 13:58:19,360 - system - ERROR - Account or Password does not correct!
2018-04-20 13:58:52,241 - system - ERROR - Account or Password does not correct!
2018-04-20 14:00:03,168 - system - INFO - Account [admin] logging success
2018-04-20 14:00:43,360 - system - INFO - Account [admin] logging success
2018-04-20 14:01:50,831 - system - INFO - Account [admin] logging success
2018-04-20 14:02:24,279 - system - INFO - Account [admin] logging success
不經一番徹骨寒 怎得梅花撲鼻香