python 面向对象之路 约束 自定义异常 多继承 (经典类,新式类(c3算法))

---恢复内容开始---

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)

抽象类，约束，约束继承它的派生类必须实现它其中的抽象方法。

abstact class Foo:

   def f1(self):
      print(1,3,4) 
      
   abstact def f2(self):pass

class Bar(Foo):
   def f2(self):
      print('111')

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

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 

接口以及作用
接口是一种数据类型,主要用于派生类中必须实现指定的方法
python中 不存在的   Java和c#中是存在的
python中使用过什么来约束
抽象类+抽象方法
约束时  抛出的异常是否可以用其他的

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

抽象类和抽象方法约束

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路径的文件中，找到前缀为prev的一行数据，获取数据并返回给调用者。
        1000,成功
        1001,文件不存在
        1002,关键字为空
        1003,未知错误
        ...
    :return:
    """
    response = {'code':1000,'data':None}
    try:
        if not os.path.exists(path):
            raise ExistsError()

        if not prev:
            raise KeyInvalidError()
        pass
    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 KeyError as obj:
    print(obj,1111)
except MyException as obj:
    print(obj,2222)
except Exception as obj:   知识点: 捕获异常
    print(obj,3333)

md5  加密  (关键字  撞库 , 加盐)   hashlib

# import hashlib
#
# SALT = b'2erer3asdfwerxdf34sdfsdfs90'

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


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

日志(logging)

为什么写日志(给开发人员看, 用于排查错误)

自定义日志

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

 日志文件个数

import logging

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

logging.error('x4')
logging.error('x5')

日志坚持写,可以帮助你更好地完成工作

面向对象多继承:
1.先找左边   再找右边

class A(object):
    pass


class B(object):
    def f1(self):
        print('B')


class C(A,B):
    pass

obj = C()

obj.f1() 

经典类和新式类
   py2:
      经典类
      新式类，如果自己或自己的前辈只要有人继承object，那么此类就是新式类。
   py3:
      新式类
   
   经典类和新式类的查找成员的顺序不一样。
      经典类，一条道走到黑（深度优先）。
      新式类，C3算法实现（python2.3更新时c3算法）。

class A(object):
    pass

class B(A):
    pass

class C(B):
    pass

class D(object):
    pass

class E(D,C):
    pass

class F(object):
    pass

class G(F):
    pass

class H(C,G):
    pass

class Foo(E,H):
    pass


# print(E.__mro__)
# print(H.__mro__)
"""
L(Foo + L(E)  + L(H) )



L(E) = E,D,C,B,A,object
L(H) = H,C,B,A,G,F,object

Foo = (object) + (G,F,object)
Foo,E,D,H,C,B,A,G,F,object
"""
print(Foo.__mro__)    

            Foo + (C,D,F,G) + (G,D,G,W) + (I,G,D,G,W) 
            
            Foo, I,B,
            获取第一个表头 和 其他表位进行比较
            不存在则拿走。
            如果存在，则放弃，然后获取第二个表的表头再次和其他表的表尾进行比较。

   简单：
      经典类，一条道走到黑（深度优先）。
      新式类，留个根。（科学C3算法）
      
   
   注意事项：
      super是遵循__mro__执行顺序。