类--接口 抽象父类 多态 鸭子类型 格式化方法与析构方法 反射 异常处理 自定义异常 断言

面向对象与面向过程分析

面向过程：清晰知道操作的功能，但不明确操作的具体对象

面向对象：清晰知道操作的对象，但不明确具体的操作方法

# 面向过程
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()

# 抽象的类方法
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')

鸭子类型

需求：需要一个对象，该对象有name属性及speak方法，就可以作为一种状态的体现被传入

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就会被销毁')

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.如果没有手动处理异常，异常会交给Python解释器处理

　　　　　　-- 处理的方式就是打印异常信息，并停止解释器

异常信息的三部分： 
　　1.异常的追踪信息：提示错误位置 
　　2.异常的类型：告知处理异常应该捕获什么类型 
　　3.异常的内容：告知错误信息

　　　　处理异常的语法：

　　try:    
　　　　会出现异常的代码块 
　　except 异常类型 as 异常别名:    
　　　　异常处理逻辑 
　　else:     
　　　　没有出现异常会执行该分支 
　　finally:     
　　　　无论是否出现异常都会执行该分支

eg：

try:
    print('kss')
except NameError as e:
    print('异常信息：',e)
else:
    print('被检测的代码块正常')
finally:
    print('异常是否出现都会执行该分支')

异常语法

将可能出现异常的代码放在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))