面向对象高级

标签：rop   资源   一句话   dex   停止   一些事   exception   ror   异常处理   

格式化方法与析构方法

class A:
    def __init__(self, name, age):
        self.name = name
        self.age = age
?
    # 格式化方法：在外界打印该类对象是被调用
    # 格式化外界直接打印该类对象的字符串表示结果
    def __str__(self): 
        # return ‘abc‘  # 外界打印A类的对象，都打印 字符串 abc
        # return super().__str__()  # 系统默认的在父类中返回的是对象存放的地址信息
        return ‘<name:%s | age:%s>‘ % (self.name, self.age)  # 根据对象实际的属性格式化具体的输出内容
?
    # 析构方法：在对象被消耗的那一刹那被调用，在被消耗前可以做一些事情
    def __del__(self):
        # del会在self代表的对象被消耗的时候被调用
        # 我们可以在析构函数中释放该对象持有的其他资源，
        # 或者将一些持有资源持久化(保存到文件或数据库中)
        del self.name  # 也可以将name存起来
?
a = A(‘老王‘, 88)
print(a, type(a))
?
import time
time.sleep(5)
?
print(‘文件马上执行完毕，a就会被销毁‘)

?

了解

class B:
    # 了解：对象.语法的内部实现
    def __setattr__(self, key, value):
        self.__dict__[key] = value  # 系统默认实现，在名称空间添加名字
        # self.__dict__[key] = value.lower()  # 可以自定义处理一些内容
?
    # 了了解：将对象添加属性的方式可以同字典形式
    def __setitem__(self, key, value):
        self.__dict__[key] = value
        
b = B()
# 设置
b.name = ‘BBB‘  # 内部走的是 __setattr__
b[‘age‘] = 18  # 内部走的是 __setitem__
?
# 访问
print(b.name)
print(b.age)

反射

# 反射：通过字符串与类及类的对象的属性(方法)建立关联
class A:
    num = 10
print(hasattr(A, ‘num‘))
res = getattr(A, ‘num‘, ‘默认值‘)
print(res)
delattr(A, ‘num‘)
print(setattr(A, ‘tag‘, 10))
# 类的属性类来操作
?
?
class B:
    def __init__(self, name):
        self.name = name
print(hasattr(b, ‘name‘))
print(getattr(b, ‘name‘, ‘对象的属性类不能获取‘))
delattr(b, ‘name‘)
print(setattr(b, ‘age‘, 18))
# 对象的属性对象来操作
?
?
class C:
    def fn(self):
        print(‘fn‘)
?
    @classmethod
    def func(cls):
        print(‘func‘)
?
fn = getattr(C, ‘fn‘)
c = C()
fn(c)  # 类获取对象方法调用时传入具体的对象
?
obj_fn = getattr(c, ‘fn‘)  
obj_fn()  # 对象获取对象方法调用时不用传参
?
func = getattr(C, ‘func‘)
func()  # 类获取类方法调用时不需要传入参数
?

异常：程序运行时的错误

# 程序中的异常处理机制：
# 1.程序中的所有异常都会被处理
# 2.程序中的所有异常都需要手动处理
# 3.如果没有手动处理异常，异常会交给Python解释器处理
#       -- 处理的方式就是打印异常信息，并停止接收器
?
?
# 异常信息的三部分：
# 1.异常的追踪信息：提示错误位置
# 2.异常的类型：告知处理异常应该捕获什么类型
# 3.异常的内容：告知错误信息
?
?
# 处理异常的语法：
‘‘‘
try:
    # 会出现异常的代码块
except (异常类型1, 异常类型2) as 异常别名:
    # 异常处理逻辑
else:
    # 没有出现异常会执行该分支
finally:
    # 无论是否出现异常都会执行该分支
‘‘‘

异常语法

# 将可能出现异常的代码放在try分支进行检测
#       -- 如果不出现异常，正常执行内部所有代码
#       -- 如果出现异常会进入except分支
?
# part1
# 1.建议大家对异常处理时，一次只处理一个异常
try:
    print(asdsdsdsdsdsdsdsdsdsdsdsdsd)  # NameError
