day 018 面向对象--约束和异常处理

2022-10-21 11:45:04

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

主要内容;

类的约束
异常处理
自定义异常
MD5加密
日志

一类的约束 (约束是对类的约束,)

看个例子:

这是领导分配给每个人的项目,要求每人写个功能结果如下:

例子1

class Normal: # 张三, 普通⼈人登录

    def login(self):

         pass

class Member: # 李李四, 会员登录

    def denglu(self):

        pass

class Admin: # 王五, 管理理员登录

    def login(self):

        pass

现李四写的你调用不了

那么怎么处理这样的问题:

在python中有两种方法

1 提取父类,然后在父类中定义好方法,这个方法什么都不用干,就抛一个异常就可以了,

这样所有的子类都必须重写这个方法.否则,访问就会报做

2使用元类来描述父类,在元类中给出一个抽象方法,这样子就不得不给出抽象方法的具体实现,也可以提起约束的效果

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

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. 其含义是. "没有实现的错误". 这样程序员或者项目经理可以⼀目
了然的知道是什么错了

第二套方案:

写抽象类和抽象⽅法. 这种方案相对来说比上一个麻烦一些. 需要给大家先
引入⼀个抽象的概念

比如. 你看看一些抽象派的画作. 在现实中是不

存在的. 也就无法建立实例对象与之相对应. 所以抽象类无法创建对象. 创建对象的时候会报
错.

在Python中编写一个抽象类比较麻烦,要引入abc模块中的ABCMeta和absstractmethod这两个内容.

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进行了约束. 换句话说. ⽗类对子类进

行了约束.

总结: 约束. 其实就是⽗类对子类进行约束. 子类必须要写xxx⽅法. 在python中约束的
方式和方法有两种:

1. 使用抽象类和抽象方法, 由于该⽅案来源是java和c#. 所以使用频率还是很少的
2. 使⽤⼈为抛出异常的⽅案. 并且尽量抛出的是NotImplementError. 这样比较专
业, 而且错误比较明确.(推荐)

二异常处理(程序在运行过程中出现的错误)

看简单异常例子:

def chu(a, b):

    return a/b

try:

    ret = chu(, )

    print(ret)

except Exception as e:

    print('整数不能是0')

那try...except是什么意思呢? 尝试着运行xxxxx代码. 出现了错误. 就执行except后面的
代码. 在这个过程中. 当代码出现错误的时候. 系统会产生一个异常对象. 然后这个异常会向
外抛. 被except拦截. 并把接收到的异常对象赋值给e. 那这里的e就是异常对象. 那这里的
Exception是什么? Exception是所有异常的基类, 也就是异常的跟. 换句话说. 所有的错误都
是Exception的子类对象. 我们看到的ZeroDivisionError 其实就是Exception的子类. 那这样
写好像有点⼉儿问题撒. Exception表示所有的错误. 太笼统了. 所有的错误都会被认为是Exception.
当程序中出现多种错误的时候, 就不好分类了, 最好是出什么异常就⽤什么来处理. 这样就更加合理了.
所以在try...execpt语句中. 还可以写更多的except

try:

    print("各种操作....")

except ZeroDivisionError as e:

    print("除数不能是0")

except FileNotFoundError as e:

    print("⽂件不存在")

except Exception as e:

    print("其他错误")

完整的异常处语法:

try:

    '''操作'''

except Exception as e:

    '''异常的父类，可以捕获所有的异常'''

else:

    '''保护不抛出异常的代码, 当try中⽆无异常的时候执行'''

finally:

    '''最后总是要执⾏行我'''

代码. 不论处不出错. 最后都要执行finally中的语句. 一般我们用try...except就够用了. 顶多
加上finally. finally一般用来作为收尾工作.

