day25 Pyhton学习 约束和异常处理

一.类的约束

　　约束是对类的约束

　　有两种方法:

　　1.提取一个父类,在父类中给出一个方法,并且在方法中不给出任何代码,直接抛异常

class Base:
 　　def login(self):
 　　　　raise Exception("你没有实现login方法()")
class Normal(Base):
 　　def login(self):
 　　　　pass
class Member(Base):
 　　def denglu(self):
 　　　　pass
class Admin(Base):
 　　def login(self):
 　　　　pass

# 项目经理写的总入口
def login(obj):
 　　print("准备验证码.......")
 　　obj.login()
 　　print("进入主页.......")


n = Normal()
m = Member()
a = Admin()
login(n)
login(m) # 报错.
login(a)

在执行到login(m)的时候程序会报错. 原因是, 此时访问的login()是父类中的方法. 但是父类中的方法会抛出一个异常. 所以报错. 这样程序员就不得不写login方法了. 从而对子类进行了相应的约束.
在本示例中. 要注意. 我们抛出的是Exception异常. 而Exception是所有异常的根. 我们无法通过这个异常来判断出程序是因为什么报的错. 所以. 最好是换一个比较专业的错误信息. 最好是换成NotImplementError. 其含义是. "没有实现的错误". 这样程序员或者项目经理可以一目了然
的知道是什么错了. 就好比. 你犯错了. 我就告诉你犯错了. 你也不知道哪里错了. 这时我告诉你, 你xxx错了. 你改也好改不是?

　　2.写抽象类和抽象方法,这种方案相对来说比上一个麻烦一些.需要大家先引入一个抽象的概念,我们如果写一个方法,不知道方法的内部应该到底写什么,那这个方法就应该是一个抽象方法,如果一个类包含抽象方法,那么这个类一定是一个抽象类.抽象类是不能有

实例的

在python中编写一个抽象类比较麻烦. 需要引入abc模块中的ABCMeta和abstractmethod这两个内容. 来我们看一个例子.
from abc import ABCMeta, abstractmethod
# 类中包含了抽象方法. 那此时这个类就是个抽象类. 注意: 抽象类可以有普通方法
class IGame(metaclass=ABCMeta):
     # 一个游戏到底怎么玩儿? 你能形容? 流程能一样么?
     @abstractmethod
     def play(self):
          pass
     def turn_off(self):
          print("破B游戏不玩了, 脱坑了")
class DNFGame(IGame):
     # 子类必须实现父类中的抽象方法. 否则子类也是抽象类
     def play(self):
         print("dnf的玩儿法")
# g = IGame() # 抽象类不能创建对象
dg = DNFGame()
dg.play()
通过代码我们能发现. 这里的IGame对DNFGame进行了约束. 换句话说. 父类对子类进行了约束    

接下来. 继续解决我们一开始的问题.
from abc import ABCMeta, abstractmethod
class Base(metaclass=ABCMeta):
     @abstractmethod
     def login(self):
            pass
class Normal(Base):
     def login(self):
         pass
class Member(Base):
     def denglu(self): # 这个就没用了
             pass
     def login(self): # 子类对父类进行实现
             pass
class Admin(Base):
     def login(self):
             pass
# 项目经理写的总入口
def login(obj):
     print("准备验证码.......")
     obj.login()
     print("进入主页.......")
n = Normal()
m = Member()
a = Admin()
login(n)
login(m)
login(a)

 总结: 约束. 其实就是父类对子类进行约束. 子类必须要写xxx方法. 在python中约束的方式和方法有两种:
        1. 使用抽象类和抽象方法, 由于该方案来源是java和c#. 所以使用频率还是很少的
        2. 使用人为抛出异常的方案. 并且尽量抛出的NotImplementError. 这样比较专业, 而且错误比较明确.(推荐)

二.异常处理

　　什么是异常?异常是程序在运行过程中产生的错误,如果程序出现了异常,怎么处理呢?

def chu(a, b):
         return a/b
try:
     ret = chu(10, 0)
     print(ret)
except Exception as e:
      print("除数不能是0")
结果:
除数不能是0
     那try...except是什么意思呢? 尝试着运行xxxxx代码. 出现了错误. 就执行except后面的代码. 在这个过程中. 当代码出现错误的时候. 系统会产生一个异常对象. 然后这个异常会向外抛. 被except拦截. 并把接收到的异常对象赋值给e. 这里的e就是异常对象. 那这里的