except NameError:  # except 后跟异常类型，如果不需要查看异常信息，可以省略异常信息
    print(‘出现了NameError异常‘)
?
try:
    ls = [1, 2, 3, 4, 5]
    print(ls[10])  # IndexError
except IndexError as e:  # 如果想知道异常信息，用别名接收
    print(‘出现了IndexError异常: %s‘ % e)
?
# part2
# 2.如果无法避免一句话或是一个完整的代码结构会出现多个可能的异常，需要在一个try中提供多个except
# ls = [1, 2, 3, 4, 5]
ls = (1, 2, 3, 4, 5, 6)
# try:
#     print(ls[5])  # IndexError
#     ls.append(10)  # AttributeError
# except IndexError as e:
#     print(‘出现了IndexError异常: %s‘ % e)
# except AttributeError as e:
#     print(‘出现了AttributeError异常: %s‘ % e)
try:
    print(ls[5])  # IndexError
    ls.append(10)  # AttributeError
except (AttributeError, IndexError) as e:
    print(‘出现了异常: %s‘ % e)
?
?
print(‘===============================‘)
?
# part3
# 3.有些异常提前无法明确，或是压根没有明确的必要，可以捕获异常的父类异常
ls = [1, 2, 3, 4, 5]
# ls = (1, 2, 3, 4, 5, 6)
try:
    print(ls[5])  # IndexError
    ls.append(10)  # AttributeError
except Exception as e:  # 可以通过多态的应用，捕获父类，只要抛出的是该父类的子类异常，均可以被捕获
    print(‘出现了异常: %s‘ % e)
?
# BaseException：所有异常的基类  |  Exception：常规错误的基类
?
?
# part4
# 4.了了解 - try语法的else分支：当try检测的代码块没有出现异常，才会走else分支
try:
    print(aaaa)
except Exception as e:
    print(‘出现了异常‘, e)
else:
    print(‘没有异常‘)
?
?
# part5
# 5.finally：无论是否出现异常都会执行该分支
try:
    f = open(‘1.txt‘, ‘w‘, encoding=‘utf-8‘)
    f.write(b‘123‘)
except Exception as e:
    print(‘出现了异常‘, e)
finally:
    print(‘无论是否出现异常都会执行该分支‘)
    f.close()  # 文件只要打开，不管操作是否出现异常，都需要释放文件资源
?

自定义异常

# 自定义异常的目的：想抛一个有意义的异常，但这个异常系统没有提供，自定义一个
class PeopleNameError(Exception):  # Exception | BaseException
    # pass
    # 可以通过__init__明确外界的错误信息接收给那个属性
    # 再在__str__中格式化外界捕获异常，打印异常信息的格式
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return ‘PeopleNameError: ‘ + self.msg
?
def get_name():
    name = input(‘name: ‘)
    if ‘sb‘ in name.lower():
        raise PeopleNameError(‘人名不能有敏感词汇‘)
    return name
?
try:
    print(get_name())
except PeopleNameError as e:
    print(e)  # PeopleNameError: 人名不能有敏感词汇

断言

num = int(input(‘num: ‘))
assert num < 0  # 断言：只有满足断言条件，程序才能往下执行，反之抛出异常
print(abs(num))

__setattr__,__delattr__,__getattr__

class Foo:
    x=1
    def __init__(self,y):
        self.y=y

    def __getattr__(self, item):
        print(‘----> from getattr:你找的属性不存在‘)


    def __setattr__(self, key, value):
        print(‘----> from setattr‘)
        # self.key=value #这就无限递归了,你好好想想
        # self.__dict__[key]=value #应该使用它

    def __delattr__(self, item):
        print(‘----> from delattr‘)
        # del self.item #无限递归了
        self.__dict__.pop(item)

#__setattr__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)

#__delattr__删除属性的时候会触发
f1.__dict__[‘a‘]=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)

#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx

面向对象高级

标签：rop   资源   一句话   dex   停止   一些事   exception   ror   异常处理   

原文地址：https://www.cnblogs.com/zhangdajin/p/11145768.html