上面是处理异常. 我们在执行代码的过程中如果出现了一些条件上的不对等. 根本不符
合我的代码逻辑. 比如. 参数. 我要求你传递一个数字. 你非得传递一个字符串. 那对不起. 我
没办法帮你处理. 那如何通知你呢? 两个方案.
方案一. 直接返回即可. 我不管你还不行么?
方案二. 抛出一个异常. 告诉你. 我不好惹. 乖乖的听话.
第一种方案是我们之前写代码经常用到的⽅方案. 但这种方案并不够好. 无法起到警示作用. 所
以. 以后的代码中如果出现了类似的问题. 直接抛一个错误出去. 那怎么抛呢? 我们要用到
raise关键字

def add(a, b):

    '''

    给我传递两个整数. 我帮你计算两个数的和

    ::param a:

    ::param b:

    :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类,那你的类就是一个异常类,)

上例子: 写一个男澡堂子程序,那这时候来个女的,怎么办, 那就得抛出一个性别异常.

继承Exceptinon.那就是一个异常类

import traceback

class GenderEttor(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 GenderEttor('性别不对')

p1 =person('李四','男')

p2=person('张三','n')

nan_zao_tang_xi_zao(p2)  # 报错 .会抛出一个错误 GenderError

nan_zao_tang_xi_zao((p1))

# 处理异常

try:

    nan_zao_tang_xi_zao(p1)

    nan_zao_tang_xi_zao(p2)

except  GenderEttor  as e :

val = traceback.format_exc()  # 获取到堆栈信

print(e)

print(val)

except Exception as e:

print("报错")

上边我们虽然是报错了但是看不到错误源在哪里,想要看到那就另外引入一个模块 traceback

这个模块可以取到我们每个地方的调用信息,

又被称为堆栈信息

搞定了. 这样我们就能收放⾃如了. 当测试代码的时候把堆栈信息打印出来. 但是当到了
线上的生产环境的时候把这个堆栈去掉即可

四 MD5加密

在python中我们不需要⼿手写
这一套算法. 只需要引入一个叫hashlib的模块就能搞定MD5的加密工作

MD5是⼀一种不可逆的加密算法.

防止撞库 (加盐)

import hashlib

obj = hashlib.md5(b"fjlksajflkjasfsalwer123dfskjf") # 加盐

obj.update("alex".encode("utf-8")) # 加密的必须是字节

miwen = obj.hexdigest()

print(miwen) # 99fca4b872fa901aac30c3e952ca786d

具体应用注册:

 注册的时候. 用md5进行加密. 存储的是加密后的密文

# username = input("请输入用户名")

# password = input("请输入密码")

# # cun = my_md5(password)

# # print(cun) # alex 26adff81aa6778d26999b95ddc0e50b2

# if username == "alex" and my_md5(password) == "26adff81aa6778d26999b95ddc0e50b2":

#     print("登录成功")

# else:

#     print("登录失败")

五日志 (记录不必现BUG)

导入longing模块
简单配置下longing
出现异常的时候(except),向日志里写错误信息

import logging

logging.basicConfig(filename='app.log', # 文件名

                    format='%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s',

                    datefmt='%Y-%m-%d %H:%M:%S',

                    level=40)    # level 设置级别. 当你的信息的级别>=level的时候才会写入日志文件, 默认30

CRITICAL = 50

FATAL = CRITICAL

ERROR = 40

WARNING = 30

WARN = WARNING

INFO = 20

DEBUG = 10

NOTSET = 0

# 写日志

logging.critical("我是critical")

logging.error("我是error")

logging.warning("我是警告")

logging.info("我是基本信息")

logging.debug("我是调试")

logging.log(2, "我是自定义")

import traceback

最后, 如果你系统中想要把日志⽂文件分开. 比如. 一个大项⽬, 有两个子系统, 那两个子系

统要分开记录日志. 方便调试. 那怎么办呢? 注意. 用上面的basicConfig是搞不定的. 我们要
借助⽂件助手(FileHandler), 来帮我们完成日志的分开记录

# 多文件日志处理

# 创建⼀个操作⽇志的对象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('A', level=40)

logger1.addHandler(file_handler)

# 记录日志

logger1.error('我是A系统')

# 再创建⼀个操作⽇志的对象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('B', level=40)

logger2.addHandler(file_handler2)

# 记录日志

logger2.error('我是B系统')

多文件处理日志

码农公寓

相关文章