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

 一丶约束

　　当我们编写项目时会创建很多个类,来实现很多个功能,最后又需要把这些类都联系成一个,我们就需要来约束一下那些类中的方法,把需要联系的约束成一个方法.

class BaseMessage(object):
    def send(self,x1):
        """
        必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
        """
        raise NotImplementedError(".send() 必须被重写.")

class Email(BaseMessage):
    def send(self,x1):
        """
        必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
        """
        pass
obj = Email()
obj.send(1)

 

 　　Email类继承了BaseMessage,所以Email类中必须有send方法,否则就会报错,我们用这样的来约束类 编写.

示例:

class BaseMessage(object):
    def send(self):
        """
        必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
        """
        raise Exception()

class Email(BaseMessage):
    def send(self):
        pass # 发送邮件

    def f1(self):
        pass

    def f2(self):
        pass
class Wechat(BaseMessage):
    def send(self):
        pass # 发送微信

    def f1(self):
        pass

    def f2(self):
        pass
class Msg(BaseMessage):
    def send(self):
        pass # 发送短信

    def f1(self):
        pass

    def f2(self):
        pass


def func(arg):
    """
    报警通知的功能
    """
    arg.send()


obj = Msg()
func(obj)

 

 　　抽象类和抽象方法约束:

from abc import ABCMeta,abstractmethod

class Base(metaclass=ABCMeta): # 抽象类

    def f1(self):
        print(123)

    @abstractmethod
    def f2(self):   # 抽象方法
        pass

class Foo(Base):

    def f2(self):
        print(666)

obj = Foo()
obj.f1()

　　其它语言中的接口:

　　　　接口，接口中不允许在方法内部写代码，只能约束继承它的类必须实现接口中定义的所有方法。

伪代码:
interface IFoo:

    def f1(self,x1):pass

    def f2(self,x1):pass

interface IBar:

    def f3(self,x1):pass

    def f4(self,x1):pass

class Foo(IFoo,IBar):# 实现了2个接口

    def f1(self,x1):pass

    def f2(self,x1):pass

    def f3(self,x1):pass

    def f4(self,x1):pass

 

 　　总结:

　　　　1.什么是接口以及其作用?

　　　　　　接口是一种数据类型,主要用于约束派生类中必须实现指定的方法.

　　　　　　python中不存在,Java和C#中是存在的

　　　　2.Python中使用过什么来约束呢?

　　　　　　抽象类+抽象方法,在编写上会很麻烦.

　　　　　　人为主动抛出异常

　　　　3.约束时,抛出的异常是否可以用其它的?

　　　　　　不专业:  raise Exception(".send() 必须被重写.")

 　　　　　　专业：raise NotImplementedError(".send() 必须被重写.")

　

应用场景:

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

　　

二丶自定义异常

　　有时我们需要使程序跟我们预定的流程走时,我们可以自定义异常来约束它.

# 知识点：如何自定义异常类？
class MyException(Exception):
    def __init__(self,code,msg):
        self.code = code
        self.msg = msg
try:
    # 知识点：主动抛出异常
    raise MyException(1000,'操作异常')

except KeyError as obj:
    print(obj,1111)
except MyException as obj: # 知识点：捕获异常
    print(obj,2222)
except Exception as obj:
    print(obj,3333)

 

 三丶加密

 　　以前我们编写注册程序时,都是以明文的方式将密码写入文档的,这样很不安全,一旦文档被盗取,将会发生不可估量的损失.我们就需要将密码存储时进行加密,然后将密文存入文档,因为密文是无法被反解的,这样当被人拿到文档中的密文时也无法破解我们用户的真正的密码信息.

import hashlib
def md5(pwd):
    # 实例化对象
    obj = hashlib.md5()
    # 写入要加密的字节
    obj.update(pwd.encode('utf-8'))
    # 获取密文
    return obj.hexdigest()

user = input("请输入用户名:")
pwd = input("请输入密码:")
print(md5(pwd)) #21232f297a57a5a743894a0e4a801fc3

　　我们编写登录程序时又需要把密码从文档中拿出来,但是拿到的是密文,密文又没法反解,我们应该怎么验证用户的密码呢?我们可以把用户输入的密码用同样的方式加密一遍,然后把加密的密码跟从文档读出来的密码密文比较,相等时登陆成功

import hashlib
def md5(pwd):
    # 实例化对象
    obj = hashlib.md5()
    # 写入要加密的字节
    obj.update(pwd.encode('utf-8'))
    # 获取密文
    return obj.hexdigest()

user = input("请输入用户名:")
pwd = input("请输入密码:")
if user == 'oldboy' and md5(pwd) == '21232f297a57a5a743894a0e4a801fc3':
    print('登录成功')
else:
    print('登录失败')

 

 

　　密码加密后虽然说是无法反解的,那为什么有人能破解呢?其实他们用大量字段段加密后的密文来跟我们的密文把比较来获取加密前的内容,我们可以防止这样的事情发生,可以在密码加密时再加严一层.

SALT = b'2erer3asdfwerxdf34sdfsdfs90'

import hashlib
def md5(pwd):
    # 实例化对象
    obj = hashlib.md5(SALT)
    # 写入要加密的字节
    obj.update(pwd.encode('utf-8'))
    # 获取密文
    return obj.hexdigest()

user = input("请输入用户名:")
pwd = input("请输入密码:")       #21232f297a57a5a743894a0e4a801fc3
if user == 'oldboy' and md5(pwd) == 'c5395258d82599e5f1bec3be1e4dea4a':
    print('登录成功')
else:
    print('登录失败')

 

 

　　这样,同样的密码,但是加密后的结果不一样,那些人是无法通过撞库撞出来真正的密码的,密码的安全性就会大大提高

四丶日志

　　当我们程序推广给用户时,用户并不知道我们程序应该遵循怎样的运行规则,就有很大的几率产生错误信息,当他们向我们反馈时,我们又不知道哪里错了,这里就需要一个日志文件来把用户的错误都记录下来,方便我们知道哪里错了.

import logging

logger = logging.basicConfig(filename='rizhi.txt',
                             format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                             datefmt='%Y-%m-%d %H:%M:%S',
                             level=30)　　#level 将大于等于30的错误级别写入日志中
logging.debug('x1') # 10
logging.info('x2')  # 20
logging.warning('x3') # 30
logging.error('x4')    # 40
logging.critical('x5') # 50
logging.log(10,'x6')

 

　　如何将错误信息具体到哪一行来写到日志中呢?

import logging

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

def func():
    try:
        a = a +1
    except Exception as e:
        # 获取当前错误的堆栈信息
        msg = traceback.format_exc()
        logging.error(msg)
func()

 

　　当我们要将不同的错误信息写入不同的文件中呢?

import logging

# 创建一个操作日志的对象logger（依赖FileHandler）
file_handler = logging.FileHandler('l1.log', 'a', encoding='utf-8')
file_handler.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s"))

logger1 = logging.Logger('s1', level=logging.ERROR)
logger1.addHandler(file_handler)

logger1.error('123123123')



# 在创建一个操作日志的对象logger（依赖FileHandler）
file_handler2 = logging.FileHandler('l2.log', 'a', encoding='utf-8')
file_handler2.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s"))

logger2 = logging.Logger('s2', level=logging.ERROR)
logger2.addHandler(file_handler2)

logger2.error('666')