# 清晰知道操作的功能，但不明确操作的具体对象
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): passdef chi(self): passdef 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.abstractmethoddef func(self): passclass 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.abstractmethoddef chi(self): pass@abc.abstractmethoddef jiao(self): passclass 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()

# 抽象的类方法
import abc
class Sup(metaclass=abc.ABCMeta):@classmethod@abc.abstractmethoddef func(cls): passclass Sub(Sup):@classmethoddef func(cls): # 必须重写父类的抽象方法

了了解

import abc
class People(metaclass=abc.ABCMeta):def __init__(self, name):self.name = name@abc.abstractmethoddef speak(self): passclass 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 = namedef speak(self): print('说AAAA')class B:# 能有自己特有的属性和方法，可以和A完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型def __init__(self, name):self.name = namedef speak(self): print('说BBBB')ask_someone(B('B'))
------------------------------------
def fn(arg):passdef speak():print('你好！')fn.name = '来福'
fn.speak = speak

class A:def __init__(self, name, age):self.name = nameself.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] = valueb = 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
print(hasattr(b, 'name'))
print(getattr(b, 'name', '对象的属性类不能获取'))
delattr(b, 'name')
print(setattr(b, 'age', 18))
# 对象的属性对象来操作class C:def fn(self):print('fn')@classmethoddef func(cls):print('func')fn = getattr(C, 'fn')
c = C()
fn(c)  # 类获取对象方法调用时传入具体的对象

obj_fn = getattr(c, 'fn')
obj_fn()  # 对象获取对象方法调用时不用传参

func = getattr(C, 'func')
func()  # 类获取类方法调用时不需要传入参数

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])  # IndexErrorls.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])  # IndexErrorls.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 = msgdef __str__(self):return 'PeopleNameError: ' + self.msgdef get_name():name = input('name: ')if 'sb' in name.lower():raise PeopleNameError('人名不能有敏感词汇')return nametry:print(get_name())
except PeopleNameError as e:print(e)  # PeopleNameError: 人名不能有敏感词汇

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