python学习之路---day19--面向对象--约束

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　约束和异常
一：约束：
　　约束方法：（解释：就相当于在想项目中，先提前规划好框架和约定基本代码，像定义好调用的名字后，后面的名字只能用这个，用其他的
　　名字就会抛出异常。错误）

1：提取父类，然后再父类中定义好方法，在这个方法什么不用干，就抛出
一个异常，这样所有的子类必须重写这个方法，否则就会报错
2：使用原类来描述父类，在元类中给出一个抽象方法 这样子类就不得不给出抽象方法的具体、
方法的具体实现，可以起到约束的效果

　　001）：从实例理解

第一种约束方法：
提取父类，然后在父类中定义好方法，在这个方法什么不用干，就抛出一个异常，
这样所有的子类必须重写这个方法，否则就会报错

基本思想：相当于就是 一个 基本的程序，分为多个模块，然后分配给不同的人去做，但是每个人的代码习惯和取名习惯不一样
，在后面的总的模块合在一起，需要调用相同的功能时，名字不一样，从而造成有的模块没有调用到而产生异常

　　01)实例01：

class Base: #这个是用来约束后面不同成员的函数，强制子类不能乱起函数名字，必须是用login ，不然会报错

def login(self):
raise NotImplementedError ("子类没有实现继承")

class Normal(Base): #
def login(self):
print("游客")

class Member(Base):
def login(self): 这里这里将login（self）登陆名字写成 denglu(self) 后面的程序是执行不了的
print("吧务的登陆")
class Admin(Base):
def login(self):
print("管理员")

def login(obj):
print("准备")
obj.login()
print("主页进入 ")

n=Normal() #实例化对象
m=Member()
a=Admin()
login(n) #调用功能。这里如果的有的登陆名字写成 denglu(n) 后面的程序是执行不了的
login(m)
login(a)

　　002):第二约束方法：

2：使用原类来描述父类，在元类中给出一个抽象方法 这样子类就不得不给出抽象方法的具体、
方法的具体实现，可以起到约束的效果
基本思想： 写出抽象类和抽象方法，来约束后面的子类

实例02：

from abc import ABCMeta ,abstractmethod

class Base(metaclass=ABCMeta): #抽象类
#抽象类
@abstractmethod #
def login(self): #强制子类做xxx事
pass
def haha(self): #这个是抽象类里面的正常的方法，是可以有的，，怎么调用它呢？？？？？？？？
print("hahawowo o")

class Normal(Base):
pass
def login(self): #重写了父类的抽象方法
print("普通账号的登陆")
n=Normal()

原因时Base是一个抽象类，含有抽象方法，不允许创建实例对象
b=Base() #报错：TypeError: Can't instantiate abstract class Base with abstract methods login
b.haha() #报错：TypeError: Can't instantiate abstract class Base with abstract methods login
一个类如果全部都是抽象方法，这个类可以被接口，用来约束子类和规范子类

from abc import ABCMeta,abstractmethod #写抽象类需要引入抽象模块
class Animal(metaclass=ABCMeta):
@abstractmethod
def chi(self): #抽象概念
pass
class Cat(Animal):
def chi(self): #子类对抽象的内容给出具体的实现，重写
print("猫用嘴吃")
c=Cat()
c.chi()

a=Animal()
a.chi() #TypeError: Can't instantiate abstract class Animal with abstract methods chi

二：异常处理

001）：异常：程序在运行时出现了错误
002）：先认识异常：
def chu(a,b):
return a/b
ret=chu(3,0)
print(ret)
报错： ZeroDivisionError: division by zero
#我们知道除数是不能为0的，

解决异常：
try: .... except 运行xx代码，出现了错误就执行except 后面的代码
def chu(a,b):
return a/b
try:
ret=chu(3,0)
print(ret)
except Exception as e:
print("除数不能为0")
打印结果：除数不能为0

由python解释器来调用代码. 出现了错误. 系统会自动的产生一个叫异常的对象.
系统会尝试着把错误返回给调用方. 过程被称为:抛异常
我们通过try...except 可以吧系统产生的这个错误获取到. 过程叫捕获异常

　　异常处理实例：

import traceback
#计算a+b
def cul(a,b):
if (type(a) == int or type(a)==float) and (type(b)==int or type(b)==float):
return a+b
else:
# 在这里有两种方案. 1. 直接返回 , 2. 抛出异常
# # raise 抛出 Exception 错误和异常,所有错误的根
raise Exception("要的是整型和float型 ")

#捕获异常：

try:
print(cul(1,"是的")) #我们给其错误的信息看看
except Exception as e:
#获取到错误信息，我们需要访问堆栈信息
print(traceback.format_exc()) #获取堆栈信息
print("出现了错误")

有些错误是python 内部没有给我们里出来的，我们就需要自定义异常，但是
自定义异常会出现问题就是 pyhton 不会给出具体的记录，所以自定义异常的
异常名字要符合规范，要慎用
自定义异常实例：
class GenderException(Exception): #自定义性别异常
pass
class Person:
def __init__(self,name,gender):
self.name=name
self.gender=gender

def goto_nan_yushi(self):
if self.gender !="男":
raise GenderException("性别不对") #raise 这里就是给程序员看的，给其说明是哪里错误
else:
print("welcome")

#处理捕获异常
try:
p1=Person("张三","男")
p1.goto_nan_yushi()

p2=Person("李四","nv")
p2.goto_nan_yushi()

except GenderException as e:
print("进错了") #这里错误是给客户看的

except Exception as e:
print("其他原因你不能进去") #这里错误是给客户看的

四：日志处理：

import logging
filename: ⽂件名
format: 数据的格式化输出. 最终在⽇志⽂件中的样⼦
时间-名称-级别-模块: 错误信息
datefmt: 时间的格式
level: 错误的级别权重, 当错误的级别权重⼤于等于leval的时候才会写⼊⽂件
logging.basicConfig(filename='x1.log',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
level=30)
当前配置表示 0以上的分数会被写⼊⽂件
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0
logging.critical("我是critical") # 50分. 最贵的
logging.error("我是error") # 40分
logging.warning("我是warning")
logging.info("我是info")
logging.debug("我是debug")
logging.log(1, "我什么都不是")

import traceback
try:
print(1/0)
except Exception:
logging.error(traceback.format_exc()) # 用法
print("出错了")

import logging
# 创建⼀个操作⽇志的对象logger（依赖FileHandler）
# open()
file_handler = logging.FileHandler('zuo.log', 'a', encoding='utf-8')
file_handler.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s"))
logger1 = logging.Logger('qq', level=20)
logger1.addHandler(file_handler) # 把文件助手和日志对象绑定
logger1.error('我是A系统出错了') # 记录日志

# 再创建⼀个操作⽇志的对象logger（依赖FileHandler）
file_handler2 = logging.FileHandler('you.log', 'a', encoding='utf-8')
file_handler2.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s -%(levelname)s -%(module)s: %(message)s"))
logger2 = logging.Logger('B系统', level=20)
logger2.addHandler(file_handler2)

import traceback
try:
print(1/0)
except Exception:
logger2.critical(traceback.format_exc())
print("出错了. 请联系管理员")
print("程序继续执行")

from types import MethodType, FunctionType
class Foo:
@classmethod
def func1(self):
pass
@staticmethod
def func2(self):
pass
def func3(self):
pass

def func4(self):
pass

# obj = Foo()
# lst.append(obj.func4)
# for item in lst:
# print(isinstance(item, MethodType))