Python 约束 , 自定义异常 , 加密 , 日志

                约束                                 

约束 , 约束其派生类:  保证派生类中必须编写send方法 , 不然执行可能就会报错

Python中  语法:

 1 class BaseMessage(object):
 2     def send(self):
 3         """"
 4         必须继承BaseMessage,然后其中必须编写send方法, 用于完成具体业务
 5         """
 6         raise NotImplementedError(".send()必须被重新写")
 7         # raise Exception (".send(), 必须被重新写")  这种不专业 , 没有研究过低层, 及Javaa
 8     
 9 class Email(BaseMessage):
10     def send(self,x1):
11         """
12         必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
13         """
14         pass
15 
16 obj = Email()
17 obj.send(1)

Python中约束的方式 : 

有主动抛异常 (如上)    还有   抽象类和抽象方法:

总结 : 

• 什么是接口以及作用?
  • 　　接口是一种数据类型,主要用于约束派生类中必须实现指定的方法
  • 　　Python中不存在, Java和C#中存在
• Python中使用过什么来约束?
  • 　　抽象类 + 抽象方法  ,  编写上麻烦, 不常用
  • 　人为主动抛异常 
• 约束时 ,  抛异常是否可以用其他的?
  • 　　专业 : raise  NotImplementedError(".send()  必须被重写")
  •         不专业: raise  Exception(".send()  必须被重写")

应用场景 :

　　多个类 , 内部都必须有某些方法时 , 需要使用基类 + 异常进行约束

                           自定义异常                     

解释:  

　　上面定义已知异常类 ,   继承  Exception   类 , 下面接收该设置的已知异常类, 并可以设置返回结果 , 最后写一个接收未知异常  (Exception)  

例如 :

扫描二维码关注公众号，回复： 2985807 查看本文章

 1 # 自定义异常
 2 import os
 3 
 4 class ExistsError(Exception):
 5     pass
 6 
 7 class KeyInvalidError(Exception):
 8     pass
 9 
10 def func(path,prev):
11     """
12     去path路径的文件中，找到前缀为prev的一行数据，获取数据并返回给调用者。
13     1000, 成功
14     1001, 文件不存在
15     1002, 关键字为空
16     1003, 未知错误
17     ...
18 
19     :return:
20     """
21     response = {"code":1000,"data":None}
22     try:
23         if not os.path.exists(path):  # 判断路径是否存在
24             raise ExistsError()
25         if not prev:
26             raise KeyInvalidError()
27         
28         """
29         代码块
30         """
31     except ExistsError as e:
32         response['code'] = 1001
33         response['data'] = '文件不存在'
34     except KeyInvalidError as e:
35         response['code'] = 1002
36         response['data'] = '关键字为空'
37     except Exception as e:
38         response['code'] = 1003
39         response['data'] = '未知异常'
40     return response
41 print(func("E:\Python",""))

自定义异常例子

                         加密                       

引用 import  hashlib  模块   可以将字符串加密成密文

用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

一般用加密密码  防止数据库被盗 ,密码泄露   此加密无法解密

 1 import hashlib
 2 
 3 heshun = b"hehsun123456"  # 自定义添加的特有的加密
 4 
 5 def md5(pwd):
 6     # 初始化对象
 7     obj = hashlib.md5(heshun)
 8     # 写入加密字节
 9     obj.update(pwd.encode("utf-8"))
10     # 获取密文
11     return obj.hexdigest()

用于密码加密

例如:

 1 import hashlib
 2 
 3 SALT = b'heshun123456'
 4 
 5 def md5(pwd):
 6     # 实例化对象
 7     obj = hashlib.md5(SALT)
 8     # 写入要加密的字节
 9     obj.update(pwd.encode('utf-8'))
10     # 获取密文
11     return obj.hexdigest() 
12 
13 
14 user = input("请输入用户名:")
15 pwd = input("请输入密码:")
16 if user == 'qq123456' and md5(pwd) == '94394d9d8f30ed2dd8259819c60b9c54':
17     print('登录成功')
18 else:
19     print('登录失败')

                       日志                      

引用  logging   模块

用于便捷记录日志且线程安全的模块

1 , 单文件日志

import logging

logging.basicConfig(filename="rizhi.txt",
　　　format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',
                    level=10)

logging.debug("日志显示")
logging.info("日志显示")
logging.warning("日志显示")
logging.error("日志显示")
logging.critical("日志显示")

logging.log(10,"log")

filename = "路径"
format = "时间" - "用户" - "级别名称"-"路径"- "消息提示"
datefmt = '%Y-%m-%d %H:%M:%S %p'   #格式化时间
level = " 等级"    报错等级多少以上才显示

日志等级

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

注  :  只有[当前写等级] 大于等于[日志等级] 时 ,日志文件才被记录

日志记录格式:

多文件处理日志

对于上述记录日志的功能,只能将日志记录在单文件中,如果想要设置多个日志文件, logging.basicConfig 将无法完成, 需要自定义和日志操作对象.

# 定义文件
file_1_1 = logging.FileHandler('l1_1.log', 'a', encoding='utf-8')
fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s")
file_1_1.setFormatter(fmt)

file_1_2 = logging.FileHandler('l1_2.log', 'a', encoding='utf-8')
fmt = logging.Formatter()
file_1_2.setFormatter(fmt)

# 定义日志
logger1 = logging.Logger('s1', level=logging.ERROR)
logger1.addHandler(file_1_1)
logger1.addHandler(file_1_2)


# 写日志
logger1.critical('1111')

日志一

1 # 定义文件
2 file_2_1 = logging.FileHandler('l2_1.log', 'a')
3 fmt = logging.Formatter()
4 file_2_1.setFormatter(fmt)
5 
6 # 定义日志
7 logger2 = logging.Logger('s2', level=logging.INFO)
8 logger2.addHandler(file_2_1)

日志二

如上述创建的两个日志对象

• 当使用[logger1] 写日志时,会将相应的内容写入 l1_1.log 和 l1_2.log 文件中
• 当使用【logger2】写日志时，会将相应的内容写入 l2_1.log 文件中

将错误信息完全写入日志中

引用   traceback   模块

 1 import logging
 2 import traceback
 3 
 4 logging.basicConfig(filename="rizhi.txt",
 5   format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
 6                     datefmt='%Y-%m-%d %H:%M:%S %p',
 7                     level=10)
 8 
 9 def func():
10     try:
11         a = a +1
12     except Exception as e:
13         # 获取当前错误的堆栈信息
14         msg = traceback.format_exc()
15         logging.error(msg)
16 func()