面向对象5

1.约束

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)

抽象类和抽象方法的约束

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()

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

抽象类的作用:约束继承它的派生类必须实现它其中的方法

抽象方法的作用:约束继承此抽象方法的类的派生类必须实现这个抽象方法

抽象类加抽象方法和接口的区别:

　　接口中不允许写代码,只能约束继承它的类中必须实现指定的方法

　　抽象类加抽象方法中可以写代码,约束继承抽象类的派生类中必须实现指定的抽象方法

2.异常处理

import os

class ExistsError(Exception):
    pass

class KeyInvalidError(Exception):
    pass

def new_func(path,prev):
    """
    去path路径的文件中,找到前缀为iprev的一行数据,获取数据并返回给调用者
    1000,成功
    1001,文件不存在
    1002,关键字为空
    1003,未知错误
    """
    reponse = {'code':1000,'data':None}

    try:
        if not os.path.exists(path):
            raise ExistsError()
        if not prev:
            raise KeyInvalidError()

    except ExistsError as e:
        response['code'] = 1001
        response['data'] = "文件不存在"
    except KeyInvalidError as e:
        response['code'] = 1002
        response['data'] = '关键字为空'
    except Exception as e:
        response['code'] = 1003
        response['data'] = '未知错误'
    return response

自定义异常:

class MyException(Exception):
    def __init__(self,code,msg):
        self.code = code
        self.msg = msg

try:
    raise MyException(1000,'操作异常')

except MyException as obj:
    print(obj.code,obj.msg)


class MyException(Exception):
    def __init(self,code,msg):
        self.code = code
        self.msg = msg

try:
    raise MyException(1000,'操作异常')
except KeyError as obj:
    print(obj,111)
except MyException as obj:
    print(obj,222)
except Exception as obj:
    print(obj,333)

3.加密

import hashlib

def md5(s):
    salt = 'efg'
    s = s + salt　　#加盐
    md = hashlib.md5()
    md.update(s.encode("utf-8"))
    return md.hexdigest()
print(md5("abcd"))

4.日志

配置logging基本的设置,然后在控制台输出日志

import logging
logging.basicConfig(level = logging.INFO,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")

运行时,在控制台输出:

　　

2018-09-01 17:21:44,389 - __main__ - INFO - Start print log
2018-09-01 17:21:44,389 - __main__ - WARNING - Something maybe fail.
2018-09-01 17:21:44,389 - __main__ - INFO - Finish

　　logging中可以选择很多消息级别,如debug,info,warning,error以及critical.通过赋予logger或者handler不同的级别,开发者就可以只输出错误信息到特定的记录文件,或者在调试时只记录调试信息

参数的作用:

%(levelno)s：打印日志级别的数值
%(levelname)s：打印日志级别的名称
%(pathname)s：打印当前执行程序的路径，其实就是sys.argv[0]
%(filename)s：打印当前执行程序名
%(funcName)s：打印日志的当前函数
%(lineno)d：打印日志的当前行号
%(asctime)s：打印日志的时间
%(thread)d：打印线程ID
%(threadName)s：打印线程名称
%(process)d：打印进程ID
%(message)s：打印日志信息
将日志写入文件:
　　

import logging
logger = logging.getLogger(__name__)
logger.setLevel(level = logging.INFO)
handler = logging.FileHandler("log.txt")
handler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)

logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")

log.txt文件中的日志数据为:

2018-09-01 17:24:45,075 - __main__ - INFO - Start print log
2018-09-01 17:24:45,076 - __main__ - WARNING - Something maybe fail.
2018-09-01 17:24:45,076 - __main__ - INFO - Finish


如果要自定义日志的个数:

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')

这样就生成了两个日志,

l1.log中写入

2018-09-01 17:28:01,195 - s1 - ERROR -test0:  123123123
l2.log中写入:

2018-09-01 17:28:01,196 - s2 - ERROR -test0:  666