类--接口 抽象父类 多态 鸭子类型 格式化方法与析构方法 反射 异常处理 自定义异常 断言
# 面向过程 print(len('123'))
# 面向对象
print('123'.__len__())
# 提供所有宠物应该有的功能 class PetInterface: def close_master(self): pass # 提供所有看门应该有的功能 class WatchInterface: def watch_door(self): pass # 没有去继承PetInterface,WatchInterface的Dog就是普通的Dog类 # 但继承了PetInterface,该Dog就可以作为宠物狗,同理继承WatchInterface就可以作为看门狗 class Dog(PetInterface, WatchInterface): def jiao(self): pass def chi(self): pass def pao(self): pass # 一定要重写接口的方法 pass # 可以作为宠物及看门猫 class Cat(PetInterface, WatchInterface): pass
注意:有抽象方法的父类不能被实例化(假设能被实例化,就可以调用自己的抽象方法,没有任何意义)
# 实现抽象父类的语法 import abc# abstract base class class Sup(metaclass=abc.ABCMeta): # 借助abc(abstract base class)实现抽象父类 # 抽象父类中的抽象方法,在继承它的子类中必须有自己的实现体 # -- 抽象父类中的抽象方法实现体就没有意义,实现与不实现都是pass填充 @abc.abstractmethod def func(self): pass class Sub(Sup): def func(self): # 必须重写父类的抽象方法 # 案例 import abc class Quan(metaclass=abc.ABCMeta): def __init__(self, name): self.name = name # 共有方法,子类继承就可以了 def run(self): print(self.name + 'running') # 抽象方法:子类必须重写 @abc.abstractmethod def chi(self): pass @abc.abstractmethod def jiao(self): pass class Dog(Quan): def kanmen(self): print(self.name + '看门') def chi(self): super().chi() print(self.name + '狗粮') def jiao(self): print('汪汪汪') class Wolf(Quan): def bulie(self): print(self.name + '捕猎') def chi(self): print(self.name + '肉') def jiao(self): print('嗷嗷嗷') dog = Dog('来福') wolf = Wolf('呵呵') dog.jiao() wolf.jiao() dog.run() wolf.run()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# 抽象的类方法 import abc class Sup(metaclass=abc.ABCMeta): @classmethod @abc.abstractmethod def func(cls): pass class Sub(Sup): @classmethod def func(cls): # 必须重写父类的抽象方法
import abc class People(metaclass=abc.ABCMeta): def __init__(self, name): self.name = name @abc.abstractmethod def speak(self): pass class Chinese(People): def speak(self): print('说中国话') class England(People): def speak(self): print('说英国话') if __name__ == '__main__': # 多态的体现:功能或是需求,需要父类的对象,可以传入父类对象或任意子类对象 # 注:一般都是规定需要父类对象,传入子类对象 def ask_someone(obj): print('让%s上台演讲' % obj.name) # 父类提供,自己直接继承 obj.speak() # 父类提供,只不过子类重写了 ch = Chinese('王大锤') en = England('Tom') # 传入Chinese | England均可以,因为都是People的一种状态(体现方式) ask_someone(ch) ask_someone(en) # 传入str不可以,因为str的对象没有name和speak # s = str('白骨精') # ask_someone(s) # p = People('kkk')
def ask_someone(obj): print('让%s上台演讲' % obj.name) obj.speak() # 鸭子类型: # 1.先规定:有什么属性及什么方法的类的类型叫鸭子类型 # 2.这些类实例化出的对象,都称之为鸭子,都可以作为需求对象的一种具体体现 class A: # 能有自己特有的属性和方法,可以和B完全不一样,但是必须有鸭子类型规定的属性和方法,不然就不是鸭子类型 def __init__(self, name): self.name = name def speak(self): print('说AAAA') class B: # 能有自己特有的属性和方法,可以和A完全不一样,但是必须有鸭子类型规定的属性和方法,不然就不是鸭子类型 def __init__(self, name): self.name = name def speak(self): print('说BBBB') ask_someone(B('B'))
------------------------------------ def fn(arg): pass def speak(): print('你好!') fn.name = '来福' fn.speak = speak
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就会被销毁')
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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' # 内部走的是 b.__setattr__('name','BBB') b['age'] = 18 # 内部走的是 b.__setitem__('age', 18) # 访问 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
b = B('bob') 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.异常的内容:告知错误信息
try:
会出现异常的代码块
except 异常类型 as 异常别名:
异常处理逻辑
else:
没有出现异常会执行该分支
finally:
无论是否出现异常都会执行该分支
eg:
try: print('kss') except NameError as e: print('异常信息:',e) else: print('被检测的代码块正常') finally: print('异常是否出现都会执行该分支')
# 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))
修改属性
1)根据描述输出错误信息或是打印信息;
2)输出e有没有属性age,True或者False;输出printclass打印信息。
class Employee: def __init__(self, name, salary) -> None: self.name = name self.salary = salary def printclass(self): try: print(f"{self.name}'salary is {self.salary}, and his age is {self.age}") except: print("Error! No age") def printclass2(self): has_age = hasattr(self, 'age') print(has_age) if not has_age: setattr(self, 'age', input()) # self.age = input() print(f"{self.name}'salary is {self.salary}, and his age is {self.age}") e = Employee(input(), input()) e.printclass() e.printclass2()
输入: NiuNiu 8000 22 输出: Error! No age False NiuNiu'salary is 4000, and his age is 23
重载运算
输入两组横纵坐标x和y,将其初始化为两个Coordinate类的实例c1和c2,并将坐标相加后输出结果。
class Coordinate(): def __init__(self, x, y) -> None: self.x = x self.y = y def __str__(self) -> str: return f'({self.x}, {self.y})' def __add__(self, obj): return Coordinate(self.x + obj.x, self.y + obj.y) def get_arg(): return list(map(int, input().split()))
c1 = Coordinate(*get_arg()) c2 = Coordinate(*get_arg()) print(c1.__add__(c2)) # c = c1 + c2 # print(c.__str__()) # print(c)
输入:
1 2
3 4
输出:
(4, 6)