Exception是什么?Exception是所有异常的基类, 也就是异常的跟. 换句话说. 所有的错误都是Exception的子类对象. 我们看到的ZeroDivisionError 其实就是Exception的子类. 那这样写好像有点问题. Exception表示所有的错误. 太笼统了. 所有的错误都会被认为是Exception.
当程序中出现多种错误的时候, 就不好分类了, 最好是出什么异常就用什么来处理. 这样就更加合理了.所以在try...execpt语句中. 还可以写更多的except.

给出一个完整的异常处理方法(语法):

try:
 '''操作'''
except Exception as e:
 '''异常的父类，可以捕获所有的异常'''
else:
 '''保护不抛出异常的代码, 当try中无异常的时候执⾏'''
finally:
 '''最后总是要执行我'''

解读: 程序先执行操作, 然后如果出错了会走except中的代码. 如果不出错, 执行else中的代码. 不论出不出错. 最后都要执行finally中的语句. 一般我们用try...except就够用了. 顶多加上finally. finally一般用来作为收尾工作.

def add(a, b):
     '''
      我传递两个整数. 我帮你计算两个数的和
     :param :param a:
     :param :param b:
     :return :return:
     '''
     if not type(a) == int and not type(b) == int:
     # 当程序运行到这句话的时候. 整个函数的调用会被中断. 并向外抛出一个异常.
             raise Exception("不是整数, 朕不能帮你搞定这么复杂的运算.")
     return a + b
# 如果调用方不处理异常. 那产生的错误将会继续向外抛. 最后就抛给了用户
# add("你好", "我叫赛利亚")
# 如果调用方处理了异常. 那么错误就不会丢给用户. 程序也能正常进行
try:
     add("胡辣汤", "滋滋冒油的大腰子")
except Exception as e:
     print("报错了.自己处理去吧")

当程序运行到raise. 程序会被中断. 并实例化后面的异常对象. 抛给调用方. 如果调用方不处理. 则会把错误继续向上抛出. 最终抛给用户. 如果调用方处理了异常. 那程序可以正常的进行执行.

自定义异常: 非常简单. 只要你的类继承了Exception类. 那你的类就是一个异常类. 就这么简单.

# 继承Exception. 那这个类就是一个异常类
class GenderError(Exception):
         pass
class Person:

     def __init__(self, name, gender):
         self.name = name
         self.gender = gender

def nan_zao_tang_xi_zao(person):
     if person.gender != "男":
         raise GenderError("性别不对. 这里是男澡堂⼦")
p1 = Person("alex", "男")
p2 = Person("eggon", "蛋")

# nan_zao_tang_xi_zao(p1)
# nan_zao_tang_xi_zao(p2) # 报错. 会抛出一个异常: GenderError

# 处理异常
try:
     nan_zao_tang_xi_zao(p1)
     nan_zao_tang_xi_zao(p2)
except GenderError as e:
     print(e) # 性别不对, 这里是男澡堂子
except Exception as e:
     print("反正报错了")

如果是真的报错了. 我们在调试的时候, 最好是能看到错误源自于哪里? 怎么办呢? 需要引入另一个模块traceback. 这个模块可以获取到我们每个方法的调用信息. 又被成为堆栈信息. 这个信息对我们拍错是很有帮助的.

import traceback
# 继承Exception. 那这个类就是一个异常类
class GenderError(Exception):
      pass
class Person:
  def __init__(self, name, gender):
     self.name = name
     self.gender = gender
def nan_zao_tang_xi_zao(person):
 if person.gender != "男":
    raise GenderError("性别不对. 这里是男澡堂子")
p1 = Person("alex", "男")
p2 = Person("eggon", "蛋")
# nan_zao_tang_xi_zao(p1)
# nan_zao_tang_xi_zao(p2) # 报错. 会抛出一个异常: GenderError
# 处理异常
try:
  nan_zao_tang_xi_zao(p1)
  nan_zao_tang_xi_zao(p2)
except GenderError as e:
  val = traceback.format_exc() # 获取到堆栈信息
  print(e) # 性别不对. 这里是男澡堂子
  print(val)
except Exception as e:
  print("反正报错了")
#性别不对. 这里是男澡堂子
Traceback (most recent call last):
  File "D:/python_qishi/day021练习/练习.py", line 66, in <module>
    nan_zao_tang_xi_zao(p2)
  File "D:/python_qishi/day021练习/练习.py", line 58, in nan_zao_tang_xi_zao
    raise GenderError("性别不对. 这里是男澡堂子")
GenderError: 性别不对. 这里是男澡堂子

当测试代码的时候把堆栈信息打印出来. 但是当到了线上的生产环境的时候把这个堆栈去掉即可.