Python全栈工程师（异常（高级）、运算符重载）
ParisGabriel 每天坚持手写一天一篇 决定坚持几年 为了梦想为了信仰 开局一张图 Python人工智能从入门到精通 对象的属性管理函数: getattr(obj, name[,default) 从对象得到对象的属性，getattr（x， “y”） 等同于x， y 当属性 不存在时 如果给出default参数则返回default 如果没有给出default ，则产生一个AttributeError错误 hasattr（obj， name）用给定的name返回对象obj是否有此属性 此种做法可以避免在getattr（obj，name）时引发错误 setattr(obj, name, value) 给对象obj的名为name的 属性设置相应的值value, set(x, 'y', v) 等同于 x.y = v delattr(obj, name) 删除对象obj中的name属性 , delattr(x, 'y') 等同于 del x.y 示例： class Dog: pass d = Dog() d.color = "白色" v = getattr(d, "color") # 等同于 v = d.color v = getattr(d, "kinds") # 出错,没有d.kinds属性 v = getattr(d, "kinds", "没有这个属性") # v= '没有这个属性' hasattr(d, 'color') # True hasattr(d, 'kinds') # False setattr(d, 'kinds', '京巴') # 等同于d.kinds ='京巴' hasattr(d, 'kinds') # True delattr(d, 'kinds') # 等同于 del d.kinds hasattr(d, 'kinds') # False 异常（高级）： 可以用于异常的语句 try-except # 捕获异常，得到通知 try-finally # 左任何流程（正常/异常）都必须执行要执行的语句 raise # 发送异常 assert # 根据条件发送异常通知with 语句： 语法： with 表达式1[as 变量1]， 表达式2[as 变量2].... 作用： 使用与对资源进行访问的场合，确保使用过程中不管 是否发生异常都会执行必要的“清理操作”，并释放资源 （如： 文件使用后自动关闭，线程中锁的自动获取和释放等） 说明： 执行表达式，as子句中的变量绑定生成的对象 with语句并不改变异常的状态示例： # with语句打开文件和自动关闭 try: with open("a.txt") as f: for x in f: print(x) int("abc") # 出现异常 except OSError: print("文件打开失败") except ValueError: print("文件操作过程中错误") # try-finally语句打开文件和关闭 try: f = open("a.txt") for x in f: print(x) except OSError: print("打开文件失败") except ValueError: print("文件操作过程中错误") finally: f.close() # 修改原来的copy文件功能 src_filename = input("请输入源文件路径名: ") dst_filename = input('请输入目标文件路径名: ') try: with open(src_filename, 'rb') as src,\ open(dst_filename, 'wb') as dst: # 打开源文件用来读数据 while True: b = src.read(4096) if not b: # 已经再也读不到数据了 break dst.write(b) print("复制成功") except OSError: print("复制失败") 环境管理器： 类内有__enter__和__exit__实例方法的类被称为环境管理器 能够用with进行管理的对象必须是环境管理器 说明： __enter__将在进入with语句时被调用并返回由as变量绑定的对象 __exit__将在离开with语句时被调用，且可以用参数来判断在 离开with语句时是否有异常发生并作出相应的处理示例： # 一个自定义的类创建的对象能够使用ｗｉｔｈ语句 class A: '''此类的对象可用于ｗｉｔｈ语句进行管理''' def __enter__(self): print("已经进入ｗｉｔｈ语句中，资源分配成功") return self # <<<-- 此处返回的对象将由as变量绑定 def __exit__(self, exc_type, exc_val, exc_tb): print("离开ｗｉｔｈ语句,资源释放成功") if exc_type is None: print("当离开ｗｉｔｈ语句时没有异常") else: print("有异常发生 异常类型：",exc_type , "异常值：", exc_val) with A() as a: print("这是ｗｉｔｈ语句中的语句") raise ValueError("故意制造的异常") 运算符重载： 什么是运算符重载 让自定义的类生成的对象（实例）能够使用运算符进行操作 作用： 1.让自定义的类的实例能够运行运算符操作 2.让程序简洁易读 3.对定义对象将运算符赋予新的运算规则 说明： 运算符重载方法的参数已经有固定含义，不建议改变原有的含义 算数运算符重载： 方法名 运算符和表达式 说明__add__(self, rhs) self + rsh 加法__sub__(self, rhs) self - rsh 减法__mul__(self, rhs) self * rsh 乘法__truediv__(self, rhs) self / rsh 除法__floordiv__(self, rhs) self // rsh 地板除__mod__(self, rhs) self % rsh 求模__pow__(self, rhs) self ** rsh 幂 rhs（self hand side） 右手边 示例： class MyNumber: def __init__(self, val): self.data = val def __repr__(self): return "%d" % self.data def __add__(self, rsh): v = self.data + rsh.data return MyNumber(v) def __sub__(self, rsh): return MyNumber(self.data - rsh.data) n1 = MyNumber(100) n2 = MyNumber(200) n3 = n1 + n2 # 等同于 n3 = n1.__add__(n2) # n3 = n1.__add__(n2) print(t(n1, "-", n2, "=", n1 - n2) 反向算术运算符的重载 当运算符的左侧为内建类型,右侧为自义类型的对象进行算术运算符运算时,会出现TypeError错误, 因无法修改内建类的代码来实现运算符重载,此时需要使用反向算术运算符重载 反向算术运算符重载 方法名 运算符和表达式 说明__radd__(self, lhs) lhs + self 加法__rsub__(self, lhs) lhs - self 减法__rmul__(self, lhs) lhs * self 乘法__rtruediv__(self, lhs) lhs / self 除法__rfloordiv__(self, lhs) lhs // self 地板除__rmod__(self, lhs) lhs % self 取模(求余)__rpow__(self, lhs) lhs ** self 幂 lhs(left hand side) 右手边 示例： # 此示例示意返向算述运算符的重载 class MyList: def __init__(self, lst=[]): '''在初始化方法内为每个对象都创建一个bata属性 bata 用来绑定每个对象自己的列表 ''' self.beta = [x for x in lst] # self.bata = list(lst) def __repr__(self): return "%s" % self.beta def __mul__(self, rhs): return MyList(self.beta * rhs) print("__mul__ 被到调用") def __rmul__(self, lhs): print("__rmul__ 被到调用") return MyList(self.beta * lhs) # 反向传参 L1 = MyList([1, 2, 3]) L2 = MyList(range(4, 7)) L3 = 2 * L1 # L1.__rmul__(2) print(L3) L5 = L1 * 2 # L5 = L1.__mul__(2) print(L5) # MyList([1, 2, 3, 1, 2, 3]) 复合赋值算术运算符的重载 以复合赋值算术运算符 x += y 为例,此运算会优先调用x.__iadd__(y) 方法, 如果没有__iadd__方法时会将复合赋值运算拆解为 x = x + y,然后调用x = x.__add__(y) 方法 如果再不存在 __add__方法则会触发TypeError异常 其它复合赋值运算符也具有相同的规则 复合赋值算术运算符重载 方法名 运算符和表达式 说明__iadd__(self, lhs) lhs += self 加法__isub__(self, lhs) lhs -= self 减法__imul__(self, lhs) lhs *= self 乘法__itruediv__(self,lhs) lhs /= self 除法__ifloordiv__(self, lhs) lhs //= self 地板除__imod__(self, lhs) lhs %= self 取模(求余)__ipow__(self, lhs) lhs **= self 幂 示例： class MyList: def __init__(self, lst=[]): '''在初始化方法内为每个对象都创建一个bata属性 bata 用来绑定每个对象自己的列表 ''' # self.beta = [x for x in lst] self.bata = list(lst) def __repr__(self): return "%s" % self.beta def __iadd__(self, rhs): self.beta += rhs.beta # id不变 return self def __add__(self, rhs): return MyList(self.beta + rhs.beta) # id会不变 L = MyList([1, 2, 3]) def f1(lst): lst += MyList([4, 5, 6]) f1(L) print(L) 复合赋值算术运算符重载 方法名 运算符和表达式 说明__lt__(self, rhs) self < rhs 小于__le__(self, rhs) self <= rhs 小于等于__gt__(self, rhs) self > rhs 大于__ge__(self, rhs) self >= rhs 大于等于__eq__(self, rhs) self == rhs 等于__ne__(self, rhs) self != rhs 不等于示例： # 此示例示意比较运算符的重载 class MyList: def __init__(self, iterable): self.data = list(iterable) def __repr__(self): return 'MyList(%s)' % self.data def __eq__(self, rhs): return self.data == rhs.data def __gt__(self, rhs): return self.data > rhs.data L1 = MyList([1, 2, 3]) L2 = MyList([1, 2, 3]) print(L1 == L2) # True print(L1 > L2) # False # print(L1 == L2) # 如果没有__eq__ 方法判断两个对象的id # print(L1 > L2) # 如果没有__gt__ 方法报错 位运算符重载 方法名 运算符和表达式 说明 __invert__(self) ~ self 取反(一元运算符) __and__(self, rhs) self & rhs 位与 __or__(self, rhs) self | rhs 位或 __xor__(self, rhs) self ^ rhs 位异或 __lshift__(self, rhs) self << rhs 左移 __rshift__(self, rhs) self >> rhs 右移 反向位运算符重载 方法名 运算符和表达式 说明 __rand__(self, lhs) lhs & self 位与 __ror__(self, lhs) lhs | self 位或 __rxor__(self, lhs) lhs ^ self 位异或 __rlshift__(self, lhs) lhs << self 左移 __rrshift__(self, lhs) lhs >> self 右移 复合赋值位运算符重载 方法名 运算符和表达式 说明 __iand__(self, rhs) self &= rhs 位与 __ior__(self, rhs) self |= rhs 位或 __ixor__(self, rhs) self ^= rhs 位异或 __ilshift__(self, rhs) self <<= rhs 左移 __irshift__(self, rhs) self >>= rhs 右移 一元运算符重载 方法名 运算符和表达式 说明 __invert__(self) ~ self 取反(一元运算符) __pos__(self) + self 正号 __neg__(self) - self 负号 语法: def __xxx__(self): 示例： # 此示例示意一元运算符的重载 class MyList: def __init__(self, lst=[]): '''在初始化方法内为每个对象都创建一个bata属性 bata 用来绑定每个对象自己的列表 ''' self.beta = [x for x in lst] # self.bata = list(lst) def __repr__(self): return "%s" % self.beta def __neg__(self): return MyList((-x for x in self.beta)) def __pos__(self): return MyList((abs(x) for x in self.beta)) # L = [] # for x in self.beta: # if x > 0: # L.append(x) # else: # L.append(-x) # return MyList(L) L1 = MyList([1, -2, 3, -4, 5]) L2 = -L1 print(L2) # MyList([-1, 2, -3, 4, -5]) # 实现用正号运算符返回全部元素为正数的自定义列表 L3 = + L1 print(L3) # MyList([1, 2, 3, 4, 5]) in / not in 运算符重载重载方法:def __contains__(self, e):....示例： # in not in 重载 class MyList: def __init__(self, lst=[]): '''在初始化方法内为每个对象都创建一个bata属性 bata 用来绑定每个对象自己的列表 ''' self.beta = [x for x in lst] # self.bata = list(lst) def __repr__(self): return "%s" % self.beta def __contains__(self, e): return e in self.beta L1 = MyList([1, 2, -3, 4, -5]) print(2 in L1) print(3 in L1) print(4 in L1) print(5 in L1) 索引和切片运算符的重载 方法名 运算符和表达式 说明 __getitem__(self, i) x = self[i] 索引/切片取值 __setitem__(self, i, val) self[i] = val 索引/切片赋值 __delitem__(self, i) del self[i] 删除索引/切片 作用:让自定义的类的对象能够支持索引和切片操作示例： # 此示例示意 索引/切片 运算符的重载 class MyList: def __init__(self, iterable): self.data = list(iterable) def __repr__(self): return 'MyList(%s)' % self.data def __getitem__(self, i): print("索引i的值是:", i) return self.data[i] def __setitem__(self, i, v): print("__setitem__被调用, i=", i, 'v=', v) self.data[i] = v def __delitem__(self, i): del self.data[i] L1 = MyList([1, -2, 3, -4, 5]) v = L1[2] # v = 3 print(v) # 3 L1[1] = 2 print(L1) # MyList([1, 2, 3, -4, 5]) del L1[3] print(L1) # MyList([1, 2, 3, 5]) slice 函数: 作用: 用于创建一个slice切片对象,此对象存储切片的信息 格式: slice(start=None, stop=None, step=None) slice对象的属性 s.start 切片的起始值, 默认为None s.stop 切片的终止值, 默认为None s.step 切片的步长, 默认为None示例： # 此示例示意 索引/切片 运算符的重载 class MyList: def __init__(self, iterable): self.data = list(iterable) def __repr__(self): return 'MyList(%s)' % self.data def __getitem__(self, i): print("索引i的值是:", i) if type(i) is int: print("正在进行索引操作") elif type(i) is slice: print("正在进行切片操作") print("起始值是:", i.start) print("终止值是:", i.stop) print("步长值是:", i.step) return self.data[i] def __setitem__(self, i, v): print("__setitem__被调用, i=", i, 'v=', v) self.data[i] = v def __delitem__(self, i): del self.data[i] L1 = MyList([1, -2, 3, -4, 5]) L2 = L1[::2] print(L2) 特性属性 @property 实现其它语言所拥有的 getter 和 setter 的功能 作用: 用来模拟一个属性 通过@property 装饰器可以对模拟属性的取值和赋值加以控制 示例见: 示例： class Student: def __init__(self, s): self.__score = s # 私有属性,不让其它人任意修改成绩 @property def score(self): '''伪装模拟私有一个成绩属性 并返回成绩''' return self.__score @score.setter def score(self, v): '''实现设置者setter , 对用户的复制加以限制''' assert 0 <= v <= 100, "成绩不合法" self.__score = v s = Student(59) print(s.score) # 希望有一个属性能得到成绩 虚拟属性不能复制 s.score = 80 # 通过s.score 来修改成绩 print(s.score) # 修改成功 s.score看似属性 是模拟属性 实际内部已经被替换 问题: L = [1, 2, 3] def f1(lst): lst += [4, 5, 6] f1(L) print(L) # [1, 2, 3, 4, 5, 6] 为什么 L = (1, 2, 3) def f1(lst): lst += (4, 5, 6) # lst = lst + (4, 5, 6) f1(L) print(L) # (1, 2, 3) 为什么 练习: 1. 实现两个自定义的列表相加 class MyList: .... 此处自己实现 L1 = MyList([1, 2, 3]) L2 = MyList(range(4, 7)) L3 = L1 + L2 print(L3) # MyList([1, 2, 3, 4, 5, 6]) L4 = L2 + L1 print(L4) # MyList([4, 5, 6, 1, 2, 3]) L5 = L1 * 2 print(L5) # MyList([1, 2, 3, 1, 2, 3]) 练习: 实现有序集合类 OrderSet() 能实现两个集合的交集 &,全集 |, 补集 - 对称补集 ^, ==/!= , in/ not in 等操作 要求集合内部用 list 存储 class OrderSet: ... s1 = OrderSet([1, 2, 3, 4]) s2 = OrderSet([3, 4, 5]) print(s1 & s2) # OrderSet([3, 4]) print(s1 | s2) # OrderSet([1, 2, 3, 4, 5]) print(s1 ^ s2) # OrderSet([1, 2, 5]) if OrderSet([1, 2, 3]) != OrderSet([3, 4, 5]): print("不相等") if s2 == OrderSet(3, 4, 5): print('s2 == OrderSet(3, 4, 5) is True') if 2 in s1: print("2在 s1中